Generative AI on AWS with AWS Bedrock.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "authorship_tag": "ABX9TyOq/kmmM5xy6EREZOBBR0FI"
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "code",
      "source": [
        "!pip install boto3"
      ],
      "metadata": {
        "id": "psc2bhoOjr7b"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Getting Started with BedRock**\n",
        "\n"
      ],
      "metadata": {
        "id": "Zdv2Q3ERWgr6"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import json\n",
        "import boto3\n",
        "client=boto3.client('bedrock-runtime',region_name='us-east-1',aws_access_key_id='',aws_secret_access_key='')\n",
        "inputText=input(\"Enter the question for Gen AI : \")\n",
        "body_part=json.dumps({'inputText': inputText,\n",
        " 'textGenerationConfig': {'maxTokenCount': 8192,\n",
        "  'stopSequences': [],\n",
        "  'temperature': 0,\n",
        "  'topP': 1}})\n",
        "response = client.invoke_model(\n",
        "    body=body_part,\n",
        "    contentType=\"application/json\",\n",
        "    accept=\"application/json\",\n",
        "    modelId='amazon.titan-text-express-v1'\n",
        ")\n",
        "output_text=json.loads(response['body'].read())['results'][0]['outputText']\n",
        "output_text[output_text.index('\\n')+1:]"
      ],
      "metadata": {
        "id": "77ZU4uFvjV1-"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Text Embedding with BedRock**"
      ],
      "metadata": {
        "id": "xF_U_TnOW9RH"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import json\n",
        "import boto3\n",
        "client=boto3.client('bedrock-runtime',region_name='us-east-1',aws_access_key_id='',aws_secret_access_key='')\n",
        "inputText=input(\"Enter the word/sentence for embedding : \")\n",
        "body_part=json.dumps({'inputText': inputText})\n",
        "response = client.invoke_model(\n",
        "    body=body_part,\n",
        "    contentType=\"application/json\",\n",
        "    accept=\"application/json\",\n",
        "    modelId='amazon.titan-embed-text-v1'\n",
        ")\n",
        "json.loads(response['body'].read())['embedding']"
      ],
      "metadata": {
        "id": "BNuEgCDbbfWh"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Cosine Similarity**"
      ],
      "metadata": {
        "id": "qf_HQb8vXCG8"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import json\n",
        "import boto3\n",
        "import math\n",
        "client=boto3.client('bedrock-runtime',region_name='us-east-1',aws_access_key_id='',aws_secret_access_key='')\n",
        "\n",
        "def get_embedding(b):\n",
        "  body_part=json.dumps({\n",
        " 'inputText':b\n",
        "})\n",
        "  response=client.invoke_model(\n",
        "  body=body_part,\n",
        "  contentType=\"application/json\",\n",
        "  accept=\"application/json\",\n",
        "  modelId='amazon.titan-embed-text-v1'\n",
        "  )\n",
        "  return json.loads(response['body'].read())['embedding']\n",
        "\n",
        "def cosine_similarity(v1,v2):\n",
        "    \"compute cosine similarity of v1 to v2: (v1 dot v2)/{||v1||*||v2||)\"\n",
        "    sumxx, sumxy, sumyy = 0, 0, 0\n",
        "    for i in range(len(v1)):\n",
        "        x = v1[i]; y = v2[i]\n",
        "        sumxx += x*x\n",
        "        sumyy += y*y\n",
        "        sumxy += x*y\n",
        "    return sumxy/(math.sqrt(sumxx)*math.sqrt(sumyy))\n",
        "\n",
        "text1 = \"This bottle is empty\"\n",
        "text2 = \"There is nothing in the bottle\"\n",
        "v1=get_embedding(text1)\n",
        "v2=get_embedding(text2)\n",
        "\n",
        "print(v1)\n",
        "print(v2)\n",
        "\n",
        "print(cosine_similarity(v1,v2))\n"
      ],
      "metadata": {
        "id": "UYBXwdyZbfUf"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **GenAI application development with Pinecone Vector Database**"
      ],
      "metadata": {
        "id": "4OKqgwesXFmX"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "!pip install pinecone-client boto3"
      ],
      "metadata": {
        "id": "XSVulF0ObfSS"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "from pinecone import Pinecone\n",
        "\n",
        "pc = Pinecone(api_key=\"\")\n",
        "index = pc.Index(\"demoytsimilaritysearch\")"
      ],
      "metadata": {
        "id": "n8G5n3gIbfNK"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "data_to_store=[\"Mango\",\"JackFruit\",\"Banana\",\"Red\",\"Green\",\"Blue\" ,\"Pen\",\"Pensil\",\"Scale\"]\n",
        "\n",
        "import json\n",
        "import boto3\n",
        "import math\n",
        "client=boto3.client('bedrock-runtime',region_name='us-east-1',aws_access_key_id='',aws_secret_access_key='')\n",
        "\n",
        "def get_embedding(b):\n",
        "  body_part=json.dumps({\n",
        " 'inputText':b\n",
        "})\n",
        "  response=client.invoke_model(\n",
        "  body=body_part,\n",
        "  contentType=\"application/json\",\n",
        "  accept=\"application/json\",\n",
        "  modelId='amazon.titan-embed-text-v1'\n",
        "  )\n",
        "  return json.loads(response['body'].read())['embedding']\n",
        "\n",
        "\n",
        "vectors=[]\n",
        "for i in data_to_store:\n",
        "  vectors.append({\n",
        "            \"id\":i,\n",
        "            \"values\": get_embedding(i)\n",
        "        })\n",
        "\n",
        "index.upsert(\n",
        "    vectors=vectors,\n",
        "    namespace= \"ns1\"\n",
        ")"
      ],
      "metadata": {
        "id": "NsJiBG30bfJ1"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "index.query(\n",
        "    namespace=\"ns1\",\n",
        "    vector= get_embedding(\"Ruler\") ,\n",
        "    top_k=2\n",
        ")"
      ],
      "metadata": {
        "id": "NOCQm4ZWbfGF"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Multimodal Embeddings with BedRock**"
      ],
      "metadata": {
        "id": "qvsWs_6aXMi1"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# [**Image Dataset**](https://github.com/SatadruMukherjee/Data-Preprocessing-Models/blob/main/Multimodal%20Embedding%20using%20BedRock.zip)"
      ],
      "metadata": {
        "id": "6qXiLpIyXbfY"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "!pip install boto3 pinecone-client"
      ],
      "metadata": {
        "id": "BtKRbVdAbfDb"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#Reference Document: https://aws.amazon.com/blogs/aws/amazon-titan-image-generator-multimodal-embeddings-and-text-models-are-now-available-in-amazon-bedrock/\n",
        "import json\n",
        "import boto3\n",
        "import base64\n",
        "\n",
        "bedrock_runtime=boto3.client('bedrock-runtime',region_name='us-east-1',aws_access_key_id='',aws_secret_access_key='')\n",
        "\n",
        "from pinecone import Pinecone\n",
        "\n",
        "pc = Pinecone(api_key=\"{}\")\n",
        "index = pc.Index(\"imagesearchytdemo\")\n",
        "\n",
        "\n",
        "def image_embedding(image_name):\n",
        "  # Maximum image size supported is 2048 x 2048 pixels\n",
        "  with open(image_name, \"rb\") as image_file:\n",
        "    input_image = base64.b64encode(image_file.read()).decode('utf8')\n",
        "\n",
        "  # You can specify either text or image or both\n",
        "  body = json.dumps(\n",
        "    {\n",
        "        \"inputImage\": input_image\n",
        "    }\n",
        "  )\n",
        "  response = bedrock_runtime.invoke_model(\n",
        "  body=body,\n",
        "  modelId=\"amazon.titan-embed-image-v1\",\n",
        "  accept=\"application/json\",\n",
        "  contentType=\"application/json\"\n",
        "  )\n",
        "  response_body = json.loads(response.get(\"body\").read())\n",
        "  return response_body.get(\"embedding\")\n",
        "\n",
        "data_to_store=[\"1.png\", \"2.png\", \"3.png\", \"4.png\", \"5.png\", \"6.png\", \"7.png\"]\n",
        "\n",
        "vectors=[]\n",
        "for i in data_to_store:\n",
        "  vectors.append({\n",
        "            \"id\":i,\n",
        "            \"values\": image_embedding(i)\n",
        "        })\n",
        "\n",
        "index.upsert(\n",
        "    vectors=vectors,\n",
        "    namespace= \"ns1\"\n",
        ")"
      ],
      "metadata": {
        "id": "w4u9NN3jbfBM"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "index.query(\n",
        "    namespace=\"ns1\",\n",
        "    vector=image_embedding('/content/red_bag_testing.PNG'),\n",
        "    top_k=2\n",
        ")"
      ],
      "metadata": {
        "id": "e-egnMUobe-v"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def text_multimodal_embedding(text):\n",
        "\n",
        "  # You can specify either text or image or both\n",
        "  body = json.dumps(\n",
        "    {\n",
        "        \"inputText\": text\n",
        "    }\n",
        "  )\n",
        "  response = bedrock_runtime.invoke_model(\n",
        "  body=body,\n",
        "  modelId=\"amazon.titan-embed-image-v1\",\n",
        "  accept=\"application/json\",\n",
        "  contentType=\"application/json\"\n",
        "  )\n",
        "  response_body = json.loads(response.get(\"body\").read())\n",
        "  return response_body.get(\"embedding\")\n",
        "\n",
        "index.query(\n",
        "    namespace=\"ns1\",\n",
        "    vector=text_multimodal_embedding('Pink Bag'),\n",
        "    top_k=2\n",
        ")"
      ],
      "metadata": {
        "id": "XuacGFDEbe8l"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **RAG**"
      ],
      "metadata": {
        "id": "rnwE4vWv8Q11"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "!pip install boto3 langchain langchain-pinecone"
      ],
      "metadata": {
        "id": "rrc1o_TRHYlc"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Reference Links:\n",
        "\n",
        "\n",
        "https://github.com/aws-samples/amazon-bedrock-samples/blob/main/rag-solutions/rag-foundations-workshop/notebooks/03_retrieval_based_text_application.ipynb\n",
        "\n",
        "https://python.langchain.com/docs/integrations/vectorstores/pinecone/"
      ],
      "metadata": {
        "id": "DY3JavuWe1av"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import boto3\n",
        "import os\n",
        "\n",
        "\n",
        "boto3_bedrock = boto3.client('bedrock-runtime',region_name='us-east-1',aws_access_key_id='',aws_secret_access_key='')\n"
      ],
      "metadata": {
        "id": "pbdJMAcE8TEG"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "from langchain.docstore.document import Document\n",
        "from langchain.document_loaders import TextLoader\n",
        "from langchain.embeddings import BedrockEmbeddings\n",
        "from langchain.text_splitter import CharacterTextSplitter"
      ],
      "metadata": {
        "id": "qAZs_ljaHW1H"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# load the sagemaker FAQ list\n",
        "with open('/content/yt_ran_dem.txt') as f:\n",
        "    doc = f.read()\n",
        "\n",
        "# create a loader\n",
        "docs = []\n",
        "loader = TextLoader('')\n",
        "docs.append(Document(page_content=doc))\n",
        "\n",
        "# split documents into chunks\n",
        "text_splitter = CharacterTextSplitter(\n",
        "    separator='\\n',\n",
        "    chunk_size=300,\n",
        "    chunk_overlap=25,\n",
        "\n",
        ")\n",
        "split_docs = text_splitter.split_documents(docs)"
      ],
      "metadata": {
        "id": "Av6GXm-dHrbB"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "split_docs"
      ],
      "metadata": {
        "id": "CrFOkCroH-Xx"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import os\n",
        "os.environ['PINECONE_API_KEY']='{}'"
      ],
      "metadata": {
        "id": "NpKkmyGFJMnc"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "embedding_model = BedrockEmbeddings(\n",
        "    client=boto3_bedrock,\n",
        "    model_id=\"amazon.titan-embed-text-v1\"\n",
        ")\n",
        "from langchain_pinecone import PineconeVectorStore\n",
        "\n",
        "index_name = \"demoytrag\"\n",
        "\n",
        "docsearch = PineconeVectorStore.from_documents(split_docs, embedding_model, index_name=index_name)"
      ],
      "metadata": {
        "id": "Bh3jYapAIWNq"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "search_results = docsearch.similarity_search(\n",
        "    'What is the bank name mentioned in the blog?', k=3\n",
        ")\n",
        "print(search_results)"
      ],
      "metadata": {
        "id": "IFG7HGuRJf7A"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "from langchain import PromptTemplate\n",
        "\n",
        "RAG_PROMPT_TEMPLATE = '''Here is some important context which can help inform the questions the Human asks.\n",
        "Make sure to not make anything up to answer the question if it is not provided in the context.\n",
        "\n",
        "<context>\n",
        "{context}\n",
        "</context>\n",
        "\n",
        "Human: {human_input}\n",
        "\n",
        "Assistant:\n",
        "'''\n",
        "PROMPT = PromptTemplate.from_template(RAG_PROMPT_TEMPLATE)"
      ],
      "metadata": {
        "id": "bCVDh4snJ0q5"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import json"
      ],
      "metadata": {
        "id": "0sqx48qIKf2P"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "human_input = input(\"Enter your question : \")\n",
        "search_results = docsearch.similarity_search(human_input, k=3)\n",
        "context_string = '\\n\\n'.join([f'Document {ind+1}: ' + i.page_content for ind, i in enumerate(search_results)])\n",
        "prompt_data = PROMPT.format(human_input=human_input, context=context_string)\n",
        "inputText=prompt_data\n",
        "body_part=json.dumps({'inputText': inputText,\n",
        " 'textGenerationConfig': {'maxTokenCount': 8192,\n",
        "  'stopSequences': [],\n",
        "  'temperature': 0,\n",
        "  'topP': 1}})\n",
        "response = boto3_bedrock.invoke_model(\n",
        "    body=body_part,\n",
        "    contentType=\"application/json\",\n",
        "    accept=\"application/json\",\n",
        "    modelId='amazon.titan-text-express-v1'\n",
        ")\n",
        "output_text=json.loads(response['body'].read())['results'][0]['outputText']\n",
        "output_text[output_text.index('\\n')+1:]"
      ],
      "metadata": {
        "id": "XzerGgtwJ-H1"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}