diff --git "a/ocr_notebooks/table_extraction.ipynb" "b/ocr_notebooks/table_extraction.ipynb"
new file mode 100644--- /dev/null
+++ "b/ocr_notebooks/table_extraction.ipynb"
@@ -0,0 +1,3398 @@
+{
+  "nbformat": 4,
+  "nbformat_minor": 0,
+  "metadata": {
+    "colab": {
+      "provenance": [],
+      "collapsed_sections": [
+        "SFMoKtzdyYHU",
+        "cRHuvf0kKUr7"
+      ]
+    },
+    "kernelspec": {
+      "name": "python3",
+      "display_name": "Python 3"
+    },
+    "language_info": {
+      "name": "python"
+    }
+  },
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "source": [
+        "# **Utils**"
+      ],
+      "metadata": {
+        "id": "ekEn765o-nNk"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "!pip install pillow"
+      ],
+      "metadata": {
+        "id": "y4Op9_Ey-qp8",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "outputId": "0811c257-4608-4880-85fb-8809bd35d0de"
+      },
+      "execution_count": 2,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Requirement already satisfied: pillow in /usr/local/lib/python3.10/dist-packages (9.4.0)\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "from PIL import Image, ImageDraw\n",
+        "from IPython.display import display\n",
+        "\n",
+        "def draw_boxes(image_path, boxes):\n",
+        "    image = Image.open(image_path).convert(\"RGB\")\n",
+        "    draw = ImageDraw.Draw(image)\n",
+        "\n",
+        "    for box in boxes:\n",
+        "        draw.rectangle(box, outline=\"red\", width=3)\n",
+        "    display(image)"
+      ],
+      "metadata": {
+        "id": "HNQ0V2Ec-3qY"
+      },
+      "execution_count": 3,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "def convert_pdf_to_images(pdf_path):\n",
+        "    images = []\n",
+        "    with fitz.open(pdf_path) as doc:\n",
+        "        for page_num in range(len(doc)):\n",
+        "            page = doc.load_page(page_num)\n",
+        "            pix = page.get_pixmap()\n",
+        "            images.append(pix)\n",
+        "    return images\n",
+        "\n",
+        "def encode_image_to_base64(image):\n",
+        "    image_bytes = image.tobytes()\n",
+        "    base64_encoded = base64.b64encode(image_bytes)\n",
+        "    base64_string = base64_encoded.decode(\"utf-8\")\n",
+        "    return base64_string"
+      ],
+      "metadata": {
+        "id": "YcrPwmvHUSLY"
+      },
+      "execution_count": 4,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "def calculate_scaling_factors(extracted_bbox, ground_truth_bbox):\n",
+        "    extracted_width = extracted_bbox[2] - extracted_bbox[0]\n",
+        "    extracted_height = extracted_bbox[3] - extracted_bbox[1]\n",
+        "    ground_truth_width = ground_truth_bbox[2] - ground_truth_bbox[0]\n",
+        "    ground_truth_height = ground_truth_bbox[3] - ground_truth_bbox[1]\n",
+        "\n",
+        "    scale_x = ground_truth_width / extracted_width\n",
+        "    scale_y = ground_truth_height / extracted_height\n",
+        "    print(scale_x, scale_y)\n",
+        "\n",
+        "    return scale_x, scale_y\n",
+        "\n",
+        "def apply_scaling(bbox, scale_x, scale_y):\n",
+        "    x1 = bbox[0] * scale_x\n",
+        "    y1 = bbox[1] * scale_y\n",
+        "    x2 = bbox[2] * scale_x\n",
+        "    y2 = bbox[3] * scale_y\n",
+        "    return [x1, y1, x2, y2]\n",
+        "\n",
+        "def scale_bounding_boxes(extracted_boxes, ground_truth_boxes):\n",
+        "    scaled_boxes = []\n",
+        "    for extracted_page, ground_truth_page in zip(extracted_boxes, ground_truth_boxes):\n",
+        "        if not extracted_page or not ground_truth_page:\n",
+        "            # If either page is empty, add empty list and continue\n",
+        "            scaled_boxes.append([])\n",
+        "            continue\n",
+        "\n",
+        "        # Calculate scaling factors based on the first bounding box pair of the current page\n",
+        "        scale_x, scale_y = calculate_scaling_factors(extracted_page[0], ground_truth_page[0])\n",
+        "\n",
+        "        scaled_page = [apply_scaling(bbox, scale_x, scale_y) for bbox in extracted_page]\n",
+        "        scaled_boxes.append(scaled_page)\n",
+        "\n",
+        "    return scaled_boxes"
+      ],
+      "metadata": {
+        "id": "hsebsXnrqMQR"
+      },
+      "execution_count": 5,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import numpy as np\n",
+        "import matplotlib.pyplot as plt\n",
+        "\n",
+        "def calculate_iou(box1, box2):\n",
+        "    x1_max = max(box1[0], box2[0])\n",
+        "    y1_max = max(box1[1], box2[1])\n",
+        "    x2_min = min(box1[2], box2[2])\n",
+        "    y2_min = min(box1[3], box2[3])\n",
+        "\n",
+        "    intersection_area = max(0, x2_min - x1_max) * max(0, y2_min - y1_max)\n",
+        "    box1_area = (box1[2] - box1[0]) * (box1[3] - box1[1])\n",
+        "    box2_area = (box2[2] - box2[0]) * (box2[3] - box2[1])\n",
+        "    union_area = box1_area + box2_area - intersection_area\n",
+        "\n",
+        "    iou = intersection_area / union_area if union_area != 0 else 0\n",
+        "    return iou\n",
+        "\n",
+        "def match_bounding_boxes(gt_boxes, pred_boxes):\n",
+        "    matched_ious = []\n",
+        "    used_predictions = set()\n",
+        "    for gt_box in gt_boxes:\n",
+        "        best_iou = 0\n",
+        "        best_pred_idx = -1\n",
+        "        for i, pred_box in enumerate(pred_boxes):\n",
+        "            if i in used_predictions:\n",
+        "                continue\n",
+        "            iou = calculate_iou(gt_box, pred_box)\n",
+        "            if iou > best_iou:\n",
+        "                best_iou = iou\n",
+        "                best_pred_idx = i\n",
+        "        if best_pred_idx >= 0:\n",
+        "            used_predictions.add(best_pred_idx)\n",
+        "            matched_ious.append(best_iou)\n",
+        "        else:\n",
+        "            matched_ious.append(0)\n",
+        "    return matched_ious\n",
+        "\n",
+        "def evaluate_models(ground_truth, predictions):\n",
+        "    model_ious = {}\n",
+        "    for model, pred_boxes in predictions.items():\n",
+        "        ious = []\n",
+        "        for gt_boxes, model_boxes in zip(ground_truth, pred_boxes):\n",
+        "            matched_ious = match_bounding_boxes(gt_boxes, model_boxes)\n",
+        "            ious.extend(matched_ious)\n",
+        "        model_ious[model] = np.mean(ious)\n",
+        "    return model_ious\n",
+        "\n",
+        "def plot_iou(ground_truth, table_bounding_boxes):\n",
+        "    model_ious = t\n",
+        "\n",
+        "    plt.figure(figsize=(13, 6))\n",
+        "    plt.bar(model_ious.keys(), model_ious.values(), color=\"#568c64\")\n",
+        "    plt.xlabel('Models')\n",
+        "    plt.ylabel('Average IoU')\n",
+        "    plt.title('Table Extraction - Model Comparison Based on IoU')\n",
+        "    plt.ylim(0, 1)\n",
+        "    plt.show()\n",
+        "\n",
+        "    print(model_ious)"
+      ],
+      "metadata": {
+        "id": "C9kd39msyXsf"
+      },
+      "execution_count": 6,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "GroundTruth = [\n",
+        "    [[91, 160, 828, 826]], # hardware 1\n",
+        "    [[106, 162, 844, 426], [108, 539, 840, 770]], # hardware 2\n",
+        "    [[553, 125, 1471, 480]], # hardware 3\n",
+        "    [[11, 186, 673, 532], [404, 108, 673, 167]], # bank statement 1\n",
+        "    [[63, 478, 936, 1127]], # bank statement 2\n",
+        "    [[644, 269, 1275, 962]], # bank statement 3\n",
+        "    [[45, 442, 560, 657]], # bank statement 4\n",
+        "    [[81, 458, 458, 825], [489, 745, 748, 805]], # data sheet 3\n",
+        "    [[63, 374, 592, 726]], # invoice 1\n",
+        "    [[44, 340, 611, 456], [44, 502, 611, 702]], # invoice 2\n",
+        "    [[60, 413, 776, 683]], # invoice 3\n",
+        "    [[428, 144, 768, 549]], # real estate listings 2\n",
+        "    [[50, 143, 767, 845]], # real estate listings 3\n",
+        "    [[126, 72, 689, 308], [128, 376, 688, 584], [148, 821, 668, 895]], # research paper 1\n",
+        "    [[23, 366, 791, 769]], # SEC 10k 1\n",
+        "    [[22, 596, 793, 762], [24, 897, 793, 1013]], # SEC 144 1\n",
+        "    [[22, 117, 793, 1022]], # SEC 144 2\n",
+        "    [[94, 101, 592, 267]], # text book 2\n",
+        "    [[223, 102, 721, 398]], # text book 3\n",
+        "]"
+      ],
+      "metadata": {
+        "id": "pgX0a1PycAdf"
+      },
+      "execution_count": 7,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "ground_truth = [\n",
+        "    [[91, 160, 828, 826]],\n",
+        "    [[106, 162, 844, 426], [108, 539, 840, 770]],\n",
+        "    [[553, 125, 1471, 480]]\n",
+        "]"
+      ],
+      "metadata": {
+        "id": "uDSBRnIUeWSK"
+      },
+      "execution_count": 105,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "t = {'PyMuPDF': 0.59256987881234, 'GPT 4 Turbo': 0.26977835468383293, 'GPT 4o': 0.27406410283611266, 'Table Transformer': 0.6399495573127585, 'img2table': 0.49895505703101684, 'Gemini Pro': 0.15192114262846507, 'Gemini Flash': 0.17320909579531665}"
+      ],
+      "metadata": {
+        "id": "D7l_RhWMNj3p"
+      },
+      "execution_count": 1,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "plot_iou(GroundTruth, table_bounding_boxes)"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 601
+        },
+        "id": "PdZDLLHLAQs8",
+        "outputId": "fbfb89a8-e308-4871-9a80-4bfd723909ce"
+      },
+      "execution_count": 9,
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 1300x600 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "{'PyMuPDF': 0.59256987881234, 'GPT 4 Turbo': 0.26977835468383293, 'GPT 4o': 0.27406410283611266, 'Table Transformer': 0.6399495573127585, 'img2table': 0.49895505703101684, 'Gemini Pro': 0.15192114262846507, 'Gemini Flash': 0.17320909579531665}\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "# **Table Transformer**"
+      ],
+      "metadata": {
+        "id": "JGm-OrWh-sQO"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "number_of_table_images = 19\n",
+        "table_bounding_boxes = {}"
+      ],
+      "metadata": {
+        "id": "2dCcj7H3bFyO"
+      },
+      "execution_count": 7,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "!pip install timm"
+      ],
+      "metadata": {
+        "id": "mm9Rhpf18k_W"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import os\n",
+        "os.kill(os.getpid(), 9)"
+      ],
+      "metadata": {
+        "id": "J1HcrjZU9YR9"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "from huggingface_hub import hf_hub_download\n",
+        "from transformers import AutoImageProcessor, TableTransformerForObjectDetection\n",
+        "import torch\n",
+        "from PIL import Image"
+      ],
+      "metadata": {
+        "id": "D7pVEZWc73fP"
+      },
+      "execution_count": 1,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "image_processor = AutoImageProcessor.from_pretrained(\"microsoft/table-transformer-detection\")\n",
+        "model = TableTransformerForObjectDetection.from_pretrained(\"microsoft/table-transformer-detection\")"
+      ],
+      "metadata": {
+        "id": "_sfOxQ0p8g0w"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 3,
+      "metadata": {
+        "id": "Ns7MiUY12W7o"
+      },
+      "outputs": [],
+      "source": [
+        "def get_bounding_box_table_transformer(image_path):\n",
+        "  image = Image.open(image_path).convert(\"RGB\")\n",
+        "\n",
+        "  inputs = image_processor(images=image, return_tensors=\"pt\")\n",
+        "  outputs = model(**inputs)\n",
+        "\n",
+        "  target_sizes = torch.tensor([image.size[::-1]])\n",
+        "  results = image_processor.post_process_object_detection(outputs, threshold=0.9, target_sizes=target_sizes)[0]\n",
+        "\n",
+        "  for score, label, box in zip(results[\"scores\"], results[\"labels\"], results[\"boxes\"]):\n",
+        "      box = [round(i, 2) for i in box.tolist()]\n",
+        "      print(\n",
+        "          f\"Detected {model.config.id2label[label.item()]} with confidence \"\n",
+        "          f\"{round(score.item(), 3)} at location {box}\"\n",
+        "      )\n",
+        "  # draw_boxes(image_path, results[\"boxes\"].tolist())\n",
+        "  return results[\"boxes\"].tolist()"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "bounding_boxes = []\n",
+        "for image_id in range(1, number_of_table_images+1):\n",
+        "    bounding_boxes.append(get_bounding_box_table_transformer(f\"/content/table-{image_id}.png\"))"
+      ],
+      "metadata": {
+        "id": "hLXfHKOfYs0-",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "collapsed": true,
+        "outputId": "4ac1d316-c102-4ccf-c878-641a6fc91ed3"
+      },
+      "execution_count": 68,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Detected table with confidence 1.0 at location [96.0, 166.24, 822.08, 820.72]\n",
+            "Detected table with confidence 0.999 at location [112.75, 166.88, 817.07, 423.66]\n",
+            "Detected table with confidence 0.998 at location [113.62, 551.71, 717.57, 769.02]\n",
+            "Detected table with confidence 0.991 at location [84.09, 124.33, 1449.32, 477.9]\n",
+            "Detected table with confidence 0.999 at location [13.07, 186.75, 660.28, 508.17]\n",
+            "Detected table with confidence 0.999 at location [96.56, 493.15, 922.1, 1075.55]\n",
+            "Detected table with confidence 0.998 at location [653.11, 278.32, 1266.22, 960.26]\n",
+            "Detected table with confidence 0.999 at location [46.12, 455.55, 553.68, 637.68]\n",
+            "Detected table with confidence 0.999 at location [87.42, 458.74, 435.34, 820.38]\n",
+            "Detected table with confidence 0.971 at location [67.07, 167.88, 589.33, 669.51]\n",
+            "Detected table with confidence 0.985 at location [49.59, 347.63, 550.93, 448.3]\n",
+            "Detected table with confidence 0.997 at location [80.58, 431.38, 759.34, 581.56]\n",
+            "Detected table with confidence 0.999 at location [434.34, 174.71, 752.25, 535.47]\n",
+            "Detected table with confidence 1.0 at location [62.11, 143.34, 760.56, 828.18]\n",
+            "Detected table with confidence 0.999 at location [158.72, 824.56, 656.57, 893.26]\n",
+            "Detected table with confidence 0.999 at location [26.3, 376.54, 786.51, 762.81]\n",
+            "Detected table with confidence 0.917 at location [32.61, 895.06, 776.1, 1008.1]\n",
+            "Detected table with confidence 0.999 at location [34.37, 158.28, 779.47, 1011.17]\n",
+            "Detected table with confidence 0.956 at location [105.81, 111.87, 583.19, 250.39]\n",
+            "Detected table with confidence 1.0 at location [235.99, 125.88, 707.31, 377.27]\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "table_bounding_boxes[\"Table Transformer\"] = bounding_boxes"
+      ],
+      "metadata": {
+        "id": "p5bnNc9Gq0Fh"
+      },
+      "execution_count": 74,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "# **Gemini**"
+      ],
+      "metadata": {
+        "id": "k6J-oSrhMMji"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "!pip install google-generativeai"
+      ],
+      "metadata": {
+        "id": "RGW86jAkMS7_"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import ast\n",
+        "import google.generativeai as genai\n",
+        "from PIL import Image, ImageDraw"
+      ],
+      "metadata": {
+        "id": "vUv_RtDwMWin"
+      },
+      "execution_count": 2,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "genai.configure(api_key= 'AIzaSyBwk94xRhPOIkvO0E3pYhXQ7Rrk5my5IyY')\n",
+        "gemini_pro_vision = genai.GenerativeModel('gemini-pro-vision')\n",
+        "genimi_gemini_flash = genai.GenerativeModel('gemini-1.5-flash-latest')\n",
+        "example_image = Image.open(\"/content/bank_statement_1.png\").convert(\"RGB\")\n",
+        "example_bbox = [[404,108,673,167], [11,186,673,532]]\n",
+        "prompt = f\"Extract the bounding boxes of all the tables present in this image. Return the bounding boxes as list of lists. Example: For this image -> {example_image} the extracted bounding box is {example_bbox}. This is just an example for understanding the requirement. Dont return the same bounding box.\""
+      ],
+      "metadata": {
+        "id": "jfKpg4JlMYMs"
+      },
+      "execution_count": 3,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "prompt = f\"Extract the bounding boxes of all the tables present in this image. Return the bounding boxes as list of lists. Do not include anyother text or symbols in the output\""
+      ],
+      "metadata": {
+        "id": "LfUKGju1X9AE"
+      },
+      "execution_count": 4,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "def get_bounding_box_gemini(model, image_path):\n",
+        "  img = Image.open(image_path).convert(\"RGB\")\n",
+        "  response = model.generate_content(\n",
+        "      [img, prompt], stream=False\n",
+        "  )\n",
+        "  response.resolve()\n",
+        "  return response.text"
+      ],
+      "metadata": {
+        "id": "FP-TS5nuMsKf"
+      },
+      "execution_count": 5,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "temp_b = [[[364, 76, 737, 350], [364, 402, 737, 676], [364, 76, 737, 350], [364, 402, 737, 676]], [[464, 72, 1013, 300], [1116, 72, 1665, 300]], [[434, 63, 784, 301], [434, 320, 784, 558]], [[416, 57, 775, 284], [416, 300, 775, 527]], [[564, 68, 994, 306], [564, 322, 994, 558]], [[416, 77, 737, 1014], [416, 1036, 737, 1272]], [[564, 76, 744, 174], [564, 190, 743, 314], [565, 330, 743, 494], [565, 510, 743, 673]], [], [[516, 148, 734, 304], [516, 320, 735, 477]], [[526, 764, 744, 881]], [[503, 64, 749, 290], [503, 306, 749, 532]], [[545, 72, 1013, 185], [545, 200, 1013, 313], [545, 330, 1013, 442], [545, 458, 1013, 570], [545, 598, 1013, 710], [545, 736, 1013, 848], [545, 868, 1013, 980]], [[515, 77, 1014, 446], [515, 500, 1014, 869]],[[46, 51, 794, 160], [46, 172, 794, 282], [46, 295, 794, 404], [46, 416, 794, 526], [46, 539, 794, 648], [46, 660, 794, 772], [46, 783, 794, 892], [851, 51, 1599, 160], [851, 172, 1599, 282], [851, 295, 1599, 404], [851, 416, 1599, 526], [851, 539, 1599, 648], [851, 660, 1599, 772], [851, 783, 1599, 892]], [[517, 76, 1014, 306], [517, 332, 1014, 561], [517, 588, 1014, 817], [517, 845, 1014, 1072]], [[408, 571, 776, 715], [408, 720, 776, 864], [408, 869, 776, 1013]], [[418.0, 594.0, 756.0, 812.0], [418.0, 100.0, 756.0, 318.0]], [[718, 132, 1039, 794]], [[514, 74, 744, 188]]]"
+      ],
+      "metadata": {
+        "id": "0v3XIhU2ncNl"
+      },
+      "execution_count": 40,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "bounding_boxes = []\n",
+        "for image_id in range(11, number_of_table_images+1):\n",
+        "    res = get_bounding_box_gemini(gemini_pro_vision, f\"/content/table-{image_id}.png\")\n",
+        "    print(image_id, res)\n",
+        "    bounding_boxes.append(ast.literal_eval(res))\n",
+        "bounding_boxes"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 992
+        },
+        "collapsed": true,
+        "id": "A4WO-IjX5dnH",
+        "outputId": "e18ffa6d-060f-426b-db6a-14a955661a09"
+      },
+      "execution_count": 9,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "11  [[503, 64, 749, 290], [503, 306, 749, 532]]\n",
+            "12  [[545, 72, 1013, 185], [545, 200, 1013, 313], [545, 330, 1013, 442], [545, 458, 1013, 570], [545, 598, 1013, 710], [545, 736, 1013, 848], [545, 868, 1013, 980]]\n",
+            "13  [[515, 77, 1014, 446], [515, 500, 1014, 869]]\n",
+            "14  [\n",
+            "  [46, 51, 794, 160],\n",
+            "  [46, 172, 794, 282],\n",
+            "  [46, 295, 794, 404],\n",
+            "  [46, 416, 794, 526],\n",
+            "  [46, 539, 794, 648],\n",
+            "  [46, 660, 794, 772],\n",
+            "  [46, 783, 794, 892],\n",
+            "  [851, 51, 1599, 160],\n",
+            "  [851, 172, 1599, 282],\n",
+            "  [851, 295, 1599, 404],\n",
+            "  [851, 416, 1599, 526],\n",
+            "  [851, 539, 1599, 648],\n",
+            "  [851, 660, 1599, 772],\n",
+            "  [851, 783, 1599, 892]\n",
+            "]\n",
+            "15  [[517, 76, 1014, 306], [517, 332, 1014, 561], [517, 588, 1014, 817], [517, 845, 1014, 1072]]\n",
+            "16  [[408, 571, 776, 715], [408, 720, 776, 864], [408, 869, 776, 1013]]\n",
+            "17  [[418.0, 594.0, 756.0, 812.0], [418.0, 100.0, 756.0, 318.0]]\n",
+            "18  [[718, 132, 1039, 794]]\n",
+            "19  [[514, 74, 744, 188]]\n"
+          ]
+        },
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "[[[503, 64, 749, 290], [503, 306, 749, 532]],\n",
+              " [[545, 72, 1013, 185],\n",
+              "  [545, 200, 1013, 313],\n",
+              "  [545, 330, 1013, 442],\n",
+              "  [545, 458, 1013, 570],\n",
+              "  [545, 598, 1013, 710],\n",
+              "  [545, 736, 1013, 848],\n",
+              "  [545, 868, 1013, 980]],\n",
+              " [[515, 77, 1014, 446], [515, 500, 1014, 869]],\n",
+              " [[46, 51, 794, 160],\n",
+              "  [46, 172, 794, 282],\n",
+              "  [46, 295, 794, 404],\n",
+              "  [46, 416, 794, 526],\n",
+              "  [46, 539, 794, 648],\n",
+              "  [46, 660, 794, 772],\n",
+              "  [46, 783, 794, 892],\n",
+              "  [851, 51, 1599, 160],\n",
+              "  [851, 172, 1599, 282],\n",
+              "  [851, 295, 1599, 404],\n",
+              "  [851, 416, 1599, 526],\n",
+              "  [851, 539, 1599, 648],\n",
+              "  [851, 660, 1599, 772],\n",
+              "  [851, 783, 1599, 892]],\n",
+              " [[517, 76, 1014, 306],\n",
+              "  [517, 332, 1014, 561],\n",
+              "  [517, 588, 1014, 817],\n",
+              "  [517, 845, 1014, 1072]],\n",
+              " [[408, 571, 776, 715], [408, 720, 776, 864], [408, 869, 776, 1013]],\n",
+              " [[418.0, 594.0, 756.0, 812.0], [418.0, 100.0, 756.0, 318.0]],\n",
+              " [[718, 132, 1039, 794]],\n",
+              " [[514, 74, 744, 188]]]"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 9
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "table_bounding_boxes[\"Gemini Pro\"] = temp_b"
+      ],
+      "metadata": {
+        "id": "UcIf1nxjA4zs"
+      },
+      "execution_count": 23,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import re\n",
+        "\n",
+        "def parse_bboxs_gemini_flash(input_string):\n",
+        "    lines = [line for line in input_string.strip().split('\\n') if line]\n",
+        "    bounding_boxes = [list(map(int, re.findall(r'\\d+', line))) for line in lines]\n",
+        "    return bounding_boxes"
+      ],
+      "metadata": {
+        "id": "e8ff-l0Vr6Be"
+      },
+      "execution_count": 25,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "bounding_boxes = []\n",
+        "for image_id in range(1, number_of_table_images+1):\n",
+        "    res = parse_bboxs_gemini_flash(get_bounding_box_gemini(genimi_gemini_flash, f\"/content/table-{image_id}.png\"))\n",
+        "    print(image_id, res)\n",
+        "    bounding_boxes.append(res)\n",
+        "bounding_boxes"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 1000
+        },
+        "collapsed": true,
+        "id": "Y4dJ1fSm5kif",
+        "outputId": "db1c3828-b645-4f6c-f33d-0cb8e42cc6d7"
+      },
+      "execution_count": 27,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "1 [[94, 112, 818, 880]]\n",
+            "2 [[107, 115, 343, 840], [396, 115, 591, 813]]\n",
+            "3 [[134, 47, 463, 911]]\n",
+            "4 [[342, 15, 952, 967], [222, 616, 284, 965]]\n",
+            "5 [[280, 63, 371, 454], [410, 85, 910, 928]]\n",
+            "6 [[], [], [], [104], [336], [235], [662], [], [], [255], [345], [903], [662], [], [], []]\n",
+            "7 [[608, 67, 892, 928], [342, 78, 400, 569]]\n",
+            "8 [[139, 608, 170, 879], [417, 102, 797, 532], [692, 576, 754, 891], [573, 630, 658, 834]]\n",
+            "9 [[402, 91, 780, 911]]\n",
+            "10 [[354, 78, 500, 862], [526, 74, 761, 890]]\n",
+            "11 [[336, 77, 585, 922]]\n",
+            "12 [[138, 522, 541, 926]]\n",
+            "13 [[148, 69, 798, 932]]\n",
+            "14 [[291, 85, 355, 913], [558, 85, 601, 912], [781, 191, 855, 817], [885, 139, 914, 904]]\n",
+            "15 [[357, 43, 724, 962]]\n",
+            "16 [[543, 38, 697, 923], [833, 39, 964, 942]]\n",
+            "17 [[217, 44, 949, 960]]\n",
+            "18 [[96, 126, 253, 725, 100, 740, 161, 891]]\n",
+            "19 [[116, 277, 367, 861]]\n"
+          ]
+        },
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "[[[94, 112, 818, 880]],\n",
+              " [[107, 115, 343, 840], [396, 115, 591, 813]],\n",
+              " [[134, 47, 463, 911]],\n",
+              " [[342, 15, 952, 967], [222, 616, 284, 965]],\n",
+              " [[280, 63, 371, 454], [410, 85, 910, 928]],\n",
+              " [[],\n",
+              "  [],\n",
+              "  [],\n",
+              "  [104],\n",
+              "  [336],\n",
+              "  [235],\n",
+              "  [662],\n",
+              "  [],\n",
+              "  [],\n",
+              "  [255],\n",
+              "  [345],\n",
+              "  [903],\n",
+              "  [662],\n",
+              "  [],\n",
+              "  [],\n",
+              "  []],\n",
+              " [[608, 67, 892, 928], [342, 78, 400, 569]],\n",
+              " [[139, 608, 170, 879],\n",
+              "  [417, 102, 797, 532],\n",
+              "  [692, 576, 754, 891],\n",
+              "  [573, 630, 658, 834]],\n",
+              " [[402, 91, 780, 911]],\n",
+              " [[354, 78, 500, 862], [526, 74, 761, 890]],\n",
+              " [[336, 77, 585, 922]],\n",
+              " [[138, 522, 541, 926]],\n",
+              " [[148, 69, 798, 932]],\n",
+              " [[291, 85, 355, 913],\n",
+              "  [558, 85, 601, 912],\n",
+              "  [781, 191, 855, 817],\n",
+              "  [885, 139, 914, 904]],\n",
+              " [[357, 43, 724, 962]],\n",
+              " [[543, 38, 697, 923], [833, 39, 964, 942]],\n",
+              " [[217, 44, 949, 960]],\n",
+              " [[96, 126, 253, 725, 100, 740, 161, 891]],\n",
+              " [[116, 277, 367, 861]]]"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 27
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "scaled_boxes = scale_bounding_boxes(bounding_boxes, GroundTruth)"
+      ],
+      "metadata": {
+        "id": "SU59RW14owDJ",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "collapsed": true,
+        "outputId": "489b9591-c156-465e-8cf2-bde94c64c2a2"
+      },
+      "execution_count": 34,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "1.0179558011049723 0.8671875\n",
+            "3.1271186440677967 0.3641379310344828\n",
+            "2.790273556231003 0.41087962962962965\n",
+            "1.0852459016393443 0.3634453781512605\n",
+            "9.593406593406593 1.659846547314578\n",
+            "1.8133802816901408 0.2497096399535424\n",
+            "12.161290322580646 1.3542435424354244\n",
+            "1.3994708994708995 0.4292682926829268\n",
+            "3.8835616438356166 0.14795918367346939\n",
+            "2.8755020080321283 0.31952662721893493\n",
+            "0.8436724565756824 1.0024752475247525\n",
+            "1.103076923076923 0.813441483198146\n",
+            "8.796875 0.28502415458937197\n",
+            "2.092643051771117 0.4385201305767138\n",
+            "5.0064935064935066 0.18757062146892656\n",
+            "1.0532786885245902 0.9879912663755459\n",
+            "3.171974522292994 0.27712854757929883\n",
+            "1.9840637450199203 0.5068493150684932\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "table_bounding_boxes[\"Gemini Flash\"] = bounding_boxes"
+      ],
+      "metadata": {
+        "id": "0obpPk6PrfSp"
+      },
+      "execution_count": 37,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "# **PyMuPDF**"
+      ],
+      "metadata": {
+        "id": "FLUoK1eEDdz6"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "!pip install pymupdf"
+      ],
+      "metadata": {
+        "id": "vTbQnKbhDbGN"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import io\n",
+        "import pymupdf\n",
+        "import fitz"
+      ],
+      "metadata": {
+        "id": "UASxsiDsEZOa"
+      },
+      "execution_count": 76,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "def extract_bounding_box_pymupdf(pdf_path):\n",
+        "    bounding_boxes = []\n",
+        "    pages = pymupdf.open(pdf_path)\n",
+        "    for page_num in range(len(pages)):\n",
+        "        page = pages[page_num]\n",
+        "        tabs = page.find_tables()\n",
+        "        page_tables = []\n",
+        "        for table in range(len(tabs.tables)):\n",
+        "            page_tables.append(list(tabs.tables[table].bbox))\n",
+        "        bounding_boxes.append(page_tables)\n",
+        "    return bounding_boxes"
+      ],
+      "metadata": {
+        "id": "4tPKkL9WDhny"
+      },
+      "execution_count": 89,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "bounding_boxes = extract_bounding_box_pymupdf(\"/content/table-data.pdf\")\n",
+        "bounding_boxes"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "collapsed": true,
+        "id": "wAVMMzeKOUyK",
+        "outputId": "eebfca12-cb13-4c64-d529-5f5349e8e031"
+      },
+      "execution_count": 92,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "[[[18.487498389350044,\n",
+              "   19.124998092651367,\n",
+              "   593.9155578613281,\n",
+              "   109.12499237060547]],\n",
+              " [],\n",
+              " []]"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 92
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "scaled_boxes = scale_bounding_boxes(bounding_boxes, ground_truth)"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "cDRQ3HYOsGqZ",
+        "outputId": "e920c106-bf06-4d0a-abc0-3c4638dad60a"
+      },
+      "execution_count": 38,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "2.13103094886968 2.140958468255127\n",
+            "1.690586078570765 5.6974702138220685\n",
+            "2.6620540127239725 2.66533617646015\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "draw_boxes(\"/content/table-2.png\", scaled_boxes[1])"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 1000
+        },
+        "collapsed": true,
+        "id": "06HAD3ejkAZP",
+        "outputId": "7320bc3a-fb52-41ce-f9c5-900d8cc83f62"
+      },
+      "execution_count": 41,
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<PIL.Image.Image image mode=RGB size=930x1310>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "table_bounding_boxes[\"PyMuPDF\"] = scaled_boxes"
+      ],
+      "metadata": {
+        "id": "FI5bbFlmsFpi"
+      },
+      "execution_count": 44,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "# **GPT 4**"
+      ],
+      "metadata": {
+        "id": "2AsVXS8rUAau"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "!pip install openai"
+      ],
+      "metadata": {
+        "id": "GJmOrHo2UDiR"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import openai\n",
+        "import fitz\n",
+        "import base64\n",
+        "import requests"
+      ],
+      "metadata": {
+        "id": "iThqg5lpUFK0"
+      },
+      "execution_count": 28,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "openai.api_key = 'sk-proj-YOl2xepEsNppWm3xLshlT3BlbkFJL04qQgahGxFcFGEClnQK'\n",
+        "image_media_type = \"image/png\""
+      ],
+      "metadata": {
+        "id": "tJiWKY7rUG3D"
+      },
+      "execution_count": 29,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "def convert_pdf_to_images(pdf_path):\n",
+        "    images = []\n",
+        "    with fitz.open(pdf_path) as doc:\n",
+        "        for page_num in range(len(doc)):\n",
+        "            page = doc.load_page(page_num)\n",
+        "            pix = page.get_pixmap()\n",
+        "            images.append(pix)\n",
+        "    return images\n",
+        "\n",
+        "def encode_image_to_base64(image):\n",
+        "    image_bytes = image.tobytes()\n",
+        "    base64_encoded = base64.b64encode(image_bytes)\n",
+        "    base64_string = base64_encoded.decode(\"utf-8\")\n",
+        "    return base64_string"
+      ],
+      "metadata": {
+        "id": "5EBsT_ZCQuxW"
+      },
+      "execution_count": 30,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "example_image = Image.open(\"/content/bank_statement_1.png\").convert(\"RGB\")\n",
+        "example_bbox = [[404,108,673,167], [11,186,673,532]]\n",
+        "prompt = f\"Extract the bounding boxes of all the tables present in this image. Return the bounding boxes as list of lists. And don't provide any other text in the response.\""
+      ],
+      "metadata": {
+        "id": "dU4cPU86md8R"
+      },
+      "execution_count": 56,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "def extract_bounding_box_gpt(model, pdf_path):\n",
+        "    images = convert_pdf_to_images(pdf_path)\n",
+        "    extracted_bbox = []\n",
+        "    headers = {\n",
+        "        \"Content-Type\": \"application/json\",\n",
+        "        \"Authorization\": f\"Bearer {openai.api_key}\"\n",
+        "    }\n",
+        "\n",
+        "    for image in images:\n",
+        "        base64_string = encode_image_to_base64(image)\n",
+        "        payload = {\n",
+        "            \"model\": model,\n",
+        "            \"messages\": [\n",
+        "              {\n",
+        "                \"role\": \"user\",\n",
+        "                \"content\": [\n",
+        "                  {\n",
+        "                    \"type\": \"text\",\n",
+        "                    \"text\": prompt\n",
+        "                  },\n",
+        "                  {\n",
+        "                    \"type\": \"image_url\",\n",
+        "                    \"image_url\": {\n",
+        "                      \"url\": f\"data:image/jpeg;base64,{base64_string}\"\n",
+        "                    }\n",
+        "                  }\n",
+        "                ]\n",
+        "              }\n",
+        "            ],\n",
+        "          }\n",
+        "\n",
+        "        response = requests.post(\"https://api.openai.com/v1/chat/completions\", headers=headers, json=payload)\n",
+        "        response_json = response.json()\n",
+        "\n",
+        "        if \"choices\" in response_json and len(response_json[\"choices\"]) > 0:\n",
+        "            extracted_bbox.append(ast.literal_eval(response_json[\"choices\"][0][\"message\"][\"content\"]))\n",
+        "\n",
+        "    return extracted_bbox"
+      ],
+      "metadata": {
+        "id": "oB5gjXowUIUZ"
+      },
+      "execution_count": 57,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "extracted_bbox = extract_bounding_box_gpt(\"gpt-4-turbo\", \"/content/table-data.pdf\")\n",
+        "extracted_bbox"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "collapsed": true,
+        "id": "rkSwN68WULHm",
+        "outputId": "104e279b-71c1-433e-8cfe-055c6ecc788e"
+      },
+      "execution_count": 58,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "[[[41, 75, 416, 556]],\n",
+              " [[42, 98, 422, 398], [42, 438, 422, 540]],\n",
+              " [[91, 92, 704, 293]],\n",
+              " [[40, 220, 490, 470]],\n",
+              " [[29, 224, 725, 350], [33, 402, 723, 1026]],\n",
+              " [[207, 148, 789, 719]],\n",
+              " [[34, 507, 412, 562], [22, 578, 426, 742]],\n",
+              " [[68, 199, 343, 236], [67, 248, 342, 366], [65, 374, 343, 517]],\n",
+              " [[41, 467, 287, 587]],\n",
+              " [[35, 415, 293, 493], [48, 538, 268, 577]],\n",
+              " [[35, 335, 385, 480]],\n",
+              " [[44, 85, 365, 167], [44, 542, 365, 760]],\n",
+              " [[26, 109, 383, 522]],\n",
+              " [[22, 284, 385, 858], [22, 902, 385, 1188], [22, 1581, 385, 1833]],\n",
+              " [[59, 181, 353, 253], [59, 299, 350, 372]],\n",
+              " [[49, 325, 476, 428], [48, 630, 475, 812], [48, 949, 475, 1032]],\n",
+              " [[111, 300, 391, 658]],\n",
+              " [[177, 283, 390, 120]],\n",
+              " [[108, 375, 309, 618]]]"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 58
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "scaled_boxes = scale_bounding_boxes(extracted_bbox, GroundTruth)"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "collapsed": true,
+        "id": "X7dG9YCksmM2",
+        "outputId": "3cdf3b28-b476-4a93-baff-15ab599392cf"
+      },
+      "execution_count": 61,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "1.9653333333333334 1.3846153846153846\n",
+            "1.9421052631578948 0.88\n",
+            "1.497553017944535 1.7661691542288558\n",
+            "1.471111111111111 1.384\n",
+            "1.2543103448275863 5.150793650793651\n",
+            "1.0841924398625429 1.2136602451838878\n",
+            "1.3624338624338623 3.909090909090909\n",
+            "1.3709090909090909 9.91891891891892\n",
+            "2.1504065040650406 2.933333333333333\n",
+            "2.197674418604651 1.4871794871794872\n",
+            "2.045714285714286 1.8620689655172413\n",
+            "1.0591900311526479 4.939024390243903\n",
+            "2.008403361344538 1.6997578692493946\n",
+            "1.5509641873278237 0.41114982578397213\n",
+            "2.6122448979591835 5.597222222222222\n",
+            "1.8056206088992974 1.6116504854368932\n",
+            "2.7535714285714286 2.5279329608938546\n",
+            "2.3380281690140845 -1.01840490797546\n",
+            "2.4776119402985075 1.2181069958847737\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "table_bounding_boxes[\"GPT 4 Turbo\"] = scaled_boxes"
+      ],
+      "metadata": {
+        "id": "47Rn-VKqqGEq"
+      },
+      "execution_count": 46,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "extracted_bbox = extract_bounding_box_gpt(\"gpt-4o\", \"/content/table-data.pdf\")\n",
+        "extracted_bbox"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "collapsed": true,
+        "id": "dNOSNu7GRMtz",
+        "outputId": "7cd39e3e-74f0-492e-e8c0-00d779297129"
+      },
+      "execution_count": 48,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "[[[41, 118, 488, 403]],\n",
+              " [[100, 78, 468, 275], [100, 296, 468, 440]],\n",
+              " [[307, 119, 794, 274]],\n",
+              " [[32, 379, 321, 394], [31, 102, 504, 373]],\n",
+              " [[50, 273, 684, 823]],\n",
+              " [[84, 125, 702, 840]],\n",
+              " [[25, 157, 247, 340],\n",
+              "  [281, 157, 465, 340],\n",
+              "  [25, 346, 465, 451],\n",
+              "  [22, 472, 465, 675]],\n",
+              " [[63, 320, 266, 439],\n",
+              "  [63, 447, 265, 525],\n",
+              "  [80, 76, 279, 175],\n",
+              "  [55, 135, 320, 371]],\n",
+              " [[44, 258, 456, 298],\n",
+              "  [44, 294, 456, 332],\n",
+              "  [44, 331, 456, 369],\n",
+              "  [44, 368, 456, 406],\n",
+              "  [44, 405, 456, 445],\n",
+              "  [44, 442, 456, 480],\n",
+              "  [44, 480, 456, 518],\n",
+              "  [44, 518, 456, 558]],\n",
+              " [[55, 236, 359, 361], [60, 376, 387, 525], [52, 533, 348, 554]],\n",
+              " [[52, 308, 518, 434], [52, 444, 243, 474]],\n",
+              " [[47, 49, 170, 135], [33, 150, 241, 405], [334, 138, 471, 410]],\n",
+              " [[67, 220, 993, 2001]],\n",
+              " [[79, 59, 673, 225], [79, 326, 674, 490], [81, 709, 674, 746]],\n",
+              " [[46, 289, 444, 553]],\n",
+              " [[50, 181, 563, 266], [50, 278, 729, 335], [50, 352, 729, 413]],\n",
+              " [[45, 77, 525, 106],\n",
+              "  [25, 108, 545, 165],\n",
+              "  [20, 181, 550, 236],\n",
+              "  [20, 241, 550, 297],\n",
+              "  [20, 301, 550, 356],\n",
+              "  [20, 361, 550, 416],\n",
+              "  [20, 421, 550, 476],\n",
+              "  [20, 481, 550, 536],\n",
+              "  [20, 541, 550, 596]],\n",
+              " [[59, 132, 501, 227], [132, 244, 303, 260]],\n",
+              " [[92, 79, 516, 277]]]"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 48
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "scaled_boxes = scale_bounding_boxes(extracted_bbox, GroundTruth)"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "collapsed": true,
+        "id": "embI9wAys2ZH",
+        "outputId": "fd470ce9-056d-4a08-9fc9-d41017c30640"
+      },
+      "execution_count": 51,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "1.6487695749440716 2.336842105263158\n",
+            "2.005434782608696 1.3401015228426396\n",
+            "1.8850102669404518 2.2903225806451615\n",
+            "2.290657439446367 23.066666666666666\n",
+            "1.3769716088328077 1.18\n",
+            "1.0210355987055015 0.9692307692307692\n",
+            "2.31981981981982 1.174863387978142\n",
+            "1.8571428571428572 3.0840336134453783\n",
+            "1.2839805825242718 8.8\n",
+            "1.8651315789473684 0.928\n",
+            "1.536480686695279 2.142857142857143\n",
+            "2.7642276422764227 4.709302325581396\n",
+            "0.7742980561555075 0.39416058394160586\n",
+            "0.9478114478114478 1.4216867469879517\n",
+            "1.92964824120603 1.5265151515151516\n",
+            "1.5029239766081872 1.9529411764705882\n",
+            "1.60625 31.20689655172414\n",
+            "1.1266968325791855 1.7473684210526317\n",
+            "1.1745283018867925 1.494949494949495\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "table_bounding_boxes[\"GPT 4o\"] = scaled_boxes"
+      ],
+      "metadata": {
+        "id": "S7alFPQEqTEl"
+      },
+      "execution_count": 52,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "# **img2table**"
+      ],
+      "metadata": {
+        "id": "2ZELpJaMsAkl"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "!pip install img2table"
+      ],
+      "metadata": {
+        "id": "ydQhLMEPr5wC"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "from img2table.document import Image"
+      ],
+      "metadata": {
+        "id": "Sc71P2lVsIeQ"
+      },
+      "execution_count": 94,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "def extract_bounding_box_img2table(image_path):\n",
+        "    img = Image(src=image_path)\n",
+        "    extracted_tables = img.extract_tables()\n",
+        "    bbox_values = [[table.bbox.x1, table.bbox.y1, table.bbox.x2, table.bbox.y2] for table in extracted_tables]\n",
+        "    return bbox_values"
+      ],
+      "metadata": {
+        "id": "pxsLJ0z9r-8-"
+      },
+      "execution_count": 95,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "bounding_boxes = []\n",
+        "for image_id in range(1, number_of_table_images+1):\n",
+        "    bounding_boxes.append(extract_bounding_box_img2table(f\"/content/table-{image_id}.png\"))\n",
+        "bounding_boxes"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "collapsed": true,
+        "id": "QpadNqqrtn-F",
+        "outputId": "b3945957-cfe8-4d05-d15f-a8663eb91feb"
+      },
+      "execution_count": 96,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "[[[93, 164, 830, 825], [93, 164, 827, 189]],\n",
+              " [[106, 280, 844, 398], [106, 542, 840, 775], [107, 162, 840, 187]],\n",
+              " [[78, 511, 513, 655], [553, 128, 1470, 481], [885, 152, 968, 169]],\n",
+              " [],\n",
+              " [[65, 481, 934, 1123]],\n",
+              " [],\n",
+              " [],\n",
+              " [[82, 458, 458, 826], [490, 105, 748, 152], [490, 747, 748, 805]],\n",
+              " [],\n",
+              " [[46, 342, 609, 454], [46, 505, 608, 701]],\n",
+              " [[62, 415, 774, 681]],\n",
+              " [],\n",
+              " [[49, 194, 768, 844]],\n",
+              " [[128, 89, 687, 306], [130, 378, 686, 582], [150, 824, 666, 893]],\n",
+              " [],\n",
+              " [[26, 26, 791, 186]],\n",
+              " [],\n",
+              " [],\n",
+              " []]"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 96
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "table_bounding_boxes[\"img2table\"] = bounding_boxes"
+      ],
+      "metadata": {
+        "id": "bh8i_5rSt96q"
+      },
+      "execution_count": 102,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "# **ExtractTable**"
+      ],
+      "metadata": {
+        "id": "SFMoKtzdyYHU"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "!pip install -U ExtractTable"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "jZuKNeDmw_ZC",
+        "outputId": "21044963-7572-45c1-ae22-71e4e5624add"
+      },
+      "execution_count": 75,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Collecting ExtractTable\n",
+            "  Downloading ExtractTable-2.4.0-py3-none-any.whl (19 kB)\n",
+            "Requirement already satisfied: requests>=2.21 in /usr/local/lib/python3.10/dist-packages (from ExtractTable) (2.31.0)\n",
+            "Requirement already satisfied: pandas>=0.24 in /usr/local/lib/python3.10/dist-packages (from ExtractTable) (2.0.3)\n",
+            "Collecting PyPDF2>=1.26 (from ExtractTable)\n",
+            "  Downloading pypdf2-3.0.1-py3-none-any.whl (232 kB)\n",
+            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m232.6/232.6 kB\u001b[0m \u001b[31m4.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+            "\u001b[?25hRequirement already satisfied: python-dateutil>=2.8.2 in /usr/local/lib/python3.10/dist-packages (from pandas>=0.24->ExtractTable) (2.8.2)\n",
+            "Requirement already satisfied: pytz>=2020.1 in /usr/local/lib/python3.10/dist-packages (from pandas>=0.24->ExtractTable) (2023.4)\n",
+            "Requirement already satisfied: tzdata>=2022.1 in /usr/local/lib/python3.10/dist-packages (from pandas>=0.24->ExtractTable) (2024.1)\n",
+            "Requirement already satisfied: numpy>=1.21.0 in /usr/local/lib/python3.10/dist-packages (from pandas>=0.24->ExtractTable) (1.25.2)\n",
+            "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.10/dist-packages (from requests>=2.21->ExtractTable) (3.3.2)\n",
+            "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.10/dist-packages (from requests>=2.21->ExtractTable) (3.7)\n",
+            "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.10/dist-packages (from requests>=2.21->ExtractTable) (2.0.7)\n",
+            "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.10/dist-packages (from requests>=2.21->ExtractTable) (2024.6.2)\n",
+            "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.10/dist-packages (from python-dateutil>=2.8.2->pandas>=0.24->ExtractTable) (1.16.0)\n",
+            "Installing collected packages: PyPDF2, ExtractTable\n",
+            "Successfully installed ExtractTable-2.4.0 PyPDF2-3.0.1\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "from ExtractTable import ExtractTable\n",
+        "et_sess = ExtractTable(api_key=\"Iu0sfQOnq5TufIroG7V2mXZfxR702JI8GirF0hBE\")\n",
+        "print(et_sess.check_usage())\n",
+        "# table_data = et_sess.process_file(filepath=\"/content/table-3.png\", output_format=\"df\")\n",
+        "table_data = et_sess.process_file(filepath=\"/content/tables1-3.pdf\", output_format=\"df\", pages=\"all\")"
+      ],
+      "metadata": {
+        "id": "mr2BNAmtxC3D"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "for table in table_data:\n",
+        "    display(table)"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 1000
+        },
+        "id": "rP0fJCVtxfnY",
+        "outputId": "1bb5d9f9-f5fb-494a-9d9a-9171a4f4158d"
+      },
+      "execution_count": 144,
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "           0                 1  \\\n",
+              "0                                \n",
+              "1                                \n",
+              "2                       Type A   \n",
+              "3                                \n",
+              "4                                \n",
+              "5      Front            Type B   \n",
+              "6                                \n",
+              "7                                \n",
+              "8                       Type C   \n",
+              "9                                \n",
+              "10               Side repeater   \n",
+              "11                  Tail light   \n",
+              "12                  Stop light   \n",
+              "13                 Turn signal   \n",
+              "14      Rear     Back up light   \n",
+              "15            Reflex reflector   \n",
+              "16                High mounted   \n",
+              "17               License plate   \n",
+              "18                    Map lamp   \n",
+              "19  Interior         Room lamp   \n",
+              "20                     Luggage   \n",
+              "\n",
+              "                                                    2          3  \\\n",
+              "0                                          Light Bulb  Bulb type   \n",
+              "1                                Headlight (high/low)      H19LL   \n",
+              "2                                      Position light        W5W   \n",
+              "3                                   Turn signal light      PY21W   \n",
+              "4                                Headlight (high/low)      H19LL   \n",
+              "5   Position light/ Daytime Running Light (if equi...        LED   \n",
+              "6                                   Turn signal light      PY21W   \n",
+              "7                                Headlight (high/low)     9005HL   \n",
+              "8   Position light/ Daytime Running Light (if equi...        LED   \n",
+              "9                                   Turn signal light      PY21W   \n",
+              "10                           light (outside mirror) *       WY5W   \n",
+              "11                                                           LED   \n",
+              "12                                                        P21/5W   \n",
+              "13                                              light      PY21W   \n",
+              "14                                                          W16W   \n",
+              "15                                                             -   \n",
+              "16                                        stop light*        W5W   \n",
+              "17                                              light        W5W   \n",
+              "18                                                       FESTOON   \n",
+              "19                                                       FESTOON   \n",
+              "20                                 compartment lamp *    FESTOON   \n",
+              "\n",
+              "                       4  \n",
+              "0                Wattage  \n",
+              "1                60/55 W  \n",
+              "2                    5 W  \n",
+              "3                   21 W  \n",
+              "4                60/55 W  \n",
+              "5   POS/DRL : 1.6/12.2 W  \n",
+              "6                   21 W  \n",
+              "7                   60 W  \n",
+              "8   POS/DRL : 1.6/12.2 W  \n",
+              "9                    21W  \n",
+              "10                   5 W  \n",
+              "11                 2.5 W  \n",
+              "12                  21 W  \n",
+              "13                  21 W  \n",
+              "14                  16 W  \n",
+              "15                     -  \n",
+              "16            5W * 04 EA  \n",
+              "17            5W * 02 EA  \n",
+              "18            8 W * 02EA  \n",
+              "19                   8 W  \n",
+              "20                  10 W  "
+            ],
+            "text/html": [
+              "\n",
+              "  <div id=\"df-ad89e177-0b3d-4ebd-b8e6-7bcc048284d4\" class=\"colab-df-container\">\n",
+              "    <div>\n",
+              "<style scoped>\n",
+              "    .dataframe tbody tr th:only-of-type {\n",
+              "        vertical-align: middle;\n",
+              "    }\n",
+              "\n",
+              "    .dataframe tbody tr th {\n",
+              "        vertical-align: top;\n",
+              "    }\n",
+              "\n",
+              "    .dataframe thead th {\n",
+              "        text-align: right;\n",
+              "    }\n",
+              "</style>\n",
+              "<table border=\"1\" class=\"dataframe\">\n",
+              "  <thead>\n",
+              "    <tr style=\"text-align: right;\">\n",
+              "      <th></th>\n",
+              "      <th>0</th>\n",
+              "      <th>1</th>\n",
+              "      <th>2</th>\n",
+              "      <th>3</th>\n",
+              "      <th>4</th>\n",
+              "    </tr>\n",
+              "  </thead>\n",
+              "  <tbody>\n",
+              "    <tr>\n",
+              "      <th>0</th>\n",
+              "      <td></td>\n",
+              "      <td></td>\n",
+              "      <td>Light Bulb</td>\n",
+              "      <td>Bulb type</td>\n",
+              "      <td>Wattage</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>1</th>\n",
+              "      <td></td>\n",
+              "      <td></td>\n",
+              "      <td>Headlight (high/low)</td>\n",
+              "      <td>H19LL</td>\n",
+              "      <td>60/55 W</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>2</th>\n",
+              "      <td></td>\n",
+              "      <td>Type A</td>\n",
+              "      <td>Position light</td>\n",
+              "      <td>W5W</td>\n",
+              "      <td>5 W</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>3</th>\n",
+              "      <td></td>\n",
+              "      <td></td>\n",
+              "      <td>Turn signal light</td>\n",
+              "      <td>PY21W</td>\n",
+              "      <td>21 W</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>4</th>\n",
+              "      <td></td>\n",
+              "      <td></td>\n",
+              "      <td>Headlight (high/low)</td>\n",
+              "      <td>H19LL</td>\n",
+              "      <td>60/55 W</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>5</th>\n",
+              "      <td>Front</td>\n",
+              "      <td>Type B</td>\n",
+              "      <td>Position light/ Daytime Running Light (if equi...</td>\n",
+              "      <td>LED</td>\n",
+              "      <td>POS/DRL : 1.6/12.2 W</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>6</th>\n",
+              "      <td></td>\n",
+              "      <td></td>\n",
+              "      <td>Turn signal light</td>\n",
+              "      <td>PY21W</td>\n",
+              "      <td>21 W</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>7</th>\n",
+              "      <td></td>\n",
+              "      <td></td>\n",
+              "      <td>Headlight (high/low)</td>\n",
+              "      <td>9005HL</td>\n",
+              "      <td>60 W</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>8</th>\n",
+              "      <td></td>\n",
+              "      <td>Type C</td>\n",
+              "      <td>Position light/ Daytime Running Light (if equi...</td>\n",
+              "      <td>LED</td>\n",
+              "      <td>POS/DRL : 1.6/12.2 W</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>9</th>\n",
+              "      <td></td>\n",
+              "      <td></td>\n",
+              "      <td>Turn signal light</td>\n",
+              "      <td>PY21W</td>\n",
+              "      <td>21W</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>10</th>\n",
+              "      <td></td>\n",
+              "      <td>Side repeater</td>\n",
+              "      <td>light (outside mirror) *</td>\n",
+              "      <td>WY5W</td>\n",
+              "      <td>5 W</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>11</th>\n",
+              "      <td></td>\n",
+              "      <td>Tail light</td>\n",
+              "      <td></td>\n",
+              "      <td>LED</td>\n",
+              "      <td>2.5 W</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>12</th>\n",
+              "      <td></td>\n",
+              "      <td>Stop light</td>\n",
+              "      <td></td>\n",
+              "      <td>P21/5W</td>\n",
+              "      <td>21 W</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>13</th>\n",
+              "      <td></td>\n",
+              "      <td>Turn signal</td>\n",
+              "      <td>light</td>\n",
+              "      <td>PY21W</td>\n",
+              "      <td>21 W</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>14</th>\n",
+              "      <td>Rear</td>\n",
+              "      <td>Back up light</td>\n",
+              "      <td></td>\n",
+              "      <td>W16W</td>\n",
+              "      <td>16 W</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>15</th>\n",
+              "      <td></td>\n",
+              "      <td>Reflex reflector</td>\n",
+              "      <td></td>\n",
+              "      <td>-</td>\n",
+              "      <td>-</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>16</th>\n",
+              "      <td></td>\n",
+              "      <td>High mounted</td>\n",
+              "      <td>stop light*</td>\n",
+              "      <td>W5W</td>\n",
+              "      <td>5W * 04 EA</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>17</th>\n",
+              "      <td></td>\n",
+              "      <td>License plate</td>\n",
+              "      <td>light</td>\n",
+              "      <td>W5W</td>\n",
+              "      <td>5W * 02 EA</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>18</th>\n",
+              "      <td></td>\n",
+              "      <td>Map lamp</td>\n",
+              "      <td></td>\n",
+              "      <td>FESTOON</td>\n",
+              "      <td>8 W * 02EA</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>19</th>\n",
+              "      <td>Interior</td>\n",
+              "      <td>Room lamp</td>\n",
+              "      <td></td>\n",
+              "      <td>FESTOON</td>\n",
+              "      <td>8 W</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>20</th>\n",
+              "      <td></td>\n",
+              "      <td>Luggage</td>\n",
+              "      <td>compartment lamp *</td>\n",
+              "      <td>FESTOON</td>\n",
+              "      <td>10 W</td>\n",
+              "    </tr>\n",
+              "  </tbody>\n",
+              "</table>\n",
+              "</div>\n",
+              "    <div class=\"colab-df-buttons\">\n",
+              "\n",
+              "  <div class=\"colab-df-container\">\n",
+              "    <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-ad89e177-0b3d-4ebd-b8e6-7bcc048284d4')\"\n",
+              "            title=\"Convert this dataframe to an interactive table.\"\n",
+              "            style=\"display:none;\">\n",
+              "\n",
+              "  <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\" viewBox=\"0 -960 960 960\">\n",
+              "    <path d=\"M120-120v-720h720v720H120Zm60-500h600v-160H180v160Zm220 220h160v-160H400v160Zm0 220h160v-160H400v160ZM180-400h160v-160H180v160Zm440 0h160v-160H620v160ZM180-180h160v-160H180v160Zm440 0h160v-160H620v160Z\"/>\n",
+              "  </svg>\n",
+              "    </button>\n",
+              "\n",
+              "  <style>\n",
+              "    .colab-df-container {\n",
+              "      display:flex;\n",
+              "      gap: 12px;\n",
+              "    }\n",
+              "\n",
+              "    .colab-df-convert {\n",
+              "      background-color: #E8F0FE;\n",
+              "      border: none;\n",
+              "      border-radius: 50%;\n",
+              "      cursor: pointer;\n",
+              "      display: none;\n",
+              "      fill: #1967D2;\n",
+              "      height: 32px;\n",
+              "      padding: 0 0 0 0;\n",
+              "      width: 32px;\n",
+              "    }\n",
+              "\n",
+              "    .colab-df-convert:hover {\n",
+              "      background-color: #E2EBFA;\n",
+              "      box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
+              "      fill: #174EA6;\n",
+              "    }\n",
+              "\n",
+              "    .colab-df-buttons div {\n",
+              "      margin-bottom: 4px;\n",
+              "    }\n",
+              "\n",
+              "    [theme=dark] .colab-df-convert {\n",
+              "      background-color: #3B4455;\n",
+              "      fill: #D2E3FC;\n",
+              "    }\n",
+              "\n",
+              "    [theme=dark] .colab-df-convert:hover {\n",
+              "      background-color: #434B5C;\n",
+              "      box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n",
+              "      filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n",
+              "      fill: #FFFFFF;\n",
+              "    }\n",
+              "  </style>\n",
+              "\n",
+              "    <script>\n",
+              "      const buttonEl =\n",
+              "        document.querySelector('#df-ad89e177-0b3d-4ebd-b8e6-7bcc048284d4 button.colab-df-convert');\n",
+              "      buttonEl.style.display =\n",
+              "        google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
+              "\n",
+              "      async function convertToInteractive(key) {\n",
+              "        const element = document.querySelector('#df-ad89e177-0b3d-4ebd-b8e6-7bcc048284d4');\n",
+              "        const dataTable =\n",
+              "          await google.colab.kernel.invokeFunction('convertToInteractive',\n",
+              "                                                    [key], {});\n",
+              "        if (!dataTable) return;\n",
+              "\n",
+              "        const docLinkHtml = 'Like what you see? Visit the ' +\n",
+              "          '<a target=\"_blank\" href=https://colab.research.google.com/notebooks/data_table.ipynb>data table notebook</a>'\n",
+              "          + ' to learn more about interactive tables.';\n",
+              "        element.innerHTML = '';\n",
+              "        dataTable['output_type'] = 'display_data';\n",
+              "        await google.colab.output.renderOutput(dataTable, element);\n",
+              "        const docLink = document.createElement('div');\n",
+              "        docLink.innerHTML = docLinkHtml;\n",
+              "        element.appendChild(docLink);\n",
+              "      }\n",
+              "    </script>\n",
+              "  </div>\n",
+              "\n",
+              "\n",
+              "<div id=\"df-befe1a57-e820-4808-a06c-d04ced212a1a\">\n",
+              "  <button class=\"colab-df-quickchart\" onclick=\"quickchart('df-befe1a57-e820-4808-a06c-d04ced212a1a')\"\n",
+              "            title=\"Suggest charts\"\n",
+              "            style=\"display:none;\">\n",
+              "\n",
+              "<svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\"viewBox=\"0 0 24 24\"\n",
+              "     width=\"24px\">\n",
+              "    <g>\n",
+              "        <path d=\"M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zM9 17H7v-7h2v7zm4 0h-2V7h2v10zm4 0h-2v-4h2v4z\"/>\n",
+              "    </g>\n",
+              "</svg>\n",
+              "  </button>\n",
+              "\n",
+              "<style>\n",
+              "  .colab-df-quickchart {\n",
+              "      --bg-color: #E8F0FE;\n",
+              "      --fill-color: #1967D2;\n",
+              "      --hover-bg-color: #E2EBFA;\n",
+              "      --hover-fill-color: #174EA6;\n",
+              "      --disabled-fill-color: #AAA;\n",
+              "      --disabled-bg-color: #DDD;\n",
+              "  }\n",
+              "\n",
+              "  [theme=dark] .colab-df-quickchart {\n",
+              "      --bg-color: #3B4455;\n",
+              "      --fill-color: #D2E3FC;\n",
+              "      --hover-bg-color: #434B5C;\n",
+              "      --hover-fill-color: #FFFFFF;\n",
+              "      --disabled-bg-color: #3B4455;\n",
+              "      --disabled-fill-color: #666;\n",
+              "  }\n",
+              "\n",
+              "  .colab-df-quickchart {\n",
+              "    background-color: var(--bg-color);\n",
+              "    border: none;\n",
+              "    border-radius: 50%;\n",
+              "    cursor: pointer;\n",
+              "    display: none;\n",
+              "    fill: var(--fill-color);\n",
+              "    height: 32px;\n",
+              "    padding: 0;\n",
+              "    width: 32px;\n",
+              "  }\n",
+              "\n",
+              "  .colab-df-quickchart:hover {\n",
+              "    background-color: var(--hover-bg-color);\n",
+              "    box-shadow: 0 1px 2px rgba(60, 64, 67, 0.3), 0 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
+              "    fill: var(--button-hover-fill-color);\n",
+              "  }\n",
+              "\n",
+              "  .colab-df-quickchart-complete:disabled,\n",
+              "  .colab-df-quickchart-complete:disabled:hover {\n",
+              "    background-color: var(--disabled-bg-color);\n",
+              "    fill: var(--disabled-fill-color);\n",
+              "    box-shadow: none;\n",
+              "  }\n",
+              "\n",
+              "  .colab-df-spinner {\n",
+              "    border: 2px solid var(--fill-color);\n",
+              "    border-color: transparent;\n",
+              "    border-bottom-color: var(--fill-color);\n",
+              "    animation:\n",
+              "      spin 1s steps(1) infinite;\n",
+              "  }\n",
+              "\n",
+              "  @keyframes spin {\n",
+              "    0% {\n",
+              "      border-color: transparent;\n",
+              "      border-bottom-color: var(--fill-color);\n",
+              "      border-left-color: var(--fill-color);\n",
+              "    }\n",
+              "    20% {\n",
+              "      border-color: transparent;\n",
+              "      border-left-color: var(--fill-color);\n",
+              "      border-top-color: var(--fill-color);\n",
+              "    }\n",
+              "    30% {\n",
+              "      border-color: transparent;\n",
+              "      border-left-color: var(--fill-color);\n",
+              "      border-top-color: var(--fill-color);\n",
+              "      border-right-color: var(--fill-color);\n",
+              "    }\n",
+              "    40% {\n",
+              "      border-color: transparent;\n",
+              "      border-right-color: var(--fill-color);\n",
+              "      border-top-color: var(--fill-color);\n",
+              "    }\n",
+              "    60% {\n",
+              "      border-color: transparent;\n",
+              "      border-right-color: var(--fill-color);\n",
+              "    }\n",
+              "    80% {\n",
+              "      border-color: transparent;\n",
+              "      border-right-color: var(--fill-color);\n",
+              "      border-bottom-color: var(--fill-color);\n",
+              "    }\n",
+              "    90% {\n",
+              "      border-color: transparent;\n",
+              "      border-bottom-color: var(--fill-color);\n",
+              "    }\n",
+              "  }\n",
+              "</style>\n",
+              "\n",
+              "  <script>\n",
+              "    async function quickchart(key) {\n",
+              "      const quickchartButtonEl =\n",
+              "        document.querySelector('#' + key + ' button');\n",
+              "      quickchartButtonEl.disabled = true;  // To prevent multiple clicks.\n",
+              "      quickchartButtonEl.classList.add('colab-df-spinner');\n",
+              "      try {\n",
+              "        const charts = await google.colab.kernel.invokeFunction(\n",
+              "            'suggestCharts', [key], {});\n",
+              "      } catch (error) {\n",
+              "        console.error('Error during call to suggestCharts:', error);\n",
+              "      }\n",
+              "      quickchartButtonEl.classList.remove('colab-df-spinner');\n",
+              "      quickchartButtonEl.classList.add('colab-df-quickchart-complete');\n",
+              "    }\n",
+              "    (() => {\n",
+              "      let quickchartButtonEl =\n",
+              "        document.querySelector('#df-befe1a57-e820-4808-a06c-d04ced212a1a button');\n",
+              "      quickchartButtonEl.style.display =\n",
+              "        google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
+              "    })();\n",
+              "  </script>\n",
+              "</div>\n",
+              "    </div>\n",
+              "  </div>\n"
+            ],
+            "application/vnd.google.colaboratory.intrinsic+json": {
+              "type": "dataframe",
+              "variable_name": "table",
+              "summary": "{\n  \"name\": \"table\",\n  \"rows\": 21,\n  \"fields\": [\n    {\n      \"column\": \"0\",\n      \"properties\": {\n        \"dtype\": \"category\",\n        \"num_unique_values\": 4,\n        \"samples\": [\n          \"Front\",\n          \"Interior\",\n          \"\"\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"1\",\n      \"properties\": {\n        \"dtype\": \"string\",\n        \"num_unique_values\": 15,\n        \"samples\": [\n          \"Reflex reflector\",\n          \"License plate\",\n          \"\"\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"2\",\n      \"properties\": {\n        \"dtype\": \"category\",\n        \"num_unique_values\": 10,\n        \"samples\": [\n          \"stop light*\",\n          \"Headlight (high/low)\",\n          \"light (outside mirror) *\"\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"3\",\n      \"properties\": {\n        \"dtype\": \"string\",\n        \"num_unique_values\": 11,\n        \"samples\": [\n          \"9005HL\",\n          \"Bulb type\",\n          \"-\"\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"4\",\n      \"properties\": {\n        \"dtype\": \"string\",\n        \"num_unique_values\": 15,\n        \"samples\": [\n          \"-\",\n          \"5W * 02 EA\",\n          \"Wattage\"\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    }\n  ]\n}"
+            }
+          },
+          "metadata": {}
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "                0           1                              2\n",
+              "0            Item                                   mm (in.)\n",
+              "1  Overall length                              3,815 (150.2)\n",
+              "2   Overall width                               1,710 (67.3)\n",
+              "3  Overall height              1,585 (62.4) / 1,618* (63.7*)\n",
+              "4                  165/70 R14                   1,487 (58.5)\n",
+              "5     Front tread  175/65 R15                   1,475 (58.1)\n",
+              "6                  165/70 R14                   1,504 (59.2)\n",
+              "7      Rear tread  175/65 R15                   1,492 (58.7)\n",
+              "8       Wheelbase                               2,450 (96.5)"
+            ],
+            "text/html": [
+              "\n",
+              "  <div id=\"df-4ddc1275-4f2c-483c-b5c8-93b4184ede40\" class=\"colab-df-container\">\n",
+              "    <div>\n",
+              "<style scoped>\n",
+              "    .dataframe tbody tr th:only-of-type {\n",
+              "        vertical-align: middle;\n",
+              "    }\n",
+              "\n",
+              "    .dataframe tbody tr th {\n",
+              "        vertical-align: top;\n",
+              "    }\n",
+              "\n",
+              "    .dataframe thead th {\n",
+              "        text-align: right;\n",
+              "    }\n",
+              "</style>\n",
+              "<table border=\"1\" class=\"dataframe\">\n",
+              "  <thead>\n",
+              "    <tr style=\"text-align: right;\">\n",
+              "      <th></th>\n",
+              "      <th>0</th>\n",
+              "      <th>1</th>\n",
+              "      <th>2</th>\n",
+              "    </tr>\n",
+              "  </thead>\n",
+              "  <tbody>\n",
+              "    <tr>\n",
+              "      <th>0</th>\n",
+              "      <td>Item</td>\n",
+              "      <td></td>\n",
+              "      <td>mm (in.)</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>1</th>\n",
+              "      <td>Overall length</td>\n",
+              "      <td></td>\n",
+              "      <td>3,815 (150.2)</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>2</th>\n",
+              "      <td>Overall width</td>\n",
+              "      <td></td>\n",
+              "      <td>1,710 (67.3)</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>3</th>\n",
+              "      <td>Overall height</td>\n",
+              "      <td></td>\n",
+              "      <td>1,585 (62.4) / 1,618* (63.7*)</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>4</th>\n",
+              "      <td></td>\n",
+              "      <td>165/70 R14</td>\n",
+              "      <td>1,487 (58.5)</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>5</th>\n",
+              "      <td>Front tread</td>\n",
+              "      <td>175/65 R15</td>\n",
+              "      <td>1,475 (58.1)</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>6</th>\n",
+              "      <td></td>\n",
+              "      <td>165/70 R14</td>\n",
+              "      <td>1,504 (59.2)</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>7</th>\n",
+              "      <td>Rear tread</td>\n",
+              "      <td>175/65 R15</td>\n",
+              "      <td>1,492 (58.7)</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>8</th>\n",
+              "      <td>Wheelbase</td>\n",
+              "      <td></td>\n",
+              "      <td>2,450 (96.5)</td>\n",
+              "    </tr>\n",
+              "  </tbody>\n",
+              "</table>\n",
+              "</div>\n",
+              "    <div class=\"colab-df-buttons\">\n",
+              "\n",
+              "  <div class=\"colab-df-container\">\n",
+              "    <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-4ddc1275-4f2c-483c-b5c8-93b4184ede40')\"\n",
+              "            title=\"Convert this dataframe to an interactive table.\"\n",
+              "            style=\"display:none;\">\n",
+              "\n",
+              "  <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\" viewBox=\"0 -960 960 960\">\n",
+              "    <path d=\"M120-120v-720h720v720H120Zm60-500h600v-160H180v160Zm220 220h160v-160H400v160Zm0 220h160v-160H400v160ZM180-400h160v-160H180v160Zm440 0h160v-160H620v160ZM180-180h160v-160H180v160Zm440 0h160v-160H620v160Z\"/>\n",
+              "  </svg>\n",
+              "    </button>\n",
+              "\n",
+              "  <style>\n",
+              "    .colab-df-container {\n",
+              "      display:flex;\n",
+              "      gap: 12px;\n",
+              "    }\n",
+              "\n",
+              "    .colab-df-convert {\n",
+              "      background-color: #E8F0FE;\n",
+              "      border: none;\n",
+              "      border-radius: 50%;\n",
+              "      cursor: pointer;\n",
+              "      display: none;\n",
+              "      fill: #1967D2;\n",
+              "      height: 32px;\n",
+              "      padding: 0 0 0 0;\n",
+              "      width: 32px;\n",
+              "    }\n",
+              "\n",
+              "    .colab-df-convert:hover {\n",
+              "      background-color: #E2EBFA;\n",
+              "      box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
+              "      fill: #174EA6;\n",
+              "    }\n",
+              "\n",
+              "    .colab-df-buttons div {\n",
+              "      margin-bottom: 4px;\n",
+              "    }\n",
+              "\n",
+              "    [theme=dark] .colab-df-convert {\n",
+              "      background-color: #3B4455;\n",
+              "      fill: #D2E3FC;\n",
+              "    }\n",
+              "\n",
+              "    [theme=dark] .colab-df-convert:hover {\n",
+              "      background-color: #434B5C;\n",
+              "      box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n",
+              "      filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n",
+              "      fill: #FFFFFF;\n",
+              "    }\n",
+              "  </style>\n",
+              "\n",
+              "    <script>\n",
+              "      const buttonEl =\n",
+              "        document.querySelector('#df-4ddc1275-4f2c-483c-b5c8-93b4184ede40 button.colab-df-convert');\n",
+              "      buttonEl.style.display =\n",
+              "        google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
+              "\n",
+              "      async function convertToInteractive(key) {\n",
+              "        const element = document.querySelector('#df-4ddc1275-4f2c-483c-b5c8-93b4184ede40');\n",
+              "        const dataTable =\n",
+              "          await google.colab.kernel.invokeFunction('convertToInteractive',\n",
+              "                                                    [key], {});\n",
+              "        if (!dataTable) return;\n",
+              "\n",
+              "        const docLinkHtml = 'Like what you see? Visit the ' +\n",
+              "          '<a target=\"_blank\" href=https://colab.research.google.com/notebooks/data_table.ipynb>data table notebook</a>'\n",
+              "          + ' to learn more about interactive tables.';\n",
+              "        element.innerHTML = '';\n",
+              "        dataTable['output_type'] = 'display_data';\n",
+              "        await google.colab.output.renderOutput(dataTable, element);\n",
+              "        const docLink = document.createElement('div');\n",
+              "        docLink.innerHTML = docLinkHtml;\n",
+              "        element.appendChild(docLink);\n",
+              "      }\n",
+              "    </script>\n",
+              "  </div>\n",
+              "\n",
+              "\n",
+              "<div id=\"df-f7898f9d-fab8-47c9-8b19-821519e017fc\">\n",
+              "  <button class=\"colab-df-quickchart\" onclick=\"quickchart('df-f7898f9d-fab8-47c9-8b19-821519e017fc')\"\n",
+              "            title=\"Suggest charts\"\n",
+              "            style=\"display:none;\">\n",
+              "\n",
+              "<svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\"viewBox=\"0 0 24 24\"\n",
+              "     width=\"24px\">\n",
+              "    <g>\n",
+              "        <path d=\"M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zM9 17H7v-7h2v7zm4 0h-2V7h2v10zm4 0h-2v-4h2v4z\"/>\n",
+              "    </g>\n",
+              "</svg>\n",
+              "  </button>\n",
+              "\n",
+              "<style>\n",
+              "  .colab-df-quickchart {\n",
+              "      --bg-color: #E8F0FE;\n",
+              "      --fill-color: #1967D2;\n",
+              "      --hover-bg-color: #E2EBFA;\n",
+              "      --hover-fill-color: #174EA6;\n",
+              "      --disabled-fill-color: #AAA;\n",
+              "      --disabled-bg-color: #DDD;\n",
+              "  }\n",
+              "\n",
+              "  [theme=dark] .colab-df-quickchart {\n",
+              "      --bg-color: #3B4455;\n",
+              "      --fill-color: #D2E3FC;\n",
+              "      --hover-bg-color: #434B5C;\n",
+              "      --hover-fill-color: #FFFFFF;\n",
+              "      --disabled-bg-color: #3B4455;\n",
+              "      --disabled-fill-color: #666;\n",
+              "  }\n",
+              "\n",
+              "  .colab-df-quickchart {\n",
+              "    background-color: var(--bg-color);\n",
+              "    border: none;\n",
+              "    border-radius: 50%;\n",
+              "    cursor: pointer;\n",
+              "    display: none;\n",
+              "    fill: var(--fill-color);\n",
+              "    height: 32px;\n",
+              "    padding: 0;\n",
+              "    width: 32px;\n",
+              "  }\n",
+              "\n",
+              "  .colab-df-quickchart:hover {\n",
+              "    background-color: var(--hover-bg-color);\n",
+              "    box-shadow: 0 1px 2px rgba(60, 64, 67, 0.3), 0 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
+              "    fill: var(--button-hover-fill-color);\n",
+              "  }\n",
+              "\n",
+              "  .colab-df-quickchart-complete:disabled,\n",
+              "  .colab-df-quickchart-complete:disabled:hover {\n",
+              "    background-color: var(--disabled-bg-color);\n",
+              "    fill: var(--disabled-fill-color);\n",
+              "    box-shadow: none;\n",
+              "  }\n",
+              "\n",
+              "  .colab-df-spinner {\n",
+              "    border: 2px solid var(--fill-color);\n",
+              "    border-color: transparent;\n",
+              "    border-bottom-color: var(--fill-color);\n",
+              "    animation:\n",
+              "      spin 1s steps(1) infinite;\n",
+              "  }\n",
+              "\n",
+              "  @keyframes spin {\n",
+              "    0% {\n",
+              "      border-color: transparent;\n",
+              "      border-bottom-color: var(--fill-color);\n",
+              "      border-left-color: var(--fill-color);\n",
+              "    }\n",
+              "    20% {\n",
+              "      border-color: transparent;\n",
+              "      border-left-color: var(--fill-color);\n",
+              "      border-top-color: var(--fill-color);\n",
+              "    }\n",
+              "    30% {\n",
+              "      border-color: transparent;\n",
+              "      border-left-color: var(--fill-color);\n",
+              "      border-top-color: var(--fill-color);\n",
+              "      border-right-color: var(--fill-color);\n",
+              "    }\n",
+              "    40% {\n",
+              "      border-color: transparent;\n",
+              "      border-right-color: var(--fill-color);\n",
+              "      border-top-color: var(--fill-color);\n",
+              "    }\n",
+              "    60% {\n",
+              "      border-color: transparent;\n",
+              "      border-right-color: var(--fill-color);\n",
+              "    }\n",
+              "    80% {\n",
+              "      border-color: transparent;\n",
+              "      border-right-color: var(--fill-color);\n",
+              "      border-bottom-color: var(--fill-color);\n",
+              "    }\n",
+              "    90% {\n",
+              "      border-color: transparent;\n",
+              "      border-bottom-color: var(--fill-color);\n",
+              "    }\n",
+              "  }\n",
+              "</style>\n",
+              "\n",
+              "  <script>\n",
+              "    async function quickchart(key) {\n",
+              "      const quickchartButtonEl =\n",
+              "        document.querySelector('#' + key + ' button');\n",
+              "      quickchartButtonEl.disabled = true;  // To prevent multiple clicks.\n",
+              "      quickchartButtonEl.classList.add('colab-df-spinner');\n",
+              "      try {\n",
+              "        const charts = await google.colab.kernel.invokeFunction(\n",
+              "            'suggestCharts', [key], {});\n",
+              "      } catch (error) {\n",
+              "        console.error('Error during call to suggestCharts:', error);\n",
+              "      }\n",
+              "      quickchartButtonEl.classList.remove('colab-df-spinner');\n",
+              "      quickchartButtonEl.classList.add('colab-df-quickchart-complete');\n",
+              "    }\n",
+              "    (() => {\n",
+              "      let quickchartButtonEl =\n",
+              "        document.querySelector('#df-f7898f9d-fab8-47c9-8b19-821519e017fc button');\n",
+              "      quickchartButtonEl.style.display =\n",
+              "        google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
+              "    })();\n",
+              "  </script>\n",
+              "</div>\n",
+              "    </div>\n",
+              "  </div>\n"
+            ],
+            "application/vnd.google.colaboratory.intrinsic+json": {
+              "type": "dataframe",
+              "variable_name": "table",
+              "summary": "{\n  \"name\": \"table\",\n  \"rows\": 9,\n  \"fields\": [\n    {\n      \"column\": \"0\",\n      \"properties\": {\n        \"dtype\": \"string\",\n        \"num_unique_values\": 8,\n        \"samples\": [\n          \"Overall length\",\n          \"Front tread\",\n          \"Item\"\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"1\",\n      \"properties\": {\n        \"dtype\": \"category\",\n        \"num_unique_values\": 3,\n        \"samples\": [\n          \"\",\n          \"165/70 R14\",\n          \"175/65 R15\"\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"2\",\n      \"properties\": {\n        \"dtype\": \"string\",\n        \"num_unique_values\": 9,\n        \"samples\": [\n          \"1,492 (58.7)\",\n          \"3,815 (150.2)\",\n          \"1,475 (58.1)\"\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    }\n  ]\n}"
+            }
+          },
+          "metadata": {}
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "                  0              1\n",
+              "0                    Petrol Engine\n",
+              "1              Item        1.2 MPI\n",
+              "2  Displacement CC.          1,197\n",
+              "3  Bore X Stroke mm      71 X 75.6\n",
+              "4      Firing order        In-line\n",
+              "5  No. of cylinders              4"
+            ],
+            "text/html": [
+              "\n",
+              "  <div id=\"df-ddf0ef78-8b83-4cac-b724-fa6f047c07c5\" class=\"colab-df-container\">\n",
+              "    <div>\n",
+              "<style scoped>\n",
+              "    .dataframe tbody tr th:only-of-type {\n",
+              "        vertical-align: middle;\n",
+              "    }\n",
+              "\n",
+              "    .dataframe tbody tr th {\n",
+              "        vertical-align: top;\n",
+              "    }\n",
+              "\n",
+              "    .dataframe thead th {\n",
+              "        text-align: right;\n",
+              "    }\n",
+              "</style>\n",
+              "<table border=\"1\" class=\"dataframe\">\n",
+              "  <thead>\n",
+              "    <tr style=\"text-align: right;\">\n",
+              "      <th></th>\n",
+              "      <th>0</th>\n",
+              "      <th>1</th>\n",
+              "    </tr>\n",
+              "  </thead>\n",
+              "  <tbody>\n",
+              "    <tr>\n",
+              "      <th>0</th>\n",
+              "      <td></td>\n",
+              "      <td>Petrol Engine</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>1</th>\n",
+              "      <td>Item</td>\n",
+              "      <td>1.2 MPI</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>2</th>\n",
+              "      <td>Displacement CC.</td>\n",
+              "      <td>1,197</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>3</th>\n",
+              "      <td>Bore X Stroke mm</td>\n",
+              "      <td>71 X 75.6</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>4</th>\n",
+              "      <td>Firing order</td>\n",
+              "      <td>In-line</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>5</th>\n",
+              "      <td>No. of cylinders</td>\n",
+              "      <td>4</td>\n",
+              "    </tr>\n",
+              "  </tbody>\n",
+              "</table>\n",
+              "</div>\n",
+              "    <div class=\"colab-df-buttons\">\n",
+              "\n",
+              "  <div class=\"colab-df-container\">\n",
+              "    <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-ddf0ef78-8b83-4cac-b724-fa6f047c07c5')\"\n",
+              "            title=\"Convert this dataframe to an interactive table.\"\n",
+              "            style=\"display:none;\">\n",
+              "\n",
+              "  <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\" viewBox=\"0 -960 960 960\">\n",
+              "    <path d=\"M120-120v-720h720v720H120Zm60-500h600v-160H180v160Zm220 220h160v-160H400v160Zm0 220h160v-160H400v160ZM180-400h160v-160H180v160Zm440 0h160v-160H620v160ZM180-180h160v-160H180v160Zm440 0h160v-160H620v160Z\"/>\n",
+              "  </svg>\n",
+              "    </button>\n",
+              "\n",
+              "  <style>\n",
+              "    .colab-df-container {\n",
+              "      display:flex;\n",
+              "      gap: 12px;\n",
+              "    }\n",
+              "\n",
+              "    .colab-df-convert {\n",
+              "      background-color: #E8F0FE;\n",
+              "      border: none;\n",
+              "      border-radius: 50%;\n",
+              "      cursor: pointer;\n",
+              "      display: none;\n",
+              "      fill: #1967D2;\n",
+              "      height: 32px;\n",
+              "      padding: 0 0 0 0;\n",
+              "      width: 32px;\n",
+              "    }\n",
+              "\n",
+              "    .colab-df-convert:hover {\n",
+              "      background-color: #E2EBFA;\n",
+              "      box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
+              "      fill: #174EA6;\n",
+              "    }\n",
+              "\n",
+              "    .colab-df-buttons div {\n",
+              "      margin-bottom: 4px;\n",
+              "    }\n",
+              "\n",
+              "    [theme=dark] .colab-df-convert {\n",
+              "      background-color: #3B4455;\n",
+              "      fill: #D2E3FC;\n",
+              "    }\n",
+              "\n",
+              "    [theme=dark] .colab-df-convert:hover {\n",
+              "      background-color: #434B5C;\n",
+              "      box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n",
+              "      filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n",
+              "      fill: #FFFFFF;\n",
+              "    }\n",
+              "  </style>\n",
+              "\n",
+              "    <script>\n",
+              "      const buttonEl =\n",
+              "        document.querySelector('#df-ddf0ef78-8b83-4cac-b724-fa6f047c07c5 button.colab-df-convert');\n",
+              "      buttonEl.style.display =\n",
+              "        google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
+              "\n",
+              "      async function convertToInteractive(key) {\n",
+              "        const element = document.querySelector('#df-ddf0ef78-8b83-4cac-b724-fa6f047c07c5');\n",
+              "        const dataTable =\n",
+              "          await google.colab.kernel.invokeFunction('convertToInteractive',\n",
+              "                                                    [key], {});\n",
+              "        if (!dataTable) return;\n",
+              "\n",
+              "        const docLinkHtml = 'Like what you see? Visit the ' +\n",
+              "          '<a target=\"_blank\" href=https://colab.research.google.com/notebooks/data_table.ipynb>data table notebook</a>'\n",
+              "          + ' to learn more about interactive tables.';\n",
+              "        element.innerHTML = '';\n",
+              "        dataTable['output_type'] = 'display_data';\n",
+              "        await google.colab.output.renderOutput(dataTable, element);\n",
+              "        const docLink = document.createElement('div');\n",
+              "        docLink.innerHTML = docLinkHtml;\n",
+              "        element.appendChild(docLink);\n",
+              "      }\n",
+              "    </script>\n",
+              "  </div>\n",
+              "\n",
+              "\n",
+              "<div id=\"df-e975719d-acc1-450b-9089-7a4f0b14ca72\">\n",
+              "  <button class=\"colab-df-quickchart\" onclick=\"quickchart('df-e975719d-acc1-450b-9089-7a4f0b14ca72')\"\n",
+              "            title=\"Suggest charts\"\n",
+              "            style=\"display:none;\">\n",
+              "\n",
+              "<svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\"viewBox=\"0 0 24 24\"\n",
+              "     width=\"24px\">\n",
+              "    <g>\n",
+              "        <path d=\"M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zM9 17H7v-7h2v7zm4 0h-2V7h2v10zm4 0h-2v-4h2v4z\"/>\n",
+              "    </g>\n",
+              "</svg>\n",
+              "  </button>\n",
+              "\n",
+              "<style>\n",
+              "  .colab-df-quickchart {\n",
+              "      --bg-color: #E8F0FE;\n",
+              "      --fill-color: #1967D2;\n",
+              "      --hover-bg-color: #E2EBFA;\n",
+              "      --hover-fill-color: #174EA6;\n",
+              "      --disabled-fill-color: #AAA;\n",
+              "      --disabled-bg-color: #DDD;\n",
+              "  }\n",
+              "\n",
+              "  [theme=dark] .colab-df-quickchart {\n",
+              "      --bg-color: #3B4455;\n",
+              "      --fill-color: #D2E3FC;\n",
+              "      --hover-bg-color: #434B5C;\n",
+              "      --hover-fill-color: #FFFFFF;\n",
+              "      --disabled-bg-color: #3B4455;\n",
+              "      --disabled-fill-color: #666;\n",
+              "  }\n",
+              "\n",
+              "  .colab-df-quickchart {\n",
+              "    background-color: var(--bg-color);\n",
+              "    border: none;\n",
+              "    border-radius: 50%;\n",
+              "    cursor: pointer;\n",
+              "    display: none;\n",
+              "    fill: var(--fill-color);\n",
+              "    height: 32px;\n",
+              "    padding: 0;\n",
+              "    width: 32px;\n",
+              "  }\n",
+              "\n",
+              "  .colab-df-quickchart:hover {\n",
+              "    background-color: var(--hover-bg-color);\n",
+              "    box-shadow: 0 1px 2px rgba(60, 64, 67, 0.3), 0 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
+              "    fill: var(--button-hover-fill-color);\n",
+              "  }\n",
+              "\n",
+              "  .colab-df-quickchart-complete:disabled,\n",
+              "  .colab-df-quickchart-complete:disabled:hover {\n",
+              "    background-color: var(--disabled-bg-color);\n",
+              "    fill: var(--disabled-fill-color);\n",
+              "    box-shadow: none;\n",
+              "  }\n",
+              "\n",
+              "  .colab-df-spinner {\n",
+              "    border: 2px solid var(--fill-color);\n",
+              "    border-color: transparent;\n",
+              "    border-bottom-color: var(--fill-color);\n",
+              "    animation:\n",
+              "      spin 1s steps(1) infinite;\n",
+              "  }\n",
+              "\n",
+              "  @keyframes spin {\n",
+              "    0% {\n",
+              "      border-color: transparent;\n",
+              "      border-bottom-color: var(--fill-color);\n",
+              "      border-left-color: var(--fill-color);\n",
+              "    }\n",
+              "    20% {\n",
+              "      border-color: transparent;\n",
+              "      border-left-color: var(--fill-color);\n",
+              "      border-top-color: var(--fill-color);\n",
+              "    }\n",
+              "    30% {\n",
+              "      border-color: transparent;\n",
+              "      border-left-color: var(--fill-color);\n",
+              "      border-top-color: var(--fill-color);\n",
+              "      border-right-color: var(--fill-color);\n",
+              "    }\n",
+              "    40% {\n",
+              "      border-color: transparent;\n",
+              "      border-right-color: var(--fill-color);\n",
+              "      border-top-color: var(--fill-color);\n",
+              "    }\n",
+              "    60% {\n",
+              "      border-color: transparent;\n",
+              "      border-right-color: var(--fill-color);\n",
+              "    }\n",
+              "    80% {\n",
+              "      border-color: transparent;\n",
+              "      border-right-color: var(--fill-color);\n",
+              "      border-bottom-color: var(--fill-color);\n",
+              "    }\n",
+              "    90% {\n",
+              "      border-color: transparent;\n",
+              "      border-bottom-color: var(--fill-color);\n",
+              "    }\n",
+              "  }\n",
+              "</style>\n",
+              "\n",
+              "  <script>\n",
+              "    async function quickchart(key) {\n",
+              "      const quickchartButtonEl =\n",
+              "        document.querySelector('#' + key + ' button');\n",
+              "      quickchartButtonEl.disabled = true;  // To prevent multiple clicks.\n",
+              "      quickchartButtonEl.classList.add('colab-df-spinner');\n",
+              "      try {\n",
+              "        const charts = await google.colab.kernel.invokeFunction(\n",
+              "            'suggestCharts', [key], {});\n",
+              "      } catch (error) {\n",
+              "        console.error('Error during call to suggestCharts:', error);\n",
+              "      }\n",
+              "      quickchartButtonEl.classList.remove('colab-df-spinner');\n",
+              "      quickchartButtonEl.classList.add('colab-df-quickchart-complete');\n",
+              "    }\n",
+              "    (() => {\n",
+              "      let quickchartButtonEl =\n",
+              "        document.querySelector('#df-e975719d-acc1-450b-9089-7a4f0b14ca72 button');\n",
+              "      quickchartButtonEl.style.display =\n",
+              "        google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
+              "    })();\n",
+              "  </script>\n",
+              "</div>\n",
+              "    </div>\n",
+              "  </div>\n"
+            ],
+            "application/vnd.google.colaboratory.intrinsic+json": {
+              "type": "dataframe",
+              "variable_name": "table",
+              "summary": "{\n  \"name\": \"table\",\n  \"rows\": 6,\n  \"fields\": [\n    {\n      \"column\": \"0\",\n      \"properties\": {\n        \"dtype\": \"string\",\n        \"num_unique_values\": 6,\n        \"samples\": [\n          \"\",\n          \"Item\",\n          \"No. of cylinders\"\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"1\",\n      \"properties\": {\n        \"dtype\": \"string\",\n        \"num_unique_values\": 6,\n        \"samples\": [\n          \"Petrol Engine\",\n          \"1.2 MPI\",\n          \"4\"\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    }\n  ]\n}"
+            }
+          },
+          "metadata": {}
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "       0            1                      2   3                   4  \\\n",
+              "0  Group   Mass Group              Age Group  Fr  Rear Out- board Lh   \n",
+              "1      0  Up to 10 kg         Up to 9 months                       U   \n",
+              "2     0+  Up to 13 kg        Up to 24 months   X                   U   \n",
+              "3      I   9 to 18 kg  9 months to 48 months   X                   U   \n",
+              "4     II  15 to 25 kg   Approx. 3 to 7 Years   X                   U   \n",
+              "5    III  22 to 36 kg  Approx. 6 to 12 Years   X                   U   \n",
+              "\n",
+              "                    5            6  \n",
+              "0  Rear Out- board Rh  Rear Center  \n",
+              "1                   U            X  \n",
+              "2                   U            X  \n",
+              "3                   U            X  \n",
+              "4                   U            X  \n",
+              "5                   U            X  "
+            ],
+            "text/html": [
+              "\n",
+              "  <div id=\"df-caf18ecd-22fb-4065-aaf1-74cddeb0250b\" class=\"colab-df-container\">\n",
+              "    <div>\n",
+              "<style scoped>\n",
+              "    .dataframe tbody tr th:only-of-type {\n",
+              "        vertical-align: middle;\n",
+              "    }\n",
+              "\n",
+              "    .dataframe tbody tr th {\n",
+              "        vertical-align: top;\n",
+              "    }\n",
+              "\n",
+              "    .dataframe thead th {\n",
+              "        text-align: right;\n",
+              "    }\n",
+              "</style>\n",
+              "<table border=\"1\" class=\"dataframe\">\n",
+              "  <thead>\n",
+              "    <tr style=\"text-align: right;\">\n",
+              "      <th></th>\n",
+              "      <th>0</th>\n",
+              "      <th>1</th>\n",
+              "      <th>2</th>\n",
+              "      <th>3</th>\n",
+              "      <th>4</th>\n",
+              "      <th>5</th>\n",
+              "      <th>6</th>\n",
+              "    </tr>\n",
+              "  </thead>\n",
+              "  <tbody>\n",
+              "    <tr>\n",
+              "      <th>0</th>\n",
+              "      <td>Group</td>\n",
+              "      <td>Mass Group</td>\n",
+              "      <td>Age Group</td>\n",
+              "      <td>Fr</td>\n",
+              "      <td>Rear Out- board Lh</td>\n",
+              "      <td>Rear Out- board Rh</td>\n",
+              "      <td>Rear Center</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>1</th>\n",
+              "      <td>0</td>\n",
+              "      <td>Up to 10 kg</td>\n",
+              "      <td>Up to 9 months</td>\n",
+              "      <td></td>\n",
+              "      <td>U</td>\n",
+              "      <td>U</td>\n",
+              "      <td>X</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>2</th>\n",
+              "      <td>0+</td>\n",
+              "      <td>Up to 13 kg</td>\n",
+              "      <td>Up to 24 months</td>\n",
+              "      <td>X</td>\n",
+              "      <td>U</td>\n",
+              "      <td>U</td>\n",
+              "      <td>X</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>3</th>\n",
+              "      <td>I</td>\n",
+              "      <td>9 to 18 kg</td>\n",
+              "      <td>9 months to 48 months</td>\n",
+              "      <td>X</td>\n",
+              "      <td>U</td>\n",
+              "      <td>U</td>\n",
+              "      <td>X</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>4</th>\n",
+              "      <td>II</td>\n",
+              "      <td>15 to 25 kg</td>\n",
+              "      <td>Approx. 3 to 7 Years</td>\n",
+              "      <td>X</td>\n",
+              "      <td>U</td>\n",
+              "      <td>U</td>\n",
+              "      <td>X</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>5</th>\n",
+              "      <td>III</td>\n",
+              "      <td>22 to 36 kg</td>\n",
+              "      <td>Approx. 6 to 12 Years</td>\n",
+              "      <td>X</td>\n",
+              "      <td>U</td>\n",
+              "      <td>U</td>\n",
+              "      <td>X</td>\n",
+              "    </tr>\n",
+              "  </tbody>\n",
+              "</table>\n",
+              "</div>\n",
+              "    <div class=\"colab-df-buttons\">\n",
+              "\n",
+              "  <div class=\"colab-df-container\">\n",
+              "    <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-caf18ecd-22fb-4065-aaf1-74cddeb0250b')\"\n",
+              "            title=\"Convert this dataframe to an interactive table.\"\n",
+              "            style=\"display:none;\">\n",
+              "\n",
+              "  <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\" viewBox=\"0 -960 960 960\">\n",
+              "    <path d=\"M120-120v-720h720v720H120Zm60-500h600v-160H180v160Zm220 220h160v-160H400v160Zm0 220h160v-160H400v160ZM180-400h160v-160H180v160Zm440 0h160v-160H620v160ZM180-180h160v-160H180v160Zm440 0h160v-160H620v160Z\"/>\n",
+              "  </svg>\n",
+              "    </button>\n",
+              "\n",
+              "  <style>\n",
+              "    .colab-df-container {\n",
+              "      display:flex;\n",
+              "      gap: 12px;\n",
+              "    }\n",
+              "\n",
+              "    .colab-df-convert {\n",
+              "      background-color: #E8F0FE;\n",
+              "      border: none;\n",
+              "      border-radius: 50%;\n",
+              "      cursor: pointer;\n",
+              "      display: none;\n",
+              "      fill: #1967D2;\n",
+              "      height: 32px;\n",
+              "      padding: 0 0 0 0;\n",
+              "      width: 32px;\n",
+              "    }\n",
+              "\n",
+              "    .colab-df-convert:hover {\n",
+              "      background-color: #E2EBFA;\n",
+              "      box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
+              "      fill: #174EA6;\n",
+              "    }\n",
+              "\n",
+              "    .colab-df-buttons div {\n",
+              "      margin-bottom: 4px;\n",
+              "    }\n",
+              "\n",
+              "    [theme=dark] .colab-df-convert {\n",
+              "      background-color: #3B4455;\n",
+              "      fill: #D2E3FC;\n",
+              "    }\n",
+              "\n",
+              "    [theme=dark] .colab-df-convert:hover {\n",
+              "      background-color: #434B5C;\n",
+              "      box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n",
+              "      filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n",
+              "      fill: #FFFFFF;\n",
+              "    }\n",
+              "  </style>\n",
+              "\n",
+              "    <script>\n",
+              "      const buttonEl =\n",
+              "        document.querySelector('#df-caf18ecd-22fb-4065-aaf1-74cddeb0250b button.colab-df-convert');\n",
+              "      buttonEl.style.display =\n",
+              "        google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
+              "\n",
+              "      async function convertToInteractive(key) {\n",
+              "        const element = document.querySelector('#df-caf18ecd-22fb-4065-aaf1-74cddeb0250b');\n",
+              "        const dataTable =\n",
+              "          await google.colab.kernel.invokeFunction('convertToInteractive',\n",
+              "                                                    [key], {});\n",
+              "        if (!dataTable) return;\n",
+              "\n",
+              "        const docLinkHtml = 'Like what you see? Visit the ' +\n",
+              "          '<a target=\"_blank\" href=https://colab.research.google.com/notebooks/data_table.ipynb>data table notebook</a>'\n",
+              "          + ' to learn more about interactive tables.';\n",
+              "        element.innerHTML = '';\n",
+              "        dataTable['output_type'] = 'display_data';\n",
+              "        await google.colab.output.renderOutput(dataTable, element);\n",
+              "        const docLink = document.createElement('div');\n",
+              "        docLink.innerHTML = docLinkHtml;\n",
+              "        element.appendChild(docLink);\n",
+              "      }\n",
+              "    </script>\n",
+              "  </div>\n",
+              "\n",
+              "\n",
+              "<div id=\"df-23aaa94d-52a2-47de-a258-3021adcf9205\">\n",
+              "  <button class=\"colab-df-quickchart\" onclick=\"quickchart('df-23aaa94d-52a2-47de-a258-3021adcf9205')\"\n",
+              "            title=\"Suggest charts\"\n",
+              "            style=\"display:none;\">\n",
+              "\n",
+              "<svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\"viewBox=\"0 0 24 24\"\n",
+              "     width=\"24px\">\n",
+              "    <g>\n",
+              "        <path d=\"M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zM9 17H7v-7h2v7zm4 0h-2V7h2v10zm4 0h-2v-4h2v4z\"/>\n",
+              "    </g>\n",
+              "</svg>\n",
+              "  </button>\n",
+              "\n",
+              "<style>\n",
+              "  .colab-df-quickchart {\n",
+              "      --bg-color: #E8F0FE;\n",
+              "      --fill-color: #1967D2;\n",
+              "      --hover-bg-color: #E2EBFA;\n",
+              "      --hover-fill-color: #174EA6;\n",
+              "      --disabled-fill-color: #AAA;\n",
+              "      --disabled-bg-color: #DDD;\n",
+              "  }\n",
+              "\n",
+              "  [theme=dark] .colab-df-quickchart {\n",
+              "      --bg-color: #3B4455;\n",
+              "      --fill-color: #D2E3FC;\n",
+              "      --hover-bg-color: #434B5C;\n",
+              "      --hover-fill-color: #FFFFFF;\n",
+              "      --disabled-bg-color: #3B4455;\n",
+              "      --disabled-fill-color: #666;\n",
+              "  }\n",
+              "\n",
+              "  .colab-df-quickchart {\n",
+              "    background-color: var(--bg-color);\n",
+              "    border: none;\n",
+              "    border-radius: 50%;\n",
+              "    cursor: pointer;\n",
+              "    display: none;\n",
+              "    fill: var(--fill-color);\n",
+              "    height: 32px;\n",
+              "    padding: 0;\n",
+              "    width: 32px;\n",
+              "  }\n",
+              "\n",
+              "  .colab-df-quickchart:hover {\n",
+              "    background-color: var(--hover-bg-color);\n",
+              "    box-shadow: 0 1px 2px rgba(60, 64, 67, 0.3), 0 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
+              "    fill: var(--button-hover-fill-color);\n",
+              "  }\n",
+              "\n",
+              "  .colab-df-quickchart-complete:disabled,\n",
+              "  .colab-df-quickchart-complete:disabled:hover {\n",
+              "    background-color: var(--disabled-bg-color);\n",
+              "    fill: var(--disabled-fill-color);\n",
+              "    box-shadow: none;\n",
+              "  }\n",
+              "\n",
+              "  .colab-df-spinner {\n",
+              "    border: 2px solid var(--fill-color);\n",
+              "    border-color: transparent;\n",
+              "    border-bottom-color: var(--fill-color);\n",
+              "    animation:\n",
+              "      spin 1s steps(1) infinite;\n",
+              "  }\n",
+              "\n",
+              "  @keyframes spin {\n",
+              "    0% {\n",
+              "      border-color: transparent;\n",
+              "      border-bottom-color: var(--fill-color);\n",
+              "      border-left-color: var(--fill-color);\n",
+              "    }\n",
+              "    20% {\n",
+              "      border-color: transparent;\n",
+              "      border-left-color: var(--fill-color);\n",
+              "      border-top-color: var(--fill-color);\n",
+              "    }\n",
+              "    30% {\n",
+              "      border-color: transparent;\n",
+              "      border-left-color: var(--fill-color);\n",
+              "      border-top-color: var(--fill-color);\n",
+              "      border-right-color: var(--fill-color);\n",
+              "    }\n",
+              "    40% {\n",
+              "      border-color: transparent;\n",
+              "      border-right-color: var(--fill-color);\n",
+              "      border-top-color: var(--fill-color);\n",
+              "    }\n",
+              "    60% {\n",
+              "      border-color: transparent;\n",
+              "      border-right-color: var(--fill-color);\n",
+              "    }\n",
+              "    80% {\n",
+              "      border-color: transparent;\n",
+              "      border-right-color: var(--fill-color);\n",
+              "      border-bottom-color: var(--fill-color);\n",
+              "    }\n",
+              "    90% {\n",
+              "      border-color: transparent;\n",
+              "      border-bottom-color: var(--fill-color);\n",
+              "    }\n",
+              "  }\n",
+              "</style>\n",
+              "\n",
+              "  <script>\n",
+              "    async function quickchart(key) {\n",
+              "      const quickchartButtonEl =\n",
+              "        document.querySelector('#' + key + ' button');\n",
+              "      quickchartButtonEl.disabled = true;  // To prevent multiple clicks.\n",
+              "      quickchartButtonEl.classList.add('colab-df-spinner');\n",
+              "      try {\n",
+              "        const charts = await google.colab.kernel.invokeFunction(\n",
+              "            'suggestCharts', [key], {});\n",
+              "      } catch (error) {\n",
+              "        console.error('Error during call to suggestCharts:', error);\n",
+              "      }\n",
+              "      quickchartButtonEl.classList.remove('colab-df-spinner');\n",
+              "      quickchartButtonEl.classList.add('colab-df-quickchart-complete');\n",
+              "    }\n",
+              "    (() => {\n",
+              "      let quickchartButtonEl =\n",
+              "        document.querySelector('#df-23aaa94d-52a2-47de-a258-3021adcf9205 button');\n",
+              "      quickchartButtonEl.style.display =\n",
+              "        google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
+              "    })();\n",
+              "  </script>\n",
+              "</div>\n",
+              "    </div>\n",
+              "  </div>\n"
+            ],
+            "application/vnd.google.colaboratory.intrinsic+json": {
+              "type": "dataframe",
+              "variable_name": "table",
+              "summary": "{\n  \"name\": \"table\",\n  \"rows\": 6,\n  \"fields\": [\n    {\n      \"column\": \"0\",\n      \"properties\": {\n        \"dtype\": \"string\",\n        \"num_unique_values\": 6,\n        \"samples\": [\n          \"Group\",\n          \"0\",\n          \"III\"\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"1\",\n      \"properties\": {\n        \"dtype\": \"string\",\n        \"num_unique_values\": 6,\n        \"samples\": [\n          \"Mass Group\",\n          \"Up to 10 kg\",\n          \"22 to 36 kg\"\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"2\",\n      \"properties\": {\n        \"dtype\": \"string\",\n        \"num_unique_values\": 6,\n        \"samples\": [\n          \"Age Group\",\n          \"Up to 9 months\",\n          \"Approx. 6 to 12 Years\"\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"3\",\n      \"properties\": {\n        \"dtype\": \"string\",\n        \"num_unique_values\": 3,\n        \"samples\": [\n          \"Fr\",\n          \"\",\n          \"X\"\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"4\",\n      \"properties\": {\n        \"dtype\": \"category\",\n        \"num_unique_values\": 2,\n        \"samples\": [\n          \"U\",\n          \"Rear Out- board Lh\"\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"5\",\n      \"properties\": {\n        \"dtype\": \"category\",\n        \"num_unique_values\": 2,\n        \"samples\": [\n          \"U\",\n          \"Rear Out- board Rh\"\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"6\",\n      \"properties\": {\n        \"dtype\": \"category\",\n        \"num_unique_values\": 2,\n        \"samples\": [\n          \"X\",\n          \"Rear Center\"\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    }\n  ]\n}"
+            }
+          },
+          "metadata": {}
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "# **Vision**"
+      ],
+      "metadata": {
+        "id": "Yd3vxVWNRC1W"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "!pip install google-cloud-vision\n",
+        "!pip install pdf2image"
+      ],
+      "metadata": {
+        "id": "bSr0YgBva6BN"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "!sudo apt-get update\n",
+        "!apt-get install poppler-utils"
+      ],
+      "metadata": {
+        "id": "iXCgdvOYSgxL"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import io\n",
+        "import os\n",
+        "from google.cloud import vision\n",
+        "from google.cloud.vision_v1 import types\n",
+        "import numpy as np"
+      ],
+      "metadata": {
+        "id": "Cz9B6uC7OWqB"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import os\n",
+        "os.environ[\"GOOGLE_APPLICATION_CREDENTIALS\"] = \"/content/ai-drive-test-vision-ocr.json\""
+      ],
+      "metadata": {
+        "id": "WBOaOXdZOi3C"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "from pdf2image import convert_from_path\n",
+        "import base64\n",
+        "from io import BytesIO\n",
+        "from PIL import Image\n",
+        "from google.cloud import vision\n",
+        "\n",
+        "def pdf_to_images(pdf_path):\n",
+        "    images = convert_from_path(pdf_path)\n",
+        "    image_paths = []\n",
+        "    for i, image in enumerate(images):\n",
+        "        image_path = f\"/tmp/page_{i}.png\"\n",
+        "        image.save(image_path, \"PNG\")\n",
+        "        image_paths.append(image_path)\n",
+        "    return image_paths"
+      ],
+      "metadata": {
+        "id": "HcqDrIRyRk8x"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "def get_table_bounding_boxes(image_path):\n",
+        "    client = vision.ImageAnnotatorClient()\n",
+        "\n",
+        "    # Load the image file into memory\n",
+        "    with open(image_path, \"rb\") as image_file:\n",
+        "        content = image_file.read()\n",
+        "    image = vision.Image(content=content)\n",
+        "\n",
+        "    # Perform text detection on the image file\n",
+        "    response = client.document_text_detection(image=image)\n",
+        "\n",
+        "    bounding_boxes = []\n",
+        "    for page in response.full_text_annotation.pages:\n",
+        "        for block in page.blocks:\n",
+        "            print(block.block_type.name)\n",
+        "            for paragraph in block.paragraphs:\n",
+        "                for word in paragraph.words:\n",
+        "                    word_text = \"\".join([symbol.text for symbol in word.symbols])\n",
+        "                    print(word_text)\n",
+        "            if block.block_type.name == \"TABLE\":\n",
+        "                print(block.block_type.name)\n",
+        "                vertices = [[vertex.x, vertex.y] for vertex in block.bounding_box.vertices]\n",
+        "                bounding_boxes.append(vertices)\n",
+        "\n",
+        "    if response.error.message:\n",
+        "        raise Exception(f'{response.error.message}')\n",
+        "\n",
+        "    return bounding_boxes"
+      ],
+      "metadata": {
+        "id": "gNdXWM-_avGJ"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "def detect_documents_vision(pages):\n",
+        "    for pg in range(len(pages)):\n",
+        "        if pg>24 and pg<30:\n",
+        "          get_table_bounding_boxes(pages[pg])"
+      ],
+      "metadata": {
+        "id": "KDHL2uCWRdD_"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "pages = pdf_to_images(\"/content/hyundai_exter.pdf\")"
+      ],
+      "metadata": {
+        "id": "JGs9uAkPVxT9"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "detect_documents_vision(pages)"
+      ],
+      "metadata": {
+        "id": "2BhmUheESAZy"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "get_table_bounding_boxes(\"/content/table-3.png\")"
+      ],
+      "metadata": {
+        "id": "nFc1vAiwXIjf"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "!pip install google-cloud-documentai"
+      ],
+      "metadata": {
+        "id": "XYoCjsKLchTh"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import os\n",
+        "from google.cloud import documentai_v1 as documentai\n",
+        "from google.cloud.documentai_v1 import types\n",
+        "import io"
+      ],
+      "metadata": {
+        "id": "My81wvIPckau"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "def get_table_bounding_boxes(image_path, project_id, location, processor_id):\n",
+        "    \"\"\"Detects tables in an image and returns the bounding boxes.\n",
+        "\n",
+        "    Args:\n",
+        "    image_path (str): The path to the image file.\n",
+        "    project_id (str): Google Cloud project ID.\n",
+        "    location (str): Google Cloud location.\n",
+        "    processor_id (str): Document AI processor ID.\n",
+        "\n",
+        "    Returns:\n",
+        "    list of lists: Bounding boxes of tables, each bounding box is represented as a list of four vertices.\n",
+        "    \"\"\"\n",
+        "    client = documentai.DocumentProcessorServiceClient()\n",
+        "\n",
+        "    # The full resource name of the processor\n",
+        "    name = f'projects/{project_id}/locations/{location}/processors/{processor_id}'\n",
+        "\n",
+        "    # Read the image file\n",
+        "    with io.open(image_path, 'rb') as image_file:\n",
+        "        image_content = image_file.read()\n",
+        "\n",
+        "    # Load the image content into a document\n",
+        "    raw_document = types.RawDocument(content=image_content, mime_type='image/jpeg')\n",
+        "\n",
+        "    # Configure the process request\n",
+        "    request = types.ProcessRequest(name=name, raw_document=raw_document)\n",
+        "\n",
+        "    # Process the document\n",
+        "    result = client.process_document(request=request)\n",
+        "\n",
+        "    document = result.document\n",
+        "\n",
+        "    # Extract bounding boxes for tables\n",
+        "    bounding_boxes = []\n",
+        "    for page in document.pages:\n",
+        "        for table in page.tables:\n",
+        "            vertices = [[vertex.x, vertex.y] for vertex in table.layout.bounding_poly.vertices]\n",
+        "            bounding_boxes.append(vertices)\n",
+        "\n",
+        "    return bounding_boxes"
+      ],
+      "metadata": {
+        "id": "GksVH-hRbP6B"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# Example usage:\n",
+        "# Set these variables to your specific values\n",
+        "project_id = 'rock-fortress-423520-h1'\n",
+        "location = 'us'\n",
+        "processor_id = '69643c68165167c1'\n",
+        "\n",
+        "print(get_table_bounding_boxes(\"/content/table-1.png\", project_id, location, processor_id))"
+      ],
+      "metadata": {
+        "id": "W6KIETuBcpfM"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "# **Florence**-2-large"
+      ],
+      "metadata": {
+        "id": "tedrUKKhBH-6"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "!pip install einops flash_attn timm"
+      ],
+      "metadata": {
+        "id": "B4noKtMMBpaD"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import fitz\n",
+        "import requests\n",
+        "from PIL import Image\n",
+        "from transformers import AutoProcessor, AutoModelForCausalLM"
+      ],
+      "metadata": {
+        "id": "ve5DeQuwBPbg"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "model = AutoModelForCausalLM.from_pretrained(\"microsoft/Florence-2-large\", trust_remote_code=True)\n",
+        "processor = AutoProcessor.from_pretrained(\"microsoft/Florence-2-large\", trust_remote_code=True)"
+      ],
+      "metadata": {
+        "id": "MaXP9YRMBhXl"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "model = AutoModelForCausalLM.from_pretrained(\"microsoft/Florence-2-base\", trust_remote_code=True)\n",
+        "processor = AutoProcessor.from_pretrained(\"microsoft/Florence-2-base\", trust_remote_code=True)"
+      ],
+      "metadata": {
+        "id": "1rcc-e5AGn_n"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "prompt = \"Extract bounding boxes of all the tables present in this page\""
+      ],
+      "metadata": {
+        "id": "xwgEmKdvBknf"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "def extract_text_florence(pdf_path):\n",
+        "    images = convert_from_path(pdf_path)\n",
+        "    extracted_text = \"\"\n",
+        "    # for image in images:\n",
+        "    image = images[0]\n",
+        "    inputs = processor(text=prompt, images=image, return_tensors=\"pt\")\n",
+        "\n",
+        "    generated_ids = model.generate(\n",
+        "        input_ids=inputs[\"input_ids\"],\n",
+        "        pixel_values=inputs[\"pixel_values\"],\n",
+        "        max_new_tokens=1024,\n",
+        "        num_beams=3,\n",
+        "        do_sample=False\n",
+        "    )\n",
+        "    generated_text = processor.batch_decode(generated_ids, skip_special_tokens=False)[0]\n",
+        "\n",
+        "    parsed_answer = processor.post_process_generation(generated_text, task=\"<OD>\", image_size=(image.width, image.height))\n",
+        "\n",
+        "    print(parsed_answer)\n"
+      ],
+      "metadata": {
+        "id": "bB-majwGBHAd"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "extract_text_florence(\"/content/table-data.pdf\")"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "Mch5i9PfDpu1",
+        "outputId": "d31acc29-d91e-4e1f-9d5e-dc9b3730e0d8"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "{'<OD>': {'bboxes': [[123.38600158691406, 222.95001220703125, 1156.986083984375, 1152.9700927734375], [0.6460000276565552, 0.9100000262260437, 1290.06201171875, 1817.27001953125]], 'labels': ['bounding boxes of all the tables present', 'this page']}}\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "# **Marker**"
+      ],
+      "metadata": {
+        "id": "cRHuvf0kKUr7"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "!pip install marker-pdf"
+      ],
+      "metadata": {
+        "id": "pIQGdq7eKXyf"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "!pip install poetry"
+      ],
+      "metadata": {
+        "id": "tctaIQpmKlSZ"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "!git clone https://github.com/VikParuchuri/marker.git"
+      ],
+      "metadata": {
+        "id": "oMXfhQVYLHFA"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "%cd /content/marker\n",
+        "!poetry install"
+      ],
+      "metadata": {
+        "id": "nAvKUsyULDym"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "!marker_single /content/hyundai_exter-25.pdf /content --max_pages 10 --langs English"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "sgk_Wk8yL6U0",
+        "outputId": "f72a374c-7677-4bad-c86f-e90e8a83f9e6"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "2024-06-07 19:39:52.061416: E external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:9261] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n",
+            "2024-06-07 19:39:52.061488: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:607] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n",
+            "2024-06-07 19:39:52.180601: E external/local_xla/xla/stream_executor/cuda/cuda_blas.cc:1515] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n",
+            "2024-06-07 19:39:52.398901: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n",
+            "To enable the following instructions: AVX2 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n",
+            "2024-06-07 19:39:54.989202: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n",
+            "Loaded detection model vikp/surya_det2 on device cpu with dtype torch.float32\n",
+            "Loaded detection model vikp/surya_layout2 on device cpu with dtype torch.float32\n",
+            "Loaded reading order model vikp/surya_order on device cpu with dtype torch.float32\n",
+            "Loaded recognition model vikp/surya_rec on device cpu with dtype torch.float32\n",
+            "Loaded texify model to cpu with torch.float32 dtype\n",
+            "Detecting bboxes: 100% 1/1 [00:32<00:00, 32.02s/it]\n",
+            "Detecting bboxes: 100% 1/1 [00:32<00:00, 32.56s/it]\n",
+            "Finding reading order: 100% 1/1 [00:16<00:00, 16.46s/it]\n",
+            "Saved markdown to the /content/hyundai_exter-25 folder\n"
+          ]
+        }
+      ]
+    }
+  ]
+}
\ No newline at end of file