homework-1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "bb06ac07-b480-4bc1-a464-9809afc66ffe",
   "metadata": {},
   "source": [
    "# Getting the data\n",
    "Now let's get the FAQ data. You can run this snippet:Homework: Introduction\n",
    "\n",
    "In this homework, we'll learn more about search and use Elastic Search for practice.\n",
    "\n",
    "> It's possible that your answers won't match exactly. If it's the case, select the closest one."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "848cf87b-0c1f-4fd8-9b42-fc3786cc1099",
   "metadata": {},
   "outputs": [],
   "source": [
    "from elasticsearch import Elasticsearch\n",
    "from tqdm import tqdm\n",
    "import requests as r"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8f113522-3cd8-4ac3-ac4a-9f693b682d7e",
   "metadata": {},
   "source": [
    "## Q1. Running Elastic\n",
    "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",
    "```\n",
    "curl localhost:9200\n",
    "```\n",
    "\n",
    "What's the `version.build_hash` value?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "9d97ce13-d2e5-4ad3-adba-e31a0c02aa8c",
   "metadata": {},
   "outputs": [],
   "source": [
    "es = Elasticsearch('http://localhost:9200')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "bd5ba407-a3ec-4dac-afea-2e2ccabf86a5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Answer: 42f05b9372a9a4a470db3b52817899b99a76ee73\n"
     ]
    }
   ],
   "source": [
    "print('Answer:', es.info()['version']['build_hash'])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5af362d8-6d3b-49c5-a4de-8571e5c55704",
   "metadata": {},
   "source": [
    "# Getting the data\n",
    "\n",
    "Now let's get the FAQ data. You can run this snippet:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "ca1ca0a1-3dec-4c98-a850-c84c9274cd52",
   "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": "code",
   "execution_count": 5,
   "id": "eaa12bcb-bb9a-4966-bcfe-507f09d9fc43",
   "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'},\n",
       " {'text': 'GitHub - DataTalksClub data-engineering-zoomcamp#prerequisites',\n",
       "  'section': 'General course-related questions',\n",
       "  'question': 'Course - What are the prerequisites for this course?',\n",
       "  'course': 'data-engineering-zoomcamp'},\n",
       " {'text': \"Yes, even if you don't register, you're still eligible to submit the homeworks.\\nBe aware, however, that there will be deadlines for turning in the final projects. So don't leave everything for the last minute.\",\n",
       "  'section': 'General course-related questions',\n",
       "  'question': 'Course - Can I still join the course after the start date?',\n",
       "  'course': 'data-engineering-zoomcamp'}]"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "documents[:3]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "384b277f-5471-4c5c-8dc0-9f800dc0ef42",
   "metadata": {},
   "source": [
    "# Q2. Indexing the data\n",
    "\n",
    "Index the data in the same way as was shown in the course videos. Make the course field a keyword and the rest should be text.\n",
    "\n",
    "Don't forget to install the ElasticSearch client for Python:\n",
    "\n",
    "```bash\n",
    "pip install elasticsearch\n",
    "```\n",
    "\n",
    "Which function do you use for adding your data to elastic?\n",
    "\n",
    "* insert\n",
    "* index\n",
    "* put\n",
    "* add"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6852fe54-5e24-4884-a514-0046a09e351e",
   "metadata": {},
   "source": [
    "Answer: index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "d16b7004-0cf2-4931-a690-71bafad75bb6",
   "metadata": {},
   "outputs": [],
   "source": [
    "index_settings = dict(\n",
    "    settings=dict(number_of_shards=1, number_of_replicas=0),\n",
    "    mappings=dict(\n",
    "        properties=dict(\n",
    "            text=dict(type='text'),\n",
    "            section=dict(type='text'),\n",
    "            question=dict(type='text'),\n",
    "            course=dict(type='keyword')\n",
    "        )\n",
    "    )\n",
    ")\n",
    "index_name = 'course-questions'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "ef1b8197-59f7-4392-be9f-a2d3fb4367fa",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ObjectApiResponse({'acknowledged': True, 'shards_acknowledged': True, 'index': 'course-questions'})"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "es.indices.delete(index=index_name, ignore_unavailable=True)   # clear previously loaded, if any\n",
    "es.indices.create(index=index_name, body=index_settings)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "13a905ce-a429-4e00-b689-939de2f626fe",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 948/948 [00:01<00:00, 731.43it/s]\n"
     ]
    }
   ],
   "source": [
    "for doc in tqdm(documents):\n",
    "    es.index(index=index_name, document=doc)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d32644d2-2200-4090-8ec3-52fc288fe321",
   "metadata": {},
   "source": [
    "## Q3. Searching\n",
    "\n",
    "Now let's search in our index.\n",
    "\n",
    "We will execute a query \"How do I execute a command in a running docker container?\".\n",
    "\n",
    "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",
    "\n",
    "* 94.05\n",
    "* 84.05\n",
    "* 74.05\n",
    "* 64.05\n",
    "\n",
    "Look at the _score field."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "65b5e550-42af-49f0-9bb8-a7106fcdf91a",
   "metadata": {},
   "outputs": [],
   "source": [
    "query = 'How do I execute a command in a running docker container?'\n",
    "query_template = dict(\n",
    "    size=5,\n",
    "    query=dict(\n",
    "        bool=dict(\n",
    "            must=dict(multi_match=dict(query=query, fields=['question^4', 'text'], type='best_fields')),\n",
    "        )\n",
    "    )\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "7dd71b78-6312-46b8-bd74-0854de7b262f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Answer: 82.93802\n"
     ]
    }
   ],
   "source": [
    "response = es.search(index=index_name, body=query_template)\n",
    "best_score = response['hits']['hits'][0]['_score']\n",
    "\n",
    "print('Answer:', best_score)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bcad64b1-9105-49c6-8835-68d497a0df8a",
   "metadata": {},
   "source": [
    "## Q4. Filtering\n",
    "\n",
    "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": 11,
   "id": "61de2252-7495-4abe-adb4-d09f0ffd7f9d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Answer: How do I copy files from a different folder into docker container’s working directory?\n"
     ]
    }
   ],
   "source": [
    "query = 'How do I execute a command in a running docker container?'\n",
    "query_template = dict(\n",
    "    size=3,\n",
    "    query=dict(\n",
    "        bool=dict(\n",
    "            must=dict(multi_match=dict(query=query, fields=['question^4', 'text'], type='best_fields')),\n",
    "            filter=dict(term=dict(course='machine-learning-zoomcamp'))\n",
    "        )\n",
    "    )\n",
    ")\n",
    "\n",
    "response = es.search(index=index_name, body=query_template)\n",
    "hits = [m['_source'] for m in response['hits']['hits']]\n",
    "third_question = hits[-1]['question']\n",
    "\n",
    "print('Answer:', third_question)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ad55ffde-5854-4237-ad17-3ccaa8875687",
   "metadata": {},
   "source": [
    "## Q5. Building a prompt\n",
    "\n",
    "Now we're ready to build a prompt to send to an LLM.\n",
    "\n",
    "Take the records returned from Elasticsearch in Q4 and use this template to build the context. Separate context entries by two linebreaks (\\n\\n)\n",
    "\n",
    "context_template = \"\"\"\n",
    "Q: {question}\n",
    "A: {text}\n",
    "\"\"\".strip()\n",
    "\n",
    "Now use the context you just created along with the \"How do I execute a command in a running docker container?\" question to construct a prompt using the template below:\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",
    "What's the length of the resulting prompt? (use the len function)\n",
    "\n",
    "* 962\n",
    "* 1462\n",
    "* 1962\n",
    "* 2462\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "d27548c0-7fd8-4980-b54d-8232c9c3b971",
   "metadata": {},
   "outputs": [],
   "source": [
    "context = '\\n\\n'.join([f\"Q:{hit['question']} A:{hit['text']}\".strip() for hit in hits])\n",
    "prompt = f'''\n",
    "    You're a course teaching assistant.\n",
    "    Answer the QUESTION based on the CONTEXT from the FAQ database.\n",
    "    Use only the facts from the CONTEXT when answering the QUESION.\n",
    "\n",
    "    QUESTION={query}\n",
    "\n",
    "    CONTEXT:{context}'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "6cd57c79-d14a-4222-b69d-c75d74f6af76",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Answer: 1474\n"
     ]
    }
   ],
   "source": [
    "print('Answer:', len(prompt))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "31c7676b-d704-4568-adbe-5bcbcdc4e1e9",
   "metadata": {},
   "source": [
    "## Q6. Tokens\n",
    "\n",
    "When we use the OpenAI Platform, we're charged by the number of tokens we send in our prompt and receive in the response.\n",
    "\n",
    "The OpenAI python package uses tiktoken for tokenization:\n",
    "\n",
    "```bash\n",
    "pip install tiktoken\n",
    "```\n",
    "\n",
    "Let's calculate the number of tokens in our query:\n",
    "\n",
    "```\n",
    "encoding = tiktoken.encoding_for_model(\"gpt-4o\")\n",
    "```\n",
    "\n",
    "Use the encode function. How many tokens does our prompt have?\n",
    "\n",
    "* 122\n",
    "* 222\n",
    "* 322\n",
    "* 422"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "ea5c39ea-8def-4526-a700-bd82f38edae5",
   "metadata": {},
   "outputs": [],
   "source": [
    "import tiktoken\n",
    "\n",
    "encoding = tiktoken.encoding_for_model('gpt-4o')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "09234543-1de3-4534-a553-244cd0248958",
   "metadata": {},
   "outputs": [],
   "source": [
    "encoded_prompt = encoding.encode(prompt)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "6a95fd23-7ee8-43e0-95a8-748fc04e6d83",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Answer: 330 tokens\n"
     ]
    }
   ],
   "source": [
    "print('Answer:', len(encoded_prompt), 'tokens')"
   ]
  }
 ],
 "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.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}