trying to iter over full validation

DUDE_imdb_loader.py

@@ -27,11 +27,14 @@ from io import BytesIO
 tqdm.pandas()
 from joblib import Parallel, delayed
 
-# import pdf2image
+import pdf2image
 import PyPDF2
 
-from datasets import load_dataset_builder, load_dataset
 from PIL import Image as PIL_Image
+from datasets import load_dataset_builder, load_dataset, logging
+
+
+logger = logging.get_logger(__name__)
 
 
 MAX_PAGES = 50
@@ -48,125 +51,88 @@ def save_json(json_path, data):
         json.dump(data, f)
 
 
-# 0. PDF to images
+def get_images_pdf2image(document_filepath):
+    info = pdf2image.pdfinfo_from_path(document_filepath, userpw=None, poppler_path=None)
+    maxPages = info["Pages"]
+    maxPages = min(maxPages, maxPages)
 
-# 1. OCR metadata
+    # logger.info(f"{document_filepath} has {str(maxPages)} pages")
+    images = []
+    for page in range(1, maxPages + 1, 10):
+        images.extend(
+            pdf2image.convert_from_path(
+                document_filepath, first_page=page, last_page=min(page + 10 - 1, maxPages)
+            )
+        )
+    return images
 
 
-def pdf_to_images(document_filepath):
+def pdf_to_images(document_filepath, converter="PyPDF2"):
     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
-
+            page_image_names.append(page_image_name.replace(page_image_dir, ""))  # without dir
             if not os.path.exists(page_image_name):
-                page_image.save(page_image_name)
+                page_image.convert("RGB").save(page_image_name)
         return page_image_names
 
     example = {}
-    example["document"] = document_filepath
-    example["pages"] = 0
+    example["num_pages"] = 0
     example["page_image_names"] = []
     images = []
 
-    page_image_dir = "/".join(example["document"].split("/")[:-1]).replace("PDF", "images")
+    page_image_dir = "/".join(document_filepath.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:
+    # if len(document_filepath) > 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 converter == "PyPDF2":
+        try:
+            reader = PyPDF2.PdfReader(document_filepath)
+        except Exception as e:
+            logger.warning(f"read_pdf {e}")
+            return example
+
+        for p, page in enumerate(reader.pages):
+            if reached_page_limit:
+                break
+            try:
+                for image in page.images:
+                    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)
+            except Exception as e:
+                logger.warning(f"get_images {e}")
+
+    elif converter == "pdf2image":
+        images = get_images_pdf2image(document_filepath)
+
+    example["num_pages"] = len(images)
     if len(images) == 0:
         return example
 
-    example["page_image_names"] = images_to_pagenames(images, example["document"], page_image_dir)
+    example["page_image_names"] = images_to_pagenames(images, document_filepath, page_image_dir)
 
     return example
 
 
-def pdf_to_images_block(document_paths_blocks):
+def pdf_to_images_block(document_paths_blocks, converter):
     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, docId, document_filepath):
-
-    if docId in docs_metadata and docs_metadata[docId]["num_pages"] != -1:
-        num_pages = docs_metadata[docId]["num_pages"]
-        page_image_names = docs_metadata[docId]["page_image_names"]
-
-    else:
-        try:
-            images = pdf2image.convert_from_path(document_filepath)
-        except:
-            print(docId)
-            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 docId in documents_blocks:
-        document_filepath = documents_path_dict[docId]
-        num_pages, page_image_names = get_document_metadata(
-            docs_metadata, docId, document_filepath
-        )
-        new_doc_metadata[docId] = {"num_pages": num_pages, "page_image_names": page_image_names}
-
+        new_doc_metadata[docId] = pdf_to_images(document_filepath, converter=converter)
     return new_doc_metadata
-"""
 
 
 def parse_textract_bbox(box):
@@ -195,7 +161,11 @@ def parse_azure_box(box, page_width, page_height):
 
 def get_ocr_information(ocr_path, num_pages):
     ocr_info = load_json(ocr_path)
-    #num_pages, _ = get_document_metadata(documents_metadata, docId, documents[docId])
+
+    ocr_pages = ocr_info[0]["DocumentMetadata"]["Pages"]
+
+    if num_pages != ocr_pages:
+        raise AssertionError("Pages from images and OCR not matching, should go for pdf2image")
 
     page_ocr_tokens = [[] for page_ix in range(num_pages)]
     page_ocr_boxes = [[] for page_ix in range(num_pages)]
@@ -203,16 +173,18 @@ def get_ocr_information(ocr_path, num_pages):
         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"])
+                bounding_box = parse_textract_bbox(
+                    ocr_extraction["Geometry"]["BoundingBox"]
+                ).tolist()
                 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
 
 
@@ -240,13 +212,21 @@ def format_answers(answers_list):
 
 
 def create_imdb_record_from_json(
-    record, documents_metadata, documents_ocr_information, split, include_answers
+    record, documents_metadata, documents_ocr_info, split, include_answers
 ):
 
-    docId = record["docId"]
+    docId = record["docId"].split("_")[0]
     # document_filepath = documents_dict[docId]
-    num_pages, page_image_names = get_document_info(documents_metadata, docId)
-    document_ocr_info = documents_ocr_information[docId]
+    try:
+        num_pages, page_image_names = get_document_info(documents_metadata, docId)
+        document_ocr_info = documents_ocr_info[docId]
+    except Exception as e:
+        print(
+            "Missing: ",
+            e,
+            docId,
+        )
+        return {}
 
     if include_answers:
         answers = format_answers(record["answers"])
@@ -276,17 +256,17 @@ def create_imdb_record_from_json(
 
 
 def create_imdb_from_json(
-    data, documents_metadata, documents_ocr_information, split, version, include_answers=True
+    data, documents_metadata, documents_ocr_info, split, version, include_answers=True
 ):
     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_record = create_imdb_record_from_json(
+            record, documents_metadata, documents_ocr_info, split, include_answers
         )
+        if imdb_record:
+            imdb_records.append(imdb_record)
 
     imdb = [imdb_header] + imdb_records
 
@@ -299,7 +279,7 @@ if __name__ == "__main__":
         "DUDE",
         data_dir="/home/jordy/Downloads/DUDE_train-val-test_binaries",
     )
-    splits = datasets.keys()
+    splits = dataset.keys()
 
     for split in splits:
         if split != "val":
@@ -308,7 +288,7 @@ if __name__ == "__main__":
         split_indices = []
         OCR_paths = []
         document_paths = []
-        for i, x in enumerate(dataset):
+        for i, x in enumerate(dataset[split]):
             if x["data_split"] != split:
                 continue
             if x["document"] not in document_paths:
@@ -316,27 +296,29 @@ if __name__ == "__main__":
                 OCR_paths.append(x["OCR"])
                 split_indices.append(i)
 
-        document_paths = document_paths[:30]
-        OCR_paths = OCR_paths[:30]
+        # document_paths = document_paths[:30]
+        # OCR_paths = OCR_paths[:30]
 
         # 1. PDF to image dir and collect document metadata (num_pages, page_image_names)
         documents_metadata_filename = f"{split}-documents_metadata.json"
         if os.path.exists(documents_metadata_filename):
+            print(f"Loading from disk: {documents_metadata_filename}")
             documents_metadata = load_json(documents_metadata_filename)
         else:
             documents_metadata = {}
-            num_jobs = 6
+            num_jobs = 1
             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)
+            document_blocks = [
+                document_paths[block_size * i : block_size * i + block_size]
+                for i in range(num_jobs)
             ]
             print(
                 "chunksize",
-                len(set([docId for doc_block in documents_blocks for docId in doc_block])),
+                len(set([docId for doc_block in document_blocks for docId in doc_block])),
             )
             parallel_results = Parallel(n_jobs=num_jobs)(
-                delayed(get_document_metadata_block)(documents_metadata, documents, document_paths[i])
+                delayed(pdf_to_images_block)(document_blocks[i], "pdf2image")
                 for i in range(num_jobs)
             )
 
@@ -350,7 +332,8 @@ if __name__ == "__main__":
         # 2. Process OCR to obtain doc_ocr_info
         documents_ocr_filename = f"{split}-documents_ocr.json"
 
-        if os.path.exists(documents_ocr_filename):
+        if os.path.exists(documents_ocr_filename) and False:
+            print(f"Loading from disk: {documents_ocr_filename}")
             documents_ocr_info = load_json(documents_ocr_filename)
         else:
             documents_ocr_info = {}
@@ -359,27 +342,39 @@ if __name__ == "__main__":
 
             for i, document_filepath in enumerate(document_paths):
                 docId = document_filepath.split("/")[-1].replace(".pdf", "")
-            try:
-                ocr_tokens, ocr_boxes = get_ocr_information(OCR_paths[i], documents_metadata[docId]["num_pages"])
-                doc_ocr_info[docId] = {"ocr_tokens": ocr_tokens, "ocr_boxes": ocr_boxes}
-            except FileNotFoundError:
-                no_ocr.append(docId)
-            except KeyError:
-                error_ocr.append(docId)
+                try:
+                    ocr_tokens, ocr_boxes = get_ocr_information(
+                        OCR_paths[i], documents_metadata[docId]["num_pages"]
+                    )
+                    documents_ocr_info[docId] = {"ocr_tokens": ocr_tokens, "ocr_boxes": ocr_boxes}
+                except AssertionError as e:
+                    print(f"image2pages issue: {e}")
+                    error_ocr.append(docId)
+                except IndexError as e:
+                    print(f"pages issue: {e}")
+                    error_ocr.append(docId)
+                except FileNotFoundError:
+                    print(f"FileNotFoundError issue: {e}")
+                    no_ocr.append(docId)
+                except KeyError:
+                    print(f"Keyerror issue: {e}")
+                    error_ocr.append(docId)
 
             save_json(documents_ocr_filename, documents_ocr_info)
 
         imdb = create_imdb_from_json(
-            dataset.select(split_indices),
+            dataset[split], #.select(split_indices),  
             documents_metadata=documents_metadata,
-            documents_ocr_information=doc_ocr_info,
+            documents_ocr_info=documents_ocr_info,
             split=split,
             version="0.1",
             include_answers=True,
         )
-        np.save(f"{split}_imdb.npy", imdb)
+        np.save(f"{split}_imdb.npy", imdb)  # dump to lerna
+
+    import pdb
 
-    import pdb; pdb.set_trace()  # breakpoint 930f4f6a //
+    pdb.set_trace()  # breakpoint 930f4f6a //
 
     # page_image_dir = '/'.join(dataset['val']['document'][0].split("/")[:-1]).replace('PDF', 'images')
     # if not os.path.exists(page_image_dir):
@@ -411,7 +406,7 @@ if __name__ == "__main__":
     train_imdb = create_imdb_from_json(
         train_data,
         documents_metadata=documents_metadata,
-        documents_ocr_information=doc_ocr_info,
+        documents_ocr_info=doc_ocr_info,
         split="train",
         version="0.1",
         include_answers=True,