Datasets:
Tasks:
Token Classification
License:
| # coding=utf-8 | |
| 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__) | |
| _CITATION = """\ | |
| @article{Jaume2019FUNSDAD, | |
| title={FUNSD: A Dataset for Form Understanding in Noisy Scanned Documents}, | |
| author={Guillaume Jaume and H. K. Ekenel and J. Thiran}, | |
| journal={2019 International Conference on Document Analysis and Recognition Workshops (ICDARW)}, | |
| year={2019}, | |
| volume={2}, | |
| pages={1-6} | |
| } | |
| """ | |
| _DESCRIPTION = """\ | |
| https://guillaumejaume.github.io/FUNSD/ | |
| """ | |
| def load_image(image_path, size=None): | |
| image = Image.open(image_path).convert("RGB") | |
| w, h = image.size | |
| 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): | |
| 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 [ | |
| int(1000 * bbox[0] / size[0]), | |
| int(1000 * bbox[1] / size[1]), | |
| int(1000 * bbox[2] / size[0]), | |
| int(1000 * bbox[3] / size[1]), | |
| ] | |
| class FunsdConfig(datasets.BuilderConfig): | |
| """BuilderConfig for FUNSD""" | |
| def __init__(self, **kwargs): | |
| """BuilderConfig for FUNSD. | |
| Args: | |
| **kwargs: keyword arguments forwarded to super. | |
| """ | |
| super(FunsdConfig, self).__init__(**kwargs) | |
| class Funsd(datasets.GeneratorBasedBuilder): | |
| """FUNSD dataset.""" | |
| BUILDER_CONFIGS = [ | |
| FunsdConfig(name="funsd", version=datasets.Version("1.0.0"), description="FUNSD dataset"), | |
| ] | |
| tokenizer = AutoTokenizer.from_pretrained("xlm-roberta-base") | |
| def _info(self): | |
| return datasets.DatasetInfo( | |
| description=_DESCRIPTION, | |
| features=datasets.Features( | |
| { | |
| "id": datasets.Value("string"), | |
| "input_ids": datasets.Sequence(datasets.Value("int64")), | |
| "bbox": datasets.Sequence(datasets.Sequence(datasets.Value("int64"))), | |
| "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"]), | |
| } | |
| ), | |
| "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"), | |
| "tail": datasets.Value("int64"), | |
| "start_index": datasets.Value("int64"), | |
| "end_index": datasets.Value("int64"), | |
| } | |
| ), | |
| } | |
| ), | |
| supervised_keys=None, | |
| homepage="https://guillaumejaume.github.io/FUNSD/", | |
| citation=_CITATION, | |
| ) | |
| def _split_generators(self, dl_manager): | |
| """Returns SplitGenerators.""" | |
| downloaded_file = dl_manager.download_and_extract("https://guillaumejaume.github.io/FUNSD/dataset.zip") | |
| return [ | |
| datasets.SplitGenerator( | |
| name=datasets.Split.TRAIN, gen_kwargs={"filepath": f"{downloaded_file}/dataset/training_data/"} | |
| ), | |
| datasets.SplitGenerator( | |
| name=datasets.Split.TEST, gen_kwargs={"filepath": f"{downloaded_file}/dataset/testing_data/"} | |
| ), | |
| ] | |
| def _generate_examples(self, filepath): | |
| 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_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() | |
| 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[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: | |
| 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()) | |
| ) | |
| 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( # determine the number of tokens wiithin the text and their start and end index | |
| { | |
| "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 = [] | |
| 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 ( # 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 | |
| ): | |
| 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 ( # 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 | |
| ): | |
| 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, | |
| "original_image": original_image, | |
| "entities": entities_in_this_span, | |
| "relations": relations_in_this_span, | |
| } | |
| ) | |
| yield f"{doc_id}_{chunk_id}", item | |