Update FUNSD.py

FUNSD.py

@@ -2,11 +2,13 @@
 
 import json
 import os
+import logging
 
 import datasets
 
 from PIL import Image
 import numpy as np
+
 from transformers import AutoTokenizer
 
 logger = datasets.logging.get_logger(__name__)
@@ -27,14 +29,15 @@ _DESCRIPTION = """\
 https://guillaumejaume.github.io/FUNSD/
 """
 
-def load_image(image_path):
+def load_image(image_path, size=None):
     image = Image.open(image_path).convert("RGB")
     w, h = image.size
-    # resize image to 224x224
-    image = image.resize((224, 224))
-    image = np.asarray(image)  
-    image = image[:, :, ::-1] # flip color channels from RGB to BGR
-    image = image.transpose(2, 0, 1) # move channels to first dimension
+    if size is not None:
+        # resize image
+        image = image.resize((size, size))
+        image = np.asarray(image)  
+        image = image[:, :, ::-1] # flip color channels from RGB to BGR
+        image = image.transpose(2, 0, 1) # move channels to first dimension
     return image, (w, h)
 
 def simplify_bbox(bbox):
@@ -99,6 +102,14 @@ class Funsd(datasets.GeneratorBasedBuilder):
                             "label": datasets.ClassLabel(names=["HEADER", "QUESTION", "ANSWER"]),
                         }
                     ),
+                    "original_image": datasets.features.Image(),
+                    "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"),
@@ -131,33 +142,33 @@ class Funsd(datasets.GeneratorBasedBuilder):
         ann_dir = os.path.join(filepath, "annotations")
         img_dir = os.path.join(filepath, "images")
         for guid, file in enumerate(sorted(os.listdir(ann_dir))):
-            words = []
-            bboxes = []
-            labels = []
+            doc_id = file.split(".")[0]
+            file_path = os.path.join(ann_dir, file)
+            with open(file_path, "r", encoding="utf8") as f:
+                document = json.load(f)
+            image_path = os.path.join(img_dir, file)
+            image_path = image_path.replace("json", "png")
+            image, size = load_image(image_path, size=224)
+            original_image, _ = load_image(image_path)
+
+            
+            document = document["form"]
             tokenized_doc = {"input_ids": [], "bbox": [], "labels": []}
             entities = []
             relations = []
+            # image id to label dict
             id2label = {}
             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)
-            image_path = os.path.join(img_dir, file)
-            image_path = image_path.replace("json", "png")
-            image, size = load_image(image_path)
-            for item in data["form"]:
-                words_example, label = item["words"], item["label"]
-                words_example = [w for w in words_example if w["text"].strip() != ""]
-                if len(words_example) == 0:
-                    continue
-                if len(item["text"]) == 0:
-                    empty_entity.add(item["id"])
+            for line in document:
+                # word navako text lai empty_entity ma add garne
+                if len(line["text"]) == 0:
+                    empty_entity.add(line["id"])
                     continue
-                id2label[item["id"]] = item["label"]
-                relations.extend([tuple(sorted(l)) for l in item["linking"]])
+                id2label[line["id"]] = line["label"]
+                relations.extend([tuple(sorted(l)) for l in line["linking"]])
                 tokenized_inputs = self.tokenizer(
-                    item["text"],
+                    line["text"],
                     add_special_tokens=False,
                     return_offsets_mapping=True,
                     return_attention_mask=False,
@@ -165,6 +176,7 @@ class Funsd(datasets.GeneratorBasedBuilder):
                 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)
@@ -172,7 +184,9 @@ class Funsd(datasets.GeneratorBasedBuilder):
                     text_length += offset[1] - offset[0]
                     tmp_box = []
                     while ocr_length < text_length:
-                        ocr_word = item["words"].pop(0)
+                        if len(line["words"]) == 0:
+                            break
+                        ocr_word = line["words"].pop(0)
                         ocr_length += len(
                             self.tokenizer._tokenizer.normalizer.normalize_str(ocr_word["text"].strip())
                         )
@@ -180,44 +194,28 @@ class Funsd(datasets.GeneratorBasedBuilder):
                     if len(tmp_box) == 0:
                         tmp_box = last_box
                     bbox.append(normalize_bbox(merge_bbox(tmp_box), size))
-                    last_box = tmp_box  # noqa
-                    
+                    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": item["label"].upper()})
-                
-               
-                if item["label"] == "other":
-                    for w in words_example:
-                        words.append(w["text"])
-                        labels.append("O")
-                        bboxes.append(normalize_bbox(w["box"], size))
-                    #label = ["O"] * len(bbox)
+                if line["label"] == "other":
+                    label = ["O"] * len(bbox)
                 else:
-                    words.append(words_example[0]["text"])
-                    labels.append("B-" + item["label"].upper())
-                    bboxes.append(normalize_bbox(words_example[0]["box"], size))
-                    for w in words_example[1:]:
-                        words.append(w["text"])
-                        labels.append("I-" + item["label"].upper())
-                        bboxes.append(normalize_bbox(w["box"], size))
-                    #label = [f"I-{item['label'].upper()}"] * len(bbox)
-                    #label[0] = f"B-{item['label'].upper()}"                    
-                
+                    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[item["id"]] = len(entities)
-                    entities.append(
+                    entity_id_to_index_map[line["id"]] = len(entities)
+                    entities.append( # determine the number of tokens wiithin the text and their start and end index
                         {
-                            "start": len(tokenized_doc["input_ids"]),
-                            "end": len(tokenized_doc["input_ids"]) + len(tokenized_inputs["input_ids"]),
-                            "label": item["label"].upper(),
+                            "start": len(tokenized_doc["input_ids"]), # start index of the token of text. eg for text hello world having token hello world, it is 0
+                            "end": len(tokenized_doc["input_ids"]) + len(tokenized_inputs["input_ids"]), # end index of the token of text. This will be 2 for hello world.
+                            "label": line["label"].upper(), # label of the text
                         }
                     )
                 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 = []
@@ -255,12 +253,13 @@ class Funsd(datasets.GeneratorBasedBuilder):
             )
             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 (
+                    if ( # yo condition garda yedi text ko ek part euta chunk ra baki arko chunk ma aayo vane k garne?
                         index <= entity["start"] < index + chunk_size
                         and index <= entity["end"] < index + chunk_size
                     ):
@@ -270,7 +269,7 @@ class Funsd(datasets.GeneratorBasedBuilder):
                         entities_in_this_span.append(entity)
                 relations_in_this_span = []
                 for relation in relations:
-                    if (
+                    if ( # yo condition garda yedi question euta chunk ra answer arko chunk ma aayo vane k garne?
                         index <= relation["start_index"] < index + chunk_size
                         and index <= relation["end_index"] < index + chunk_size
                     ):
@@ -282,5 +281,14 @@ class Funsd(datasets.GeneratorBasedBuilder):
                                 "end_index": relation["end_index"] - index,
                             }
                         )
-            yield guid,{"id": str(guid), "words": words, "bboxes": bboxes, "labels": labels, "image": image, "entities": entities, "relations": relations}
+                item.update(
+                    {
+                        "id": f"{doc_id}_{chunk_id}",
+                        "image": image,
+                        "original_image": original_image,
+                        "entities": entities_in_this_span,
+                        "relations": relations_in_this_span,
+                    }
+                )
+                yield f"{doc_id}_{chunk_id}", item