01-Intro/Homework.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "128d12eb-685f-4c4f-8fcd-474ed559e1a5",
   "metadata": {},
   "source": [
    "## Q1. Running Elastic "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8ff1142f-8179-4512-8aba-9e0b01942545",
   "metadata": {},
   "source": [
    "Run Elastic Search 8.4.3, and get the cluster information. If you run it on localhost, this is how you do it:\n",
    "\n",
    "```bash\n",
    "curl localhost:9200\n",
    "```\n",
    "\n",
    "#### What's the `version.build_hash` value?\n",
    "- \"build_hash\" : \"42f05b9372a9a4a470db3b52817899b99a76ee73\"\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8d7e8410-f926-4f8c-859f-743e7ce30094",
   "metadata": {},
   "source": [
    "### Getting the Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "b17367a2-97ea-4d67-93ac-452b784d9763",
   "metadata": {},
   "outputs": [],
   "source": [
    "import requests \n",
    "\n",
    "docs_url = 'https://github.com/DataTalksClub/llm-zoomcamp/blob/main/01-intro/documents.json?raw=1'\n",
    "docs_response = requests.get(docs_url)\n",
    "documents_raw = docs_response.json()\n",
    "\n",
    "documents = []\n",
    "\n",
    "for course in documents_raw:\n",
    "    course_name = course['course']\n",
    "\n",
    "    for doc in course['documents']:\n",
    "        doc['course'] = course_name\n",
    "        documents.append(doc)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "05dd4a09-7730-40b8-8350-7beb7fffa888",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'text': \"The purpose of this document is to capture frequently asked technical questions\\nThe exact day and hour of the course will be 15th Jan 2024 at 17h00. The course will start with the first  “Office Hours'' live.1\\nSubscribe to course public Google Calendar (it works from Desktop only).\\nRegister before the course starts using this link.\\nJoin the course Telegram channel with announcements.\\nDon’t forget to register in DataTalks.Club's Slack and join the channel.\",\n",
       " 'section': 'General course-related questions',\n",
       " 'question': 'Course - When will the course start?',\n",
       " 'course': 'data-engineering-zoomcamp'}"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "documents[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5d4dbadf-7532-4335-b260-0a86bdf3ee77",
   "metadata": {},
   "source": [
    "## Q2. Indexing the data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "7440b4aa-1b1a-4384-805a-0cf35cdf24ac",
   "metadata": {},
   "outputs": [],
   "source": [
    "from elasticsearch import Elasticsearch"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "9d4a73b1-8797-4f92-9df2-fdc762161b5a",
   "metadata": {},
   "outputs": [],
   "source": [
    "es_client = Elasticsearch('http://localhost:9200')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "6011b789-4640-4e03-869e-f63be88d9dff",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ObjectApiResponse({'acknowledged': True, 'shards_acknowledged': True, 'index': 'course-question-all'})"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "index_Settings = {\n",
    "    \"settings\": {\n",
    "        \"number_of_shards\": 1,\n",
    "        \"number_of_replicas\": 0\n",
    "    },\n",
    "    \"mappings\": {\n",
    "        \"properties\": {\n",
    "            \"text\": {\"type\": \"text\"},\n",
    "            \"section\": {\"type\": \"text\"},\n",
    "            \"question\": {\"type\": \"text\"},\n",
    "            \"course\": {\"type\": \"keyword\"} \n",
    "        }\n",
    "    }\n",
    "}\n",
    "\n",
    "index_name = \"course-question-all\"\n",
    "\n",
    "es_client.indices.create(index=index_name, body=index_Settings)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e32cde8f-74c3-483b-839e-c921cc812c9f",
   "metadata": {},
   "source": [
    "### Which function do you use for adding your data to elastic?\n",
    "- Index Function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "5e2eef63-b882-4abd-a89e-e4ae7511fe4e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "3d887dfa17144d9eacdbb2ba70e59a5e",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/948 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from tqdm.auto import tqdm\n",
    "\n",
    "for doc in tqdm(documents):\n",
    "    es_client.index(index=index_name, document=doc)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9eb509f8-0b04-48a9-889f-a9b831ccda8b",
   "metadata": {},
   "source": [
    "## Q3. Searching"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "87dad847-6d85-482b-a95a-5cd83f540064",
   "metadata": {},
   "outputs": [],
   "source": [
    "query = 'How do I execute a command in a running docker container?'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3210a838-503a-48db-b07e-f6758234a817",
   "metadata": {},
   "source": [
    "### Use only question and text fields and give question a boost of 4, and use \"type\": \"best_fields\".\n",
    "\n",
    "### What's the score for the top ranking result?\n",
    " #### Score: 84.050095"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "7ea5c67e-9d2f-4d90-aa7b-32eae949a91d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Score: 84.050095, Source: {'text': 'Launch the container image in interactive mode and overriding the entrypoint, so that it starts a bash command.\\ndocker run -it --entrypoint bash <image>\\nIf the container is already running, execute a command in the specific container:\\ndocker ps (find the container-id)\\ndocker exec -it <container-id> bash\\n(Marcos MJD)', 'section': '5. Deploying Machine Learning Models', 'question': 'How do I debug a docker container?', 'course': 'machine-learning-zoomcamp'}\n",
      "Score: 75.54128, Source: {'text': 'In case running pgcli  locally causes issues or you do not want to install it locally you can use it running in a Docker container instead.\\nBelow the usage with values used in the videos of the course for:\\nnetwork name (docker network)\\npostgres related variables for pgcli\\nHostname\\nUsername\\nPort\\nDatabase name\\n$ docker run -it --rm --network pg-network ai2ys/dockerized-pgcli:4.0.1\\n175dd47cda07:/# pgcli -h pg-database -U root -p 5432 -d ny_taxi\\nPassword for root:\\nServer: PostgreSQL 16.1 (Debian 16.1-1.pgdg120+1)\\nVersion: 4.0.1\\nHome: http://pgcli.com\\nroot@pg-database:ny_taxi> \\\\dt\\n+--------+------------------+-------+-------+\\n| Schema | Name             | Type  | Owner |\\n|--------+------------------+-------+-------|\\n| public | yellow_taxi_data | table | root  |\\n+--------+------------------+-------+-------+\\nSELECT 1\\nTime: 0.009s\\nroot@pg-database:ny_taxi>', 'section': 'Module 1: Docker and Terraform', 'question': 'PGCLI - running in a Docker container', 'course': 'data-engineering-zoomcamp'}\n",
      "Score: 72.08518, Source: {'text': 'If you are trying to run Flask gunicorn & MLFlow server from the same container, defining both in Dockerfile with CMD will only run MLFlow & not Flask.\\nSolution: Create separate shell script with server run commands, for eg:\\n> \\tscript1.sh\\n#!/bin/bash\\ngunicorn --bind=0.0.0.0:9696 predict:app\\nAnother script with e.g. MLFlow server:\\n>\\tscript2.sh\\n#!/bin/bash\\nmlflow server -h 0.0.0.0 -p 5000 --backend-store-uri=sqlite:///mlflow.db --default-artifact-root=g3://zc-bucket/mlruns/\\nCreate a wrapper script to run above 2 scripts:\\n>\\twrapper_script.sh\\n#!/bin/bash\\n# Start the first process\\n./script1.sh &\\n# Start the second process\\n./script2.sh &\\n# Wait for any process to exit\\nwait -n\\n# Exit with status of process that exited first\\nexit $?\\nGive executable permissions to all scripts:\\nchmod +x *.sh\\nNow we can define last line of Dockerfile as:\\n> \\tDockerfile\\nCMD ./wrapper_script.sh\\nDont forget to expose all ports defined by services!', 'section': 'Module 4: Deployment', 'question': 'Running multiple services in a Docker container', 'course': 'mlops-zoomcamp'}\n",
      "Score: 51.04628, Source: {'text': \"You can copy files from your local machine into a Docker container using the docker cp command. Here's how to do it:\\nTo copy a file or directory from your local machine into a running Docker container, you can use the `docker cp command`. The basic syntax is as follows:\\ndocker cp /path/to/local/file_or_directory container_id:/path/in/container\\nHrithik Kumar Advani\", 'section': '5. Deploying Machine Learning Models', 'question': 'How do I copy files from my local machine to docker container?', 'course': 'machine-learning-zoomcamp'}\n",
      "Score: 49.938507, Source: {'text': 'You can copy files from your local machine into a Docker container using the docker cp command. Here\\'s how to do it:\\nIn the Dockerfile, you can provide the folder containing the files that you want to copy over. The basic syntax is as follows:\\nCOPY [\"src/predict.py\", \"models/xgb_model.bin\", \"./\"]\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tGopakumar Gopinathan', 'section': '5. Deploying Machine Learning Models', 'question': 'How do I copy files from a different folder into docker container’s working directory?', 'course': 'machine-learning-zoomcamp'}\n"
     ]
    }
   ],
   "source": [
    "search_query = {\n",
    "    \"size\": 5,\n",
    "    \"query\": {\n",
    "        \"bool\": {\n",
    "            \"must\": {\n",
    "                \"multi_match\": {\n",
    "                    \"query\": query,\n",
    "                    \"fields\": [\"question^4\", \"text\"], \n",
    "                    \"type\": \"best_fields\"\n",
    "                }\n",
    "            }\n",
    "        }\n",
    "    }\n",
    "}\n",
    "\n",
    "response = es_client.search(index=index_name, body=search_query)\n",
    "\n",
    "for hit in response['hits']['hits']:\n",
    "    print(f\"Score: {hit['_score']}, Source: {hit['_source']}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a0c82798-de81-4a6b-9ca9-c3bdc9acf9fb",
   "metadata": {},
   "source": [
    "## Q4. Filtering"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cd000aac-5e22-495f-a642-9d82634dee82",
   "metadata": {},
   "source": [
    "Now let's only limit the questions to machine-learning-zoomcamp.\n",
    "\n",
    "Return 3 results. What's the 3rd question returned by the search engine?\n",
    "\n",
    "How do I debug a docker container?\n",
    "How do I copy files from a different folder into docker container’s working directory?\n",
    "How do Lambda container images work?\n",
    "How can I annotate a graph?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "ba754fb7-32a2-470c-8a48-b2193262c6df",
   "metadata": {},
   "outputs": [],
   "source": [
    "def elastic_search(query):\n",
    "    search_query = {\n",
    "        \"size\": 3,\n",
    "        \"query\": {\n",
    "            \"bool\": {\n",
    "                \"must\": {\n",
    "                    \"multi_match\": {\n",
    "                        \"query\": query,\n",
    "                        \"fields\": [\"question^4\", \"text\"], \n",
    "                        \"type\": \"best_fields\"\n",
    "                    }\n",
    "                },\n",
    "                \"filter\": {\n",
    "                    \"term\": {\n",
    "                        \"course\": \"machine-learning-zoomcamp\"\n",
    "                    }\n",
    "                }\n",
    "            }\n",
    "        }\n",
    "    }\n",
    "\n",
    "    response = es_client.search(index=index_name, body=search_query)\n",
    "\n",
    "    result_docs = []\n",
    "\n",
    "    for hit in response['hits']['hits']:\n",
    "        result_docs.append(hit['_source'])\n",
    "    return result_docs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "bcfa0f64-f4c1-46f8-8597-f01499abde8f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[{'text': 'Launch the container image in interactive mode and overriding the entrypoint, so that it starts a bash command.\\ndocker run -it --entrypoint bash <image>\\nIf the container is already running, execute a command in the specific container:\\ndocker ps (find the container-id)\\ndocker exec -it <container-id> bash\\n(Marcos MJD)',\n",
       "  'section': '5. Deploying Machine Learning Models',\n",
       "  'question': 'How do I debug a docker container?',\n",
       "  'course': 'machine-learning-zoomcamp'},\n",
       " {'text': \"You can copy files from your local machine into a Docker container using the docker cp command. Here's how to do it:\\nTo copy a file or directory from your local machine into a running Docker container, you can use the `docker cp command`. The basic syntax is as follows:\\ndocker cp /path/to/local/file_or_directory container_id:/path/in/container\\nHrithik Kumar Advani\",\n",
       "  'section': '5. Deploying Machine Learning Models',\n",
       "  'question': 'How do I copy files from my local machine to docker container?',\n",
       "  'course': 'machine-learning-zoomcamp'},\n",
       " {'text': 'I wanted to understand how lambda container images work in depth and how lambda functions are initialized, for this reason, I found the following documentation\\nhttps://docs.aws.amazon.com/lambda/latest/dg/images-create.html\\nhttps://docs.aws.amazon.com/lambda/latest/dg/runtimes-api.html\\nAdded by Alejandro aponte',\n",
       "  'section': '9. Serverless Deep Learning',\n",
       "  'question': 'How do Lambda container images work?',\n",
       "  'course': 'machine-learning-zoomcamp'}]"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "elastic_search('How do I debug a docker container?')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "bda9d515-2225-4e1c-b38a-aed73dbbc446",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[{'text': 'You can copy files from your local machine into a Docker container using the docker cp command. Here\\'s how to do it:\\nIn the Dockerfile, you can provide the folder containing the files that you want to copy over. The basic syntax is as follows:\\nCOPY [\"src/predict.py\", \"models/xgb_model.bin\", \"./\"]\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tGopakumar Gopinathan',\n",
       "  'section': '5. Deploying Machine Learning Models',\n",
       "  'question': 'How do I copy files from a different folder into docker container’s working directory?',\n",
       "  'course': 'machine-learning-zoomcamp'},\n",
       " {'text': \"You can copy files from your local machine into a Docker container using the docker cp command. Here's how to do it:\\nTo copy a file or directory from your local machine into a running Docker container, you can use the `docker cp command`. The basic syntax is as follows:\\ndocker cp /path/to/local/file_or_directory container_id:/path/in/container\\nHrithik Kumar Advani\",\n",
       "  'section': '5. Deploying Machine Learning Models',\n",
       "  'question': 'How do I copy files from my local machine to docker container?',\n",
       "  'course': 'machine-learning-zoomcamp'},\n",
       " {'text': 'Launch the container image in interactive mode and overriding the entrypoint, so that it starts a bash command.\\ndocker run -it --entrypoint bash <image>\\nIf the container is already running, execute a command in the specific container:\\ndocker ps (find the container-id)\\ndocker exec -it <container-id> bash\\n(Marcos MJD)',\n",
       "  'section': '5. Deploying Machine Learning Models',\n",
       "  'question': 'How do I debug a docker container?',\n",
       "  'course': 'machine-learning-zoomcamp'}]"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "elastic_search('How do I copy files from a different folder into docker container’s working directory?')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "e70f06da-005c-4ad2-bc1e-efccc33698af",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[{'text': 'I wanted to understand how lambda container images work in depth and how lambda functions are initialized, for this reason, I found the following documentation\\nhttps://docs.aws.amazon.com/lambda/latest/dg/images-create.html\\nhttps://docs.aws.amazon.com/lambda/latest/dg/runtimes-api.html\\nAdded by Alejandro aponte',\n",
       "  'section': '9. Serverless Deep Learning',\n",
       "  'question': 'How do Lambda container images work?',\n",
       "  'course': 'machine-learning-zoomcamp'},\n",
       " {'text': 'Tim from BentoML has prepared a dedicated video tutorial wrt this use case here:\\nhttps://www.youtube.com/watch?v=7gI1UH31xb4&list=PL3MmuxUbc_hIhxl5Ji8t4O6lPAOpHaCLR&index=97\\nKonrad Muehlberg',\n",
       "  'section': 'Miscellaneous',\n",
       "  'question': 'How to pass BentoML content / docker container to Amazon Lambda',\n",
       "  'course': 'machine-learning-zoomcamp'},\n",
       " {'text': 'Launch the container image in interactive mode and overriding the entrypoint, so that it starts a bash command.\\ndocker run -it --entrypoint bash <image>\\nIf the container is already running, execute a command in the specific container:\\ndocker ps (find the container-id)\\ndocker exec -it <container-id> bash\\n(Marcos MJD)',\n",
       "  'section': '5. Deploying Machine Learning Models',\n",
       "  'question': 'How do I debug a docker container?',\n",
       "  'course': 'machine-learning-zoomcamp'}]"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "elastic_search('How do Lambda container images work?')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "fe68faab-6c30-44ad-8266-a8775a81ab33",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[{'text': \"Matplotlib has a cool method to annotate where you could provide an X,Y point and annotate with an arrow and text. For example this will show an arrow pointing to the x,y point optimal threshold.\\nplt.annotate(f'Optimal Threshold: {optimal_threshold:.2f}\\\\nOptimal F1 Score: {optimal_f1_score:.2f}',\\nxy=(optimal_threshold, optimal_f1_score),\\nxytext=(0.3, 0.5),\\ntextcoords='axes fraction',\\narrowprops=dict(facecolor='black', shrink=0.05))\\nQuinn Avila\",\n",
       "  'section': '4. Evaluation Metrics for Classification',\n",
       "  'question': 'How can I annotate a graph?',\n",
       "  'course': 'machine-learning-zoomcamp'},\n",
       " {'text': 'I like this visual implementation of features importance in scikit-learn library:\\nhttps://scikit-learn.org/stable/auto_examples/ensemble/plot_forest_importances.html\\nIt actually adds std.errors to features importance -> so that you can trace stability of features (important for a model’s explainability) over the different params of the model.\\nIvan Brigida',\n",
       "  'section': '6. Decision Trees and Ensemble Learning',\n",
       "  'question': 'Features Importance graph',\n",
       "  'course': 'machine-learning-zoomcamp'},\n",
       " {'text': 'Welcome to the course! Go to the course page (http://mlzoomcamp.com/), scroll down and start going through the course materials. Then read everything in the cohort folder for your cohort’s year.\\nClick on the links and start watching the videos. Also watch office hours from previous cohorts. Go to DTC youtube channel and click on Playlists and search for {course yyyy}. ML Zoomcamp was first launched in 2021.\\nOr you can just use this link: http://mlzoomcamp.com/#syllabus',\n",
       "  'section': 'General course-related questions',\n",
       "  'question': 'I just joined. What should I do next? How can I access course materials?',\n",
       "  'course': 'machine-learning-zoomcamp'}]"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "elastic_search('How can I annotate a graph?')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b774efb6-637a-4969-9b56-4cfc992e7bc4",
   "metadata": {},
   "source": [
    "## Q5. Building a prompt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "ee6c9ad4-8b70-41b8-b944-09e6ca5abbca",
   "metadata": {},
   "outputs": [],
   "source": [
    "query = \"How do I execute a command in a running docker container?\"\n",
    "search_result = elastic_search(query)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "id": "66b35212-e3ab-426a-9c17-d4c631ab1ef8",
   "metadata": {},
   "outputs": [],
   "source": [
    "def build_prompt(query, search_results):\n",
    "    prompt_template = \"\"\"\n",
    "Answer the QUESTION based on the CONTEXT from the FAQ database.\n",
    "Use only the facts from the CONTEXT when answering the QUESTION.\n",
    "\n",
    "QUESTION: {question}\n",
    "\n",
    "CONTEXT:\n",
    "{context}\n",
    "\"\"\".strip()\n",
    "\n",
    "    context_template = \"\"\"\n",
    "Q: {question}\n",
    "A: {text}\n",
    "\"\"\".strip()\n",
    "\n",
    "    context = \"\"\n",
    "\n",
    "    for doc in search_results:\n",
    "        context = context + f\"question: {doc['question']}\\nanswer: {doc['text']}\\n\\n\"\n",
    "    \n",
    "    prompt = prompt_template.format(question=query, context=context).strip()\n",
    "    prompt_length = len(prompt)\n",
    "\n",
    "    print(\"Prompt len is:\", prompt_length)\n",
    "    return prompt\n",
    "    \n",
    "    \n",
    "    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "id": "3f710067-bb8f-4250-94c0-8dbef5632e6e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Prompt len is: 1462\n",
      "Answer the QUESTION based on the CONTEXT from the FAQ database.\n",
      "Use only the facts from the CONTEXT when answering the QUESTION.\n",
      "\n",
      "QUESTION: How do I execute a command in a running docker container?\n",
      "\n",
      "CONTEXT:\n",
      "question: How do I debug a docker container?\n",
      "answer: Launch the container image in interactive mode and overriding the entrypoint, so that it starts a bash command.\n",
      "docker run -it --entrypoint bash <image>\n",
      "If the container is already running, execute a command in the specific container:\n",
      "docker ps (find the container-id)\n",
      "docker exec -it <container-id> bash\n",
      "(Marcos MJD)\n",
      "\n",
      "question: How do I copy files from my local machine to docker container?\n",
      "answer: You can copy files from your local machine into a Docker container using the docker cp command. Here's how to do it:\n",
      "To copy a file or directory from your local machine into a running Docker container, you can use the `docker cp command`. The basic syntax is as follows:\n",
      "docker cp /path/to/local/file_or_directory container_id:/path/in/container\n",
      "Hrithik Kumar Advani\n",
      "\n",
      "question: How do I copy files from a different folder into docker container’s working directory?\n",
      "answer: You can copy files from your local machine into a Docker container using the docker cp command. Here's how to do it:\n",
      "In the Dockerfile, you can provide the folder containing the files that you want to copy over. The basic syntax is as follows:\n",
      "COPY [\"src/predict.py\", \"models/xgb_model.bin\", \"./\"]\t\t\t\t\t\t\t\t\t\t\tGopakumar Gopinathan\n"
     ]
    }
   ],
   "source": [
    "prompt = build_prompt(query, search_result)\n",
    "print(prompt)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4ed492c1-5ab8-4fe0-b9c2-cd59ee9842bd",
   "metadata": {},
   "source": [
    "## Q6. Tokens"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "id": "21455946-6a9a-4ae5-9cfc-4ed89986aac7",
   "metadata": {},
   "outputs": [],
   "source": [
    "import tiktoken"
   ]
  },
  {
   "cell_type": "raw",
   "id": "9bffb425-0a36-4351-9aa8-0ae26e2864f5",
   "metadata": {},
   "source": [
    "Let's calculate the number of tokens in our query:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "id": "6b295b07-7ec4-4a69-93e0-64cd10d0846c",
   "metadata": {},
   "outputs": [],
   "source": [
    "encoding = tiktoken.encoding_for_model(\"gpt-4o\")"
   ]
  },
  {
   "cell_type": "raw",
   "id": "c83c04c6-4349-464c-8599-12bf136b771c",
   "metadata": {},
   "source": [
    "Use the encode function. How many tokens does our prompt have?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "id": "80d9ae28-b77f-4c4a-ad0b-38204c2efde8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Prompt number of Tokens 316\n",
      "Decoded Token: b\"You're\"\n"
     ]
    }
   ],
   "source": [
    "token = encoding.encode(prompt)\n",
    "num_tokens = len(token)\n",
    "print(\"Prompt number of Tokens\", num_tokens)\n",
    "\n",
    "print(\"Decoded Token:\", encoding.decode_single_token_bytes(63842))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8eb8ca14-cd14-472b-8b05-1b7cdb513718",
   "metadata": {},
   "source": [
    "## Bonus: generating the answer (ungraded)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "886907f0-ea31-4d57-b31a-e6f5b2b5ab86",
   "metadata": {},
   "source": [
    "### Let's send the prompt to OpenAI. What's the response?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "id": "2a033623-04a3-41c1-8593-360eacb6a14b",
   "metadata": {},
   "outputs": [],
   "source": [
    "from openai import OpenAI\n",
    "client = OpenAI()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "id": "fe80a7e3-f72a-46b5-b988-af617bfdc137",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "response = client.chat.completions.create(\n",
    "        model='gpt-4o',\n",
    "        messages=[{\"role\":\"user\", \"content\":prompt}]\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "id": "10545bf6-55ff-4ea0-8e01-bb362a608708",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "To execute a command in a running docker container, follow these steps:\n",
      "\n",
      "1. Find the container ID by listing the running containers using:\n",
      "   ```\n",
      "   docker ps \n",
      "   ```\n",
      "2. Once you have the container ID, execute a command in the container using:\n",
      "   ```\n",
      "   docker exec -it <container-id> bash\n",
      "   ```\n"
     ]
    }
   ],
   "source": [
    "print(response.choices[0].message.content)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0407178c-9a46-43d1-8d3e-f05aede1d20d",
   "metadata": {},
   "source": [
    "### on June 25, the prices for gpt4o are:\n",
    "\n",
    "Input: $0.005 / 1K tokens\n",
    "\n",
    "Output: $0.015 / 1K tokens"
   ]
  },
  {
   "cell_type": "raw",
   "id": "0957cfb9-6c72-4a77-90b1-b5c9a74e3bcc",
   "metadata": {},
   "source": [
    "input has 316 token in each request so total cost = ((316*0.005)/1000)*1000 = 1.58$"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}