Titan_pdf_images.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "machine_shape": "hm",
      "gpuType": "V100",
      "authorship_tag": "ABX9TyOnoQbU6S55/T1YcVuegdXf"
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "OYnddsxBwBXL"
      },
      "outputs": [],
      "source": [
        "pip install boto3 farm-haystack pyPDF2 pymuPDF easyocr faiss-gpu"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import boto3\n",
        "import json\n",
        "import base64\n",
        "\n",
        "bedrock = boto3.client('bedrock-runtime')"
      ],
      "metadata": {
        "id": "yXz6pzQ7wFGz"
      },
      "execution_count": 2,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "MULTIMODAL EMBEDDINGS\n",
        "\n",
        "IMAGE TO EMBED ->"
      ],
      "metadata": {
        "id": "HpJXSl96z08R"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "![camaro.jfif](data:image/jpeg;base64,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)"
      ],
      "metadata": {
        "id": "d8nBcLJWC-yR"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# read in image and create embeddings for image and caption\n",
        "with open(\"/content/sample_data/camaro.jfif\", \"rb\") as image_file:\n",
        "    input_image = base64.b64encode(image_file.read()).decode('utf8')\n",
        "\n",
        "\n",
        "body = json.dumps(\n",
        "    {\n",
        "        \"inputText\": \"gray camaro\",\n",
        "        \"inputImage\": input_image\n",
        "    }\n",
        ")"
      ],
      "metadata": {
        "id": "MMJnrNfzw5ky"
      },
      "execution_count": 3,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "response = bedrock.invoke_model(\n",
        "\tbody=body,\n",
        "\tmodelId=\"amazon.titan-embed-image-v1\",\n",
        "\taccept=\"application/json\",\n",
        "\tcontentType=\"application/json\"\n",
        ")"
      ],
      "metadata": {
        "id": "2yx_RHmUxfmw"
      },
      "execution_count": 4,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "response_body = json.loads(response.get(\"body\").read())\n",
        "car_embedding = response_body.get(\"embedding\")\n",
        "car_embedding[:2]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "k83gquKtxjAk",
        "outputId": "783414e5-f73c-4eb2-ad54-c0a6bf2bfd21"
      },
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[-0.0022371383, 0.033632398]"
            ]
          },
          "metadata": {},
          "execution_count": 5
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Vector embedding of similar caption\n",
        "def embed(text):\n",
        "  body = json.dumps(\n",
        "      {\n",
        "          \"inputText\": text,\n",
        "      }\n",
        "  )\n",
        "  response = bedrock.invoke_model(\n",
        "\tbody=body,\n",
        "\tmodelId=\"amazon.titan-embed-image-v1\",\n",
        "\taccept=\"application/json\",\n",
        "\tcontentType=\"application/json\"\n",
        "  )\n",
        "  response_body = json.loads(response.get(\"body\").read())\n",
        "  text_embedding = response_body.get(\"embedding\")\n",
        "  return text_embedding"
      ],
      "metadata": {
        "id": "NcmXKfwRypr0"
      },
      "execution_count": 7,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "text = 'car with stripes'\n",
        "text_embedding = embed(text)\n",
        "text_embedding[:2]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_y37LL4RWLA-",
        "outputId": "761fb1bf-464a-460a-f718-d4eee905681c"
      },
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[0.040283203, -0.0007209778]"
            ]
          },
          "metadata": {},
          "execution_count": 8
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Calculate cosine similarity with caption\n",
        "import numpy as np\n",
        "\n",
        "dot_product = np.dot(np.array(car_embedding), np.array(text_embedding))\n",
        "norm_vector1 = np.linalg.norm(car_embedding)\n",
        "norm_vector2 = np.linalg.norm(text_embedding)\n",
        "cosine_similarity_value = dot_product / (norm_vector1 * norm_vector2)\n",
        "print(f'Cosine similarity is {cosine_similarity_value}')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "cQ0Id00jy_mA",
        "outputId": "70da7a21-c167-4bbd-fc65-e6ca7183a4fb"
      },
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Cosine similarity is 0.5786531198621794\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "with open(\"/content/sample_data/camaro.jfif\", \"rb\") as image_file:\n",
        "    input_image = base64.b64encode(image_file.read()).decode('utf8')\n",
        "\n",
        "\n",
        "body = json.dumps(\n",
        "    {\n",
        "        \"inputImage\": input_image\n",
        "    }\n",
        ")\n",
        "response = bedrock.invoke_model(\n",
        "\tbody=body,\n",
        "\tmodelId=\"amazon.titan-embed-image-v1\",\n",
        "\taccept=\"application/json\",\n",
        "\tcontentType=\"application/json\"\n",
        ")\n",
        "response_body = json.loads(response.get(\"body\").read())\n",
        "car_embedding = response_body.get(\"embedding\")\n",
        "car_embedding[:2]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "nwBOiMkWWe6L",
        "outputId": "e9d6edd3-1586-4181-bd81-f0458052ea25"
      },
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[0.0015071685, 0.045170065]"
            ]
          },
          "metadata": {},
          "execution_count": 10
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Calculate cosine similarity without caption\n",
        "import numpy as np\n",
        "\n",
        "dot_product = np.dot(np.array(car_embedding), np.array(text_embedding))\n",
        "norm_vector1 = np.linalg.norm(car_embedding)\n",
        "norm_vector2 = np.linalg.norm(text_embedding)\n",
        "cosine_similarity_value = dot_product / (norm_vector1 * norm_vector2)\n",
        "print(f'Cosine similarity is {cosine_similarity_value}')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ZyqZGOuQWsVf",
        "outputId": "b6d4e148-fdfb-42e6-cde0-2262b1cb6797"
      },
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Cosine similarity is 0.39729774544583\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "np.array(car_embedding).shape"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QEt9WNIs2Cuh",
        "outputId": "400e9319-aeab-48f3-859c-d9613dbf2d54"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(1024,)"
            ]
          },
          "metadata": {},
          "execution_count": 125
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Misses content embedded in photos within the PDF\n",
        "import PyPDF2\n",
        "\n",
        "def extract_text(pdf_path):\n",
        "    with open(pdf_path, 'rb') as file:\n",
        "        pdf_reader = PyPDF2.PdfReader(file)\n",
        "        text = ''\n",
        "        for page_num in range(len(pdf_reader.pages)):\n",
        "            text += pdf_reader.pages[page_num].extract_text()\n",
        "    return text\n",
        "\n",
        "# Skips page 7\n",
        "pdf_text = extract_text('/content/sample_data/aws-ml.pdf').strip().replace('\\n\\n', '')\n",
        "print(pdf_text)\n"
      ],
      "metadata": {
        "id": "UP2zAXRIsUBl"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import fitz  # PyMuPDF-Fitz\n",
        "from haystack.schema import Document\n",
        "import easyocr\n",
        "import base64\n",
        "\n",
        "docs = []\n",
        "reader = easyocr.Reader(['en'], gpu=True) # this needs to run only once to load the model into memory\n",
        "\n",
        "def extract_text_and_images_from_pdf(pdf_path, output_folder):\n",
        "    # Open the PDF document\n",
        "    pdf_document = fitz.open(pdf_path)\n",
        "    img_bytes = None\n",
        "    for page_num in range(pdf_document.page_count):\n",
        "        # Extract text\n",
        "        page = pdf_document[page_num]\n",
        "        text = page.get_text(\"text\")\n",
        "\n",
        "        # Extract images\n",
        "        img_bytes = []\n",
        "        images = page.get_images(full=True)\n",
        "        if len(images) > 0:\n",
        "          img_bytes = []\n",
        "          for img_index, img_info in enumerate(images):\n",
        "              image_index = img_info[0]\n",
        "              base_image = pdf_document.extract_image(image_index)\n",
        "              image_bytes = base_image[\"image\"]\n",
        "              image_path = f\"test.png\"\n",
        "              with open(image_path, 'wb') as image_file:\n",
        "                  image_file.write(image_bytes)\n",
        "\n",
        "              result = reader.readtext('test.png', detail=0)\n",
        "              result = ' '.join(result)\n",
        "              text += f'\\n {result}'\n",
        "              img_bytes.append(base64.b64encode(image_bytes).decode('utf-8'))\n",
        "\n",
        "        docs.append(Document(content=text, embedding=embed(text), meta={\"document_name\":pdf_path, \"page\":page_num+1, \"img_bytes\":img_bytes}))\n",
        "        if len(docs) > 5:\n",
        "            break\n",
        "    pdf_document.close()\n",
        "\n",
        "    return docs\n",
        "\n",
        "\n",
        "docs = extract_text_and_images_from_pdf('/content/sample_data/aws-ml.pdf', '/content/sample_data/')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zfpfgjCasfoD",
        "outputId": "09db0dbe-1f40-4b14-a398-107fd6151789"
      },
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "WARNING:easyocr.easyocr:Downloading detection model, please wait. This may take several minutes depending upon your network connection.\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Progress: |██████████████████████████████████████████████████| 100.0% Complete"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "WARNING:easyocr.easyocr:Downloading recognition model, please wait. This may take several minutes depending upon your network connection.\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Progress: |██████████████████████████████████████████████████| 100.0% Complete"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.10/dist-packages/torch/_utils.py:831: UserWarning: TypedStorage is deprecated. It will be removed in the future and UntypedStorage will be the only storage class. This should only matter to you if you are using storages directly.  To access UntypedStorage directly, use tensor.untyped_storage() instead of tensor.storage()\n",
            "  return self.fget.__get__(instance, owner)()\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from pprint import pprint\n",
        "pprint(docs)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XwgWmP2UCTdV",
        "outputId": "457c1e75-4728-4f1a-e838-517df10e23c4"
      },
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[<Document: {'content': 'AWS Machine Learning Specialty \\nCheat Sheet \\nFabrice Guillaume - Nov 2020 ...]"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from haystack.document_stores import FAISSDocumentStore\n",
        "import faiss\n",
        "docstore = FAISSDocumentStore(embedding_dim=1024, faiss_index_factory_str=\"Flat\")\n",
        "docstore.write_documents(docs)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "I3INsE0t9HOD",
        "outputId": "b287b546-b1d7-40ac-8cd1-86cb4c8a3de4"
      },
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Writing Documents: 10000it [00:00, 281659.48it/s]       \n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "text = 'how do i address underfitting and overfitting?'\n",
        "emb = embed(text)\n",
        "context = docstore.query_by_embedding(np.array(emb), top_k=2)\n",
        "pprint(context)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ehhee1z_Xa--",
        "outputId": "60bd16b0-889f-47fd-bede-dc51b15cb2a5"
      },
      "execution_count": 20,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[<Document: {'content': 'Addressing UnderFitting and OverFitting \\nhttps://docs.aws.amazon.com/machine-learning/latest/dg/model-fit-...]"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from PIL import Image\n",
        "from IPython.display import display, Image as IPImage\n",
        "import io\n",
        "\n",
        "img_bytes = context[0].meta['img_bytes'][0]\n",
        "# print(img_bytes)\n",
        "# image_base64 = base64.b64encode(img_bytes).decode('utf-8')\n",
        "image_data = base64.b64decode(img_bytes)\n",
        "# Now 'image_base64' contains the base64-encoded string\n",
        "image_path = f\"testingggg.png\"\n",
        "with open(image_path, 'wb') as image_file:\n",
        "    image_file.write(image_data)\n",
        "display(IPImage(filename=image_path))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 185
        },
        "id": "qUdazxVY7Z3Q",
        "outputId": "418bce4f-21f4-4f2d-9a94-aa88045dc819"
      },
      "execution_count": 21,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<IPython.core.display.Image object>"
            ]
          },
          "metadata": {}
        }
      ]
    }
  ]
}