Homework week 1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "2332d7e6-b0f8-40bc-bb16-54a609f93bfd",
   "metadata": {},
   "source": [
    "### Q1 Running Elastic"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a1bea5af-4503-4aab-962f-6bb88c59030c",
   "metadata": {},
   "source": [
    "❯ curl localhost:9200\n",
    "{\n",
    "  \"name\" : \"637a035dca56\",\n",
    "  \"cluster_name\" : \"docker-cluster\",\n",
    "  \"cluster_uuid\" : \"tk1goW4mSFC0wsqDrsjNZQ\",\n",
    "  \"version\" : {\n",
    "    \"number\" : \"8.4.3\",\n",
    "    \"build_flavor\" : \"default\",\n",
    "    \"build_type\" : \"docker\",\n",
    "    \"build_hash\" : \"42f05b9372a9a4a470db3b52817899b99a76ee73\",\n",
    "    \"build_date\" : \"2022-10-04T07:17:24.662462378Z\",\n",
    "    \"build_snapshot\" : false,\n",
    "    \"lucene_version\" : \"9.3.0\",\n",
    "    \"minimum_wire_compatibility_version\" : \"7.17.0\",\n",
    "    \"minimum_index_compatibility_version\" : \"7.0.0\"\n",
    "  },\n",
    "  \"tagline\" : \"You Know, for Search\"\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "af57f3f3-ff57-4af9-b9de-7d597e8e689c",
   "metadata": {},
   "source": [
    "Answer 1: 42f05b9372a9a4a470db3b52817899b99a76ee73"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "04e4368d-bfb4-4695-9a4e-7fed775016e8",
   "metadata": {},
   "source": [
    "### Getting the data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "8c519b14-204d-45df-a271-963b3179f685",
   "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)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "57f03732-cf94-42d8-97b4-0492d86974e7",
   "metadata": {},
   "source": [
    "### Q2 Indexing the data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "eced8fcc-19f3-41cf-b323-bb73da64307a",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 948/948 [00:07<00:00, 121.82it/s]\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "from tqdm.auto import tqdm\n",
    "from elasticsearch import Elasticsearch\n",
    "\n",
    "# Creating a local client for the search\n",
    "es_client = Elasticsearch('http://localhost:9200')\n",
    "\n",
    "# Index setting\n",
    "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",
    "# Naming the index\n",
    "index_name = \"course-questions\"\n",
    "\n",
    "# Creating the index using the settings and the name\n",
    "es_client.indices.create(index=index_name, body=index_settings)\n",
    "\n",
    "# Using the index to iterate through all documents\n",
    "for doc in tqdm(documents):\n",
    "    es_client.index(index=index_name, document=doc)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c7cca450-a7c5-4e52-8570-9cf086edde91",
   "metadata": {},
   "source": [
    "Answer 2: Index"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f6ff529f-8e09-41f1-9ba9-9ece8cd8bb38",
   "metadata": {},
   "source": [
    "### Q3 Searching"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "60e465a3-ff5c-4607-acb8-b3701fd3a3da",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[{'_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)',\n",
       "   'section': '5. Deploying Machine Learning Models',\n",
       "   'question': 'How do I debug a docker container?',\n",
       "   'course': 'machine-learning-zoomcamp'},\n",
       "  '_score': 84.050095},\n",
       " {'_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>',\n",
       "   'section': 'Module 1: Docker and Terraform',\n",
       "   'question': 'PGCLI - running in a Docker container',\n",
       "   'course': 'data-engineering-zoomcamp'},\n",
       "  '_score': 75.54128},\n",
       " {'_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!',\n",
       "   'section': 'Module 4: Deployment',\n",
       "   'question': 'Running multiple services in a Docker container',\n",
       "   'course': 'mlops-zoomcamp'},\n",
       "  '_score': 72.08518},\n",
       " {'_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\",\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",
       "  '_score': 51.04628},\n",
       " {'_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',\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",
       "  '_score': 49.938507}]"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "query = \"How do I execute a command in a running docker container?\"\n",
    "\n",
    "def elastic_search(query):\n",
    "    \n",
    "    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",
    "    # Searhing using the query\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({\n",
    "            \"_source\": hit['_source'],\n",
    "            \"_score\": hit['_score']\n",
    "        })\n",
    "\n",
    "    return result_docs\n",
    "\n",
    "elastic_search(query)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6aab5a14-e4c2-4a61-81f2-949e07cc02ec",
   "metadata": {},
   "source": [
    "Answer 3: 84.05"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bfabb9bc-9500-4994-80f1-3f8def6887e5",
   "metadata": {},
   "source": [
    "### Q4 Filtering"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "4b7909d7-12e2-4dcb-821a-31d794f9d060",
   "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': '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'}]"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def elastic_search_filtered(query):\n",
    "    \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",
    "    # Searhing using the query\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",
    "\n",
    "    return result_docs\n",
    "\n",
    "elastic_search_filtered(query)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7bb07d87-3c94-446f-9e8d-cdf82b4e9f7c",
   "metadata": {},
   "source": [
    "Answer 4: How do I copy files from a different folder into docker container’s working directory?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dcb57e18-4c99-4d89-a162-d5c61db37827",
   "metadata": {},
   "source": [
    "### Q5 Building a prompt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "b59e1a65-0c09-4e4e-abe6-689e49845d4f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "You're a course teaching assistant. 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",
      "Q: How do I debug a docker container?\n",
      "A: 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",
      "Q: How do I copy files from my local machine to docker container?\n",
      "A: 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",
      "Q: How do I copy files from a different folder into docker container’s working directory?\n",
      "A: 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"
     ]
    },
    {
     "data": {
      "text/plain": [
       "1462"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def build_prompt(query, search_results):\n",
    "    context_entries = []\n",
    "    context_template = \"\"\"\n",
    "Q: {question}\n",
    "A: {text}\n",
    "\"\"\".strip()\n",
    "\n",
    "    prompt_template = \"\"\"\n",
    "You're a course teaching assistant. 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",
    "    for record in search_results:\n",
    "        # print(\"Printing a record: \", record)\n",
    "        formatted_entry = context_template.format(question=record['question'], text=record['text'])\n",
    "        #print(\"Printing the formatted entry: \", formatted_entry)\n",
    "        context_entries.append(formatted_entry)\n",
    "\n",
    "    context = \"\\n\\n\".join(context_entries)\n",
    "\n",
    "    prompt = prompt_template.format(question=query, context=context).strip()\n",
    "    return prompt\n",
    "\n",
    "final_prompt = build_prompt(query, elastic_search_filtered(query))\n",
    "\n",
    "print(final_prompt)\n",
    "len(final_prompt)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ca919223-8825-42a0-9e17-0e95183cf7c5",
   "metadata": {},
   "source": [
    "Answer 5: 1462"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "679babf1-94fa-46ec-833f-cf1509218287",
   "metadata": {},
   "source": [
    "### Q6 Tokens"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "ecc8bc7b-b027-4d6f-8a03-7686a9c1721f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "322"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import sys\n",
    "sys.path.append('/home/dmitry/Documents/Programming/Python/llm-zoomcamp/.venv/lib/python3.12/site-packages/')\n",
    "import tiktoken\n",
    "# Using tokenization algorithm for gpt-4o: https://community.openai.com/t/whats-the-new-tokenization-algorithm-for-gpt-4o/746708\n",
    "# encoding = tiktoken.get_encoding(\"o200k_base\")\n",
    "encoding = tiktoken.encoding_for_model(\"gpt-4o\")\n",
    "tokens = encoding.encode(final_prompt)\n",
    "len(tokens)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dd4fa9ee-6dc4-4f14-8475-dd8ee71fc0b7",
   "metadata": {},
   "source": [
    "Answer 6: 322"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3d9c7c74-4556-4aa9-87db-d124b09bd73c",
   "metadata": {},
   "source": [
    "### Bonus: generating the answer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "c630cd28-3941-4fb2-b06f-0d427ade8272",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "To execute a command in a running Docker container, follow these steps:\n",
      "\n",
      "1. First, find the container ID of the running container by using the following command:\n",
      "   ```sh\n",
      "   docker ps\n",
      "   ```\n",
      "\n",
      "2. Once you have the container ID, you can execute a command in that specific container. For example, to start a bash session inside the container, use the following command:\n",
      "   ```sh\n",
      "   docker exec -it <container-id> bash\n",
      "   ```\n",
      "\n",
      "Replace `<container-id>` with the actual ID of your running container.\n"
     ]
    }
   ],
   "source": [
    "from openai import OpenAI\n",
    "from dotenv import load_dotenv\n",
    "\n",
    "load_dotenv()\n",
    "client = OpenAI()\n",
    "\n",
    "def llm(prompt):\n",
    "    response = client.chat.completions.create(\n",
    "        model='gpt-4o',\n",
    "        messages=[{\"role\": \"user\", \"content\": prompt}]\n",
    "    )\n",
    "    \n",
    "    return response.choices[0].message.content\n",
    "\n",
    "response = llm(final_prompt)\n",
    "print(response)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8693af73-0952-4644-9e63-fb588db9407e",
   "metadata": {},
   "source": [
    "### Bonus: calculating the costs"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "702b462a-529d-40c5-a9e3-e546a40d88cb",
   "metadata": {},
   "source": [
    "Cost for gpt-4o:\n",
    "\n",
    "    Input: $0.005 / 1K tokens\n",
    "Output: $0.015 / 1K tokens\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "fa775dfc-bb45-4933-b8f0-fdecb924ecee",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The prompt is 1462 characters long\n",
      "Cost of our final prompt is $ 0.00161\n",
      "The response is 493 characters long\n",
      "Cost of the response is $ 0.001665\n"
     ]
    }
   ],
   "source": [
    "# Prompt cost\n",
    "p_cost = len(tokens) * 0.005 / 1000\n",
    "print(\"The prompt is\", len(final_prompt), \"characters long\")\n",
    "print(\"Cost of our final prompt is $\", p_cost)\n",
    "\n",
    "# Answer cost\n",
    "a_tokens = encoding.encode(response)\n",
    "a_cost = len(a_tokens) * 0.015 / 1000\n",
    "print(\"The response is\", len(response), \"characters long\")\n",
    "print(\"Cost of the response is $\", a_cost)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "94c4c94b-3a56-44ea-8c39-afe94261ce63",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.12.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}