# coding=utf-8 # Copyright 2020 The HuggingFace Datasets Authors and the current dataset script contributor. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """DUDE dataset loader""" import os from pathlib import Path import time import copy import json import numpy as np import pandas as pd from tqdm import tqdm from io import BytesIO tqdm.pandas() from joblib import Parallel, delayed # import pdf2image import PyPDF2 from datasets import load_dataset_builder, load_dataset from PIL import Image as PIL_Image MAX_PAGES = 50 MAX_PDF_SIZE = 100000000 # almost 100MB MIN_WIDTH, MIN_HEIGHT = 150, 150 def load_json(json_path): return json.load(open(json_path, "r")) def save_json(json_path, data): with open(json_path, "w") as f: json.dump(data, f) # 0. PDF to images # 1. OCR metadata def pdf_to_images(document_filepath): def images_to_pagenames(images, document_filepath, page_image_dir): "/home/jordy/Downloads/DUDE_train-val-test_binaries/PDF/val/001d6f557c342ef5a67cd38a29da9e83.pdf" page_image_names = [] for page_idx, page_image in enumerate(images): page_image_name = document_filepath.replace("PDF", "images").replace( ".pdf", f"_{page_idx}.jpg" ) # page_image_names.append(page_image_name.replace(page_images_dir, "")) #without dir if not os.path.exists(page_image_name): page_image.save(page_image_name) return page_image_names example = {} example["document"] = document_filepath example["pages"] = 0 example["page_image_names"] = [] images = [] page_image_dir = "/".join(example["document"].split("/")[:-1]).replace("PDF", "images") if not os.path.exists(page_image_dir): os.makedirs(page_image_dir) # if len(example["document"]) > MAX_PDF_SIZE: # logger.warning(f"too large document {len(example['document'])}") # return example try: reader = PyPDF2.PdfReader(example["document"]) except Exception as e: logger.warning(f"read_pdf {e}") return example reached_page_limit = False page_iterator = reader.pages for p, page in enumerate(page_iterator): if reached_page_limit: break for image in page.images: # try: # except Exception as e: # logger.warning(f"get_images {e}") if len(images) == MAX_PAGES: reached_page_limit = True break im = PIL_Image.open(BytesIO(image.data)) if im.width < MIN_WIDTH and im.height < MIN_HEIGHT: continue images.append(im) example["pages"] = len(images) if len(images) == 0: return example example["page_image_names"] = images_to_pagenames(images, example["document"], page_image_dir) return example def pdf_to_images_block(document_paths_blocks): new_doc_metadata = {} for document_filepath in document_paths_blocks: docId = document_filepath.split("/")[-1].replace(".pdf", "") new_doc_metadata[docId] = pdf_to_images(document_filepath) return new_doc_metadata """ def get_document_metadata(docs_metadata, doc_id, document_filepath): if doc_id in docs_metadata and docs_metadata[doc_id]["num_pages"] != -1: num_pages = docs_metadata[doc_id]["num_pages"] page_image_names = docs_metadata[doc_id]["page_image_names"] else: try: images = pdf2image.convert_from_path(document_filepath) except: print(doc_id) return -1, -1 num_pages = len(images) page_image_dir = ("/").join( document_filepath.replace(documents_dir, page_images_dir).split("/")[:-1] ) if not os.path.exists(page_image_dir): os.makedirs(page_image_dir) page_image_names = [] for page_idx, page_image in enumerate(images): page_image_name = document_filepath.replace(documents_dir, page_images_dir).replace( ".pdf", f"_{page_idx}.jpg" ) page_image_names.append(page_image_name.replace(page_images_dir, "")) if not os.path.exists(page_image_name): page_image.save(page_image_name) return num_pages, page_image_names def get_document_metadata_block(docs_metadata, documents_path_dict, documents_blocks): new_doc_metadata = {} for doc_id in documents_blocks: document_filepath = documents_path_dict[doc_id] num_pages, page_image_names = get_document_metadata( docs_metadata, doc_id, document_filepath ) new_doc_metadata[doc_id] = {"num_pages": num_pages, "page_image_names": page_image_names} return new_doc_metadata """ def parse_textract_bbox(box): # 0.47840896, 0.12897822, 0.5341576 , 0.14347914 # x,w,y,h return np.array([box["Left"], box["Width"], box["Top"], box["Height"]]) def parse_azure_box(box, page_width, page_height): # Box in Azure are in format X top left, Y top left, X top right, Y top right, X bottom right, Y bottom right, X bottom left, Y bottom left # [14.1592, 3.8494, 28.668, 3.8494, 28.668, 8.0487, 13.9844, 7.8738] left = min(box[0], box[6]) right = max(box[2], box[4]) top = min(box[1], box[3]) bottom = max(box[5], box[7]) width = right - left height = bottom - top # Normalize left = left / page_width top = top / page_height width = width / page_width height = height / page_height return [left, width, top, height] def get_ocr_information(doc_id): ocr_info = load_json(os.path.join(ocr_dir, doc_id + "_original.json")) num_pages, _ = get_document_metadata(documents_metadata, doc_id, documents[doc_id]) page_ocr_tokens = [[] for page_ix in range(num_pages)] page_ocr_boxes = [[] for page_ix in range(num_pages)] for ocr_block in ocr_info: for ocr_extraction in ocr_block["Blocks"]: if ocr_extraction["BlockType"] == "WORD": text = ocr_extraction["Text"].lower() bounding_box = parse_textract_bbox(ocr_extraction["Geometry"]["BoundingBox"]) page = ocr_extraction["Page"] - 1 page_ocr_tokens[page].append(text) page_ocr_boxes[page].append(bounding_box) for page in range(num_pages): page_ocr_boxes[page] = np.array(page_ocr_boxes[page]) page_ocr_boxes = page_ocr_boxes return page_ocr_tokens, page_ocr_boxes def create_header(split, version, has_answer): header = { "creation_time": time.time(), "version": version, "dataset_type": split, "has_answer": has_answer, } return header def get_document_info(documents_metadata, doc_id): doc_metadata = documents_metadata[doc_id] num_pages = doc_metadata["num_pages"] page_image_names = doc_metadata["page_image_names"] return num_pages, page_image_names def format_answers(answers_list): answers_list = list(set([answer.lower() for answer in answers_list])) return answers_list def create_imdb_record_from_json( record, documents_metadata, documents_ocr_information, split, include_answers ): doc_id = record["docId"] # document_filepath = documents_dict[doc_id] num_pages, page_image_names = get_document_info(documents_metadata, doc_id) document_ocr_info = documents_ocr_information[doc_id] if include_answers: answers = format_answers(record["answers"]) else: answers = None imdb_record = { "question_id": record["questionId"], "question": record["question"], "docId": doc_id, "image_name": page_image_names, "num_pages": num_pages, "ocr_tokens": document_ocr_info["ocr_tokens"], "ocr_normalized_boxes": document_ocr_info["ocr_boxes"], "set_name": split, "answers": answers, "answer_page": None, "extra": { # 'question_type': record['qtype'], # 'industry': record['industry'], # 'category': record['category'], "answer_type": record["answer_type"], }, } return imdb_record def create_imdb_from_json( data, documents_metadata, documents_ocr_information, split, version, include_answers ): imdb_header = create_header(split, version, include_answers) imdb_records = [] for record in tqdm(data): imdb_records.append( create_imdb_record_from_json( record, documents_metadata, documents_ocr_information, split, include_answers ) ) imdb = [imdb_header] + imdb_records return imdb if __name__ == "__main__": dataset = load_dataset( "../DUDE_loader/DUDE_loader.py", "DUDE", data_dir="/home/jordy/Downloads/DUDE_train-val-test_binaries", ) splits = datasets.keys() split = "val" # 1. PDF to image dir and collect document metadata (num_pages, page_image_names) document_paths = sorted( set([x["document"] for x in dataset[split] if x["data_split"] == split]) ) document_paths = document_paths[:30] # document_ids = [document_filepath.split("/")[-1].replace(".pdf", "") for document_filepath in document_paths] documents_metadata_filename = "documents_metadata.json" if os.path.exists(documents_metadata_filename): documents_metadata = load_json(documents_metadata_filename) else: documents_metadata = {} # for document_filepath in tqdm(document_paths): # documents_metadata[docId] = pdf_to_images(document_filepath) num_jobs = 6 block_size = int(len(document_paths) / num_jobs) + 1 print(f"{block_size} * {num_jobs} = {block_size*num_jobs} ({len(document_paths)})") documents_blocks = [ document_paths[block_size * i : block_size * i + block_size] for i in range(num_jobs) ] print( "chunksize", len(set([doc_id for doc_block in documents_blocks for doc_id in doc_block])), ) parallel_results = Parallel(n_jobs=num_jobs)( delayed(get_document_metadata_block)(documents_metadata, documents, document_paths[i]) for i in range(num_jobs) ) for block_result in parallel_results: for doc_id, metadata in tqdm(block_result.items()): if doc_id not in documents_metadata: documents_metadata[doc_id] = metadata save_json(documents_metadata_filename, documents_metadata) #2. Process OCR to obtain doc_ocr_info documents_ocr_filename = "documents_ocr.json" if os.path.exists(documents_ocr_filename): documents_ocr_info = load_json(documents_ocr_filename) else: documents_ocr_info = {} no_ocr = [] error_ocr = [] for document_filepath in document_paths: docId = document_filepath.split("/")[-1].replace(".pdf", "") try: ocr_tokens, ocr_boxes = get_ocr_information(docId) doc_ocr_info[docId] = {'ocr_tokens': ocr_tokens, 'ocr_boxes': ocr_boxes} except FileNotFoundError: no_ocr.append(docId) except KeyError: error_ocr.append(docId) save_json(documents_ocr_filename, documents_ocr_info) # page_image_dir = '/'.join(dataset['val']['document'][0].split("/")[:-1]).replace('PDF', 'images') # if not os.path.exists(page_image_dir): # os.makedirs(page_image_dir) # dataset.info.features """ Describe all steps that need to happen after loading HF DUDE dataset Change functions page_images_dir 2. Process OCR to obtain doc_ocr_info """ # update dataset with # for split in SPLITS # documents_metadata # doc_ocr_info # dict to unique docs # documents_metadata[doc_id] = {"num_pages": num_pages, "page_image_names": image_names} # doc_ocr_info[doc_id] = {"ocr_tokens": ocr_tokens, "ocr_boxes": ocr_boxes} """ train_imdb = create_imdb_from_json( train_data, documents_metadata=documents_metadata, documents_ocr_information=doc_ocr_info, split="train", version="0.1", include_answers=True, ) val_imdb = create_imdb_from_json( val_data, documents_metadata=documents_metadata, documents_ocr_information=doc_ocr_info, split="train", version="0.1", include_answers=True, ) np.save("Imdb/train_imdb.npy", train_imdb) np.save("Imdb/val_imdb.npy", val_imdb) document_paths = [] num_jobs = 6 block_size = int(len(document_ids) / num_jobs) + 1 print(f"{block_size} * {num_jobs} = {block_size*num_jobs} ({len(document_ids)})") parallel_results = Parallel(n_jobs=num_jobs)( delayed(get_document_metadata_block)(documents_metadata, documents, documents_blocks[i]) for i in range(num_jobs) ) """