Update FUNSD.py

FUNSD.py

@@ -36,6 +36,18 @@ def load_image(image_path):
     image = image.transpose(2, 0, 1) # move channels to first dimension
     return image, (w, h)
 
+def simplify_bbox(bbox):
+    return [
+        min(bbox[0::2]),
+        min(bbox[1::2]),
+        max(bbox[2::2]),
+        max(bbox[3::2]),
+    ]
+
+
+def merge_bbox(bbox_list):
+    x0, y0, x1, y1 = list(zip(*bbox_list))
+    return [min(x0), min(y0), max(x1), max(y1)]
 
 def normalize_bbox(bbox, size):
     return [
@@ -72,12 +84,27 @@ class Funsd(datasets.GeneratorBasedBuilder):
                     "id": datasets.Value("string"),
                     "tokens": datasets.Sequence(datasets.Value("string")),
                     "bboxes": datasets.Sequence(datasets.Sequence(datasets.Value("int64"))),
-                    "ner_tags": datasets.Sequence(
+                    "labels": datasets.Sequence(
                         datasets.features.ClassLabel(
                             names=["O", "B-HEADER", "I-HEADER", "B-QUESTION", "I-QUESTION", "B-ANSWER", "I-ANSWER"]
                         )
                     ),
                     "image": datasets.Array3D(shape=(3, 224, 224), dtype="uint8"),
+                    "entities": datasets.Sequence(
+                        {
+                            "start": datasets.Value("int64"),
+                            "end": datasets.Value("int64"),
+                            "label": datasets.ClassLabel(names=["HEADER", "QUESTION", "ANSWER"]),
+                        }
+                    ),
+                    "relations": datasets.Sequence(
+                        {
+                            "head": datasets.Value("int64"),
+                            "tail": datasets.Value("int64"),
+                            "start_index": datasets.Value("int64"),
+                            "end_index": datasets.Value("int64"),
+                        }
+                    ),
                 }
             ),
             supervised_keys=None,
@@ -104,8 +131,11 @@ class Funsd(datasets.GeneratorBasedBuilder):
         for guid, file in enumerate(sorted(os.listdir(ann_dir))):
             tokens = []
             bboxes = []
-            ner_tags = []
-
+            labels = []
+            entities = []
+            relations = []
+            entity_id_to_index_map = {}
+            empty_entity = set()
             file_path = os.path.join(ann_dir, file)
             with open(file_path, "r", encoding="utf8") as f:
                 data = json.load(f)
@@ -115,20 +145,276 @@ class Funsd(datasets.GeneratorBasedBuilder):
             for item in data["form"]:
                 words, label = item["words"], item["label"]
                 words = [w for w in words if w["text"].strip() != ""]
+                relations.extend([tuple(sorted(l)) for l in item["linking"]])
+                tokenized_inputs = self.tokenizer(
+                    item["text"],
+                    add_special_tokens=False,
+                    return_offsets_mapping=True,
+                    return_attention_mask=False,
+                )
+                text_length = 0
+                ocr_length = 0
+                bbox = []
+                last_box = None
+                for token_id, offset in zip(tokenized_inputs["input_ids"], tokenized_inputs["offset_mapping"]):
+                    if token_id == 6:
+                        bbox.append(None)
+                        continue
+                    text_length += offset[1] - offset[0]
+                    tmp_box = []
+                    while ocr_length < text_length:
+                        ocr_word = item["words"].pop(0)
+                        ocr_length += len(
+                            self.tokenizer._tokenizer.normalizer.normalize_str(ocr_word["text"].strip())
+                        )
+                        tmp_box.append(simplify_bbox(ocr_word["box"]))
+                    if len(tmp_box) == 0:
+                        tmp_box = last_box
+                    bbox.append(normalize_bbox(merge_bbox(tmp_box), size))
+                    last_box = tmp_box
+                bbox = [
+                    [bbox[i + 1][0], bbox[i + 1][1], bbox[i + 1][0], bbox[i + 1][1]] if b is None else b
+                    for i, b in enumerate(bbox)
+                ]
+                tokenized_inputs.update({"bbox": bbox, "labels": label})
+                if label[0] != "O":
+                    entity_id_to_index_map[line["id"]] = len(entities)
+                    entities.append(
+                        {
+                            "start": len(tokenized_doc["input_ids"]),
+                            "end": len(tokenized_doc["input_ids"]) + len(tokenized_inputs["input_ids"]),
+                            "label": line["label"].upper(),
+                        }
+                    )
+                    
+                for i in tokenized_doc:
+                    tokenized_doc[i] = tokenized_doc[i] + tokenized_inputs[i]
+                relations = list(set(relations))
+            relations = [rel for rel in relations if rel[0] not in empty_entity and rel[1] not in empty_entity]
+            kvrelations = []
+            for rel in relations:
+                pair = [id2label[rel[0]], id2label[rel[1]]]
+                if pair == ["question", "answer"]:
+                    kvrelations.append(
+                        {"head": entity_id_to_index_map[rel[0]], "tail": entity_id_to_index_map[rel[1]]}
+                    )
+                elif pair == ["answer", "question"]:
+                    kvrelations.append(
+                        {"head": entity_id_to_index_map[rel[1]], "tail": entity_id_to_index_map[rel[0]]}
+                    )
+                else:
+                    continue
+
+            def get_relation_span(rel):
+                bound = []
+                for entity_index in [rel["head"], rel["tail"]]:
+                    bound.append(entities[entity_index]["start"])
+                    bound.append(entities[entity_index]["end"])
+                return min(bound), max(bound)
+
+            relations = sorted(
+                [
+                    {
+                        "head": rel["head"],
+                        "tail": rel["tail"],
+                        "start_index": get_relation_span(rel)[0],
+                        "end_index": get_relation_span(rel)[1],
+                    }
+                    for rel in kvrelations
+                ],
+                key=lambda x: x["head"],
+            )
+            chunk_size = 512
+            for chunk_id, index in enumerate(range(0, len(tokenized_doc["input_ids"]), chunk_size)):
+                item = {}
+                for k in tokenized_doc:
+                    item[k] = tokenized_doc[k][index : index + chunk_size]
+                entities_in_this_span = []
+                global_to_local_map = {}
+                for entity_id, entity in enumerate(entities):
+                    if (
+                        index <= entity["start"] < index + chunk_size
+                        and index <= entity["end"] < index + chunk_size
+                    ):
+                        entity["start"] = entity["start"] - index
+                        entity["end"] = entity["end"] - index
+                        global_to_local_map[entity_id] = len(entities_in_this_span)
+                        entities_in_this_span.append(entity)
+                relations_in_this_span = []
+                for relation in relations:
+                    if (
+                        index <= relation["start_index"] < index + chunk_size
+                        and index <= relation["end_index"] < index + chunk_size
+                    ):
+                        relations_in_this_span.append(
+                            {
+                                "head": global_to_local_map[relation["head"]],
+                                "tail": global_to_local_map[relation["tail"]],
+                                "start_index": relation["start_index"] - index,
+                                "end_index": relation["end_index"] - index,
+                            }
+                        )
+                item.update(
+                    {
+                        "id": f"{doc['id']}_{chunk_id}",
+                        "image": image,
+                        "entities": entities_in_this_span,
+                        "relations": relations_in_this_span,
+                    }
+                )
                 if len(words) == 0:
                     continue
                 if label == "other":
                     for w in words:
                         tokens.append(w["text"])
-                        ner_tags.append("O")
+                        labels.append("O")
                         bboxes.append(normalize_bbox(w["box"], size))
                 else:
                     tokens.append(words[0]["text"])
-                    ner_tags.append("B-" + label.upper())
+                    labels.append("B-" + label.upper())
                     bboxes.append(normalize_bbox(words[0]["box"], size))
                     for w in words[1:]:
                         tokens.append(w["text"])
-                        ner_tags.append("I-" + label.upper())
+                        labels.append("I-" + label.upper())
                         bboxes.append(normalize_bbox(w["box"], size))
 
-            yield guid, {"id": str(guid), "tokens": tokens, "bboxes": bboxes, "ner_tags": ner_tags, "image": image}
+            yield guid, {"id": str(guid), "tokens": tokens, "bboxes": bboxes, "labels": labels, "image": image, "image": image, "image": image}logger.info("Generating examples from = %s", filepath)
+        ann_dir = os.path.join(filepath, "annotations")
+        img_dir = os.path.join(filepath, "images")
+        for guid, file in enumerate(sorted(os.listdir(ann_dir))):
+            doc["img"]["fpath"] = os.path.join(filepath[1], doc["img"]["fname"])
+            image, size = load_image(doc["img"]["fpath"])
+            document = doc["document"]
+            tokenized_doc = {"input_ids": [], "bbox": [], "labels": []}
+            entities = []
+            relations = []
+            id2label = {}
+            entity_id_to_index_map = {}
+            empty_entity = set()
+            for line in document:
+                if len(line["text"]) == 0:
+                    empty_entity.add(line["id"])
+                    continue
+                id2label[line["id"]] = line["label"]
+                relations.extend([tuple(sorted(l)) for l in line["linking"]])
+                tokenized_inputs = self.tokenizer(
+                    line["text"],
+                    add_special_tokens=False,
+                    return_offsets_mapping=True,
+                    return_attention_mask=False,
+                )
+                text_length = 0
+                ocr_length = 0
+                bbox = []
+                last_box = None
+                for token_id, offset in zip(tokenized_inputs["input_ids"], tokenized_inputs["offset_mapping"]):
+                    if token_id == 6:
+                        bbox.append(None)
+                        continue
+                    text_length += offset[1] - offset[0]
+                    tmp_box = []
+                    while ocr_length < text_length:
+                        ocr_word = line["words"].pop(0)
+                        ocr_length += len(
+                            self.tokenizer._tokenizer.normalizer.normalize_str(ocr_word["text"].strip())
+                        )
+                        tmp_box.append(simplify_bbox(ocr_word["box"]))
+                    if len(tmp_box) == 0:
+                        tmp_box = last_box
+                    bbox.append(normalize_bbox(merge_bbox(tmp_box), size))
+                    last_box = tmp_box
+                bbox = [
+                    [bbox[i + 1][0], bbox[i + 1][1], bbox[i + 1][0], bbox[i + 1][1]] if b is None else b
+                    for i, b in enumerate(bbox)
+                ]
+                if line["label"] == "other":
+                    label = ["O"] * len(bbox)
+                else:
+                    label = [f"I-{line['label'].upper()}"] * len(bbox)
+                    label[0] = f"B-{line['label'].upper()}"
+                tokenized_inputs.update({"bbox": bbox, "labels": label})
+                if label[0] != "O":
+                    entity_id_to_index_map[line["id"]] = len(entities)
+                    entities.append(
+                        {
+                            "start": len(tokenized_doc["input_ids"]),
+                            "end": len(tokenized_doc["input_ids"]) + len(tokenized_inputs["input_ids"]),
+                            "label": line["label"].upper(),
+                        }
+                    )
+                for i in tokenized_doc:
+                    tokenized_doc[i] = tokenized_doc[i] + tokenized_inputs[i]
+            relations = list(set(relations))
+            relations = [rel for rel in relations if rel[0] not in empty_entity and rel[1] not in empty_entity]
+            kvrelations = []
+            for rel in relations:
+                pair = [id2label[rel[0]], id2label[rel[1]]]
+                if pair == ["question", "answer"]:
+                    kvrelations.append(
+                        {"head": entity_id_to_index_map[rel[0]], "tail": entity_id_to_index_map[rel[1]]}
+                    )
+                elif pair == ["answer", "question"]:
+                    kvrelations.append(
+                        {"head": entity_id_to_index_map[rel[1]], "tail": entity_id_to_index_map[rel[0]]}
+                    )
+                else:
+                    continue
+
+            def get_relation_span(rel):
+                bound = []
+                for entity_index in [rel["head"], rel["tail"]]:
+                    bound.append(entities[entity_index]["start"])
+                    bound.append(entities[entity_index]["end"])
+                return min(bound), max(bound)
+
+            relations = sorted(
+                [
+                    {
+                        "head": rel["head"],
+                        "tail": rel["tail"],
+                        "start_index": get_relation_span(rel)[0],
+                        "end_index": get_relation_span(rel)[1],
+                    }
+                    for rel in kvrelations
+                ],
+                key=lambda x: x["head"],
+            )
+            chunk_size = 512
+            for chunk_id, index in enumerate(range(0, len(tokenized_doc["input_ids"]), chunk_size)):
+                item = {}
+                for k in tokenized_doc:
+                    item[k] = tokenized_doc[k][index : index + chunk_size]
+                entities_in_this_span = []
+                global_to_local_map = {}
+                for entity_id, entity in enumerate(entities):
+                    if (
+                        index <= entity["start"] < index + chunk_size
+                        and index <= entity["end"] < index + chunk_size
+                    ):
+                        entity["start"] = entity["start"] - index
+                        entity["end"] = entity["end"] - index
+                        global_to_local_map[entity_id] = len(entities_in_this_span)
+                        entities_in_this_span.append(entity)
+                relations_in_this_span = []
+                for relation in relations:
+                    if (
+                        index <= relation["start_index"] < index + chunk_size
+                        and index <= relation["end_index"] < index + chunk_size
+                    ):
+                        relations_in_this_span.append(
+                            {
+                                "head": global_to_local_map[relation["head"]],
+                                "tail": global_to_local_map[relation["tail"]],
+                                "start_index": relation["start_index"] - index,
+                                "end_index": relation["end_index"] - index,
+                            }
+                        )
+                item.update(
+                    {
+                        "id": f"{doc['id']}_{chunk_id}",
+                        "image": image,
+                        "entities": entities_in_this_span,
+                        "relations": relations_in_this_span,
+                    }
+                )
+                yield f"{doc['id']}_{chunk_id}", item