openai-cookbook/examples/fine-tuned_qa/olympics-2-create-qa.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"color:orange; font-weight:bold\">Note: To answer questions based on text documents, we recommend the procedure in <a href=\"https://github.com/openai/openai-cookbook/blob/main/examples/Question_answering_using_embeddings.ipynb\">Question Answering using Embeddings</a>. Some of the code below may rely on <a href=\"https://github.com/openai/openai-cookbook/tree/main/transition_guides_for_deprecated_API_endpoints\">deprecated API endpoints</a>.</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2. Creating a synthetic Q&A dataset\n",
    "We use [`davinci-instruct-beta-v3`](https://beta.openai.com/docs/engines/instruct-series-beta), a model specialized in following instructions, to create questions based on the given context. Then we also use [`davinci-instruct-beta-v3`](https://beta.openai.com/docs/engines/instruct-series-beta) to answer those questions, given the same context. \n",
    "\n",
    "This is expensive, and will also take a long time, as we call the davinci engine for each section. You can simply download the final dataset instead.\n",
    "\n",
    "We're using the dataset created using the [previous notebook](olympics-1-collect-data.ipynb)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.1 Read in the data, and create a context\n",
    "Create a context by concatenating the title, the heading and the content of that section"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>title</th>\n",
       "      <th>heading</th>\n",
       "      <th>content</th>\n",
       "      <th>tokens</th>\n",
       "      <th>context</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>2020 Summer Olympics</td>\n",
       "      <td>Summary</td>\n",
       "      <td>The 2020 Summer Olympics (Japanese: 2020年夏季オリン...</td>\n",
       "      <td>713</td>\n",
       "      <td>2020 Summer Olympics\\nSummary\\n\\nThe 2020 Summ...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2020 Summer Olympics</td>\n",
       "      <td>Host city selection</td>\n",
       "      <td>The International Olympic Committee (IOC) vote...</td>\n",
       "      <td>126</td>\n",
       "      <td>2020 Summer Olympics\\nHost city selection\\n\\nT...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>2020 Summer Olympics</td>\n",
       "      <td>Impact of the COVID-19 pandemic</td>\n",
       "      <td>In January 2020, concerns were raised about th...</td>\n",
       "      <td>369</td>\n",
       "      <td>2020 Summer Olympics\\nImpact of the COVID-19 p...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>2020 Summer Olympics</td>\n",
       "      <td>Qualifying event cancellation and postponement</td>\n",
       "      <td>Concerns about the pandemic began to affect qu...</td>\n",
       "      <td>298</td>\n",
       "      <td>2020 Summer Olympics\\nQualifying event cancell...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>2020 Summer Olympics</td>\n",
       "      <td>Effect on doping tests</td>\n",
       "      <td>Mandatory doping tests were being severely res...</td>\n",
       "      <td>163</td>\n",
       "      <td>2020 Summer Olympics\\nEffect on doping tests\\n...</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                  title                                         heading  \\\n",
       "0  2020 Summer Olympics                                         Summary   \n",
       "1  2020 Summer Olympics                             Host city selection   \n",
       "2  2020 Summer Olympics                 Impact of the COVID-19 pandemic   \n",
       "3  2020 Summer Olympics  Qualifying event cancellation and postponement   \n",
       "4  2020 Summer Olympics                          Effect on doping tests   \n",
       "\n",
       "                                             content  tokens  \\\n",
       "0  The 2020 Summer Olympics (Japanese: 2020年夏季オリン...     713   \n",
       "1  The International Olympic Committee (IOC) vote...     126   \n",
       "2  In January 2020, concerns were raised about th...     369   \n",
       "3  Concerns about the pandemic began to affect qu...     298   \n",
       "4  Mandatory doping tests were being severely res...     163   \n",
       "\n",
       "                                             context  \n",
       "0  2020 Summer Olympics\\nSummary\\n\\nThe 2020 Summ...  \n",
       "1  2020 Summer Olympics\\nHost city selection\\n\\nT...  \n",
       "2  2020 Summer Olympics\\nImpact of the COVID-19 p...  \n",
       "3  2020 Summer Olympics\\nQualifying event cancell...  \n",
       "4  2020 Summer Olympics\\nEffect on doping tests\\n...  "
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "df = pd.read_csv('olympics-data/olympics_sections.csv')\n",
    "df['context'] = df.title + \"\\n\" + df.heading + \"\\n\\n\" + df.content\n",
    "df.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.2 Create questions based on the context\n",
    "Use davinci-instruct to generate a number of plausible questions relating to the Wikipedia section contents.\n",
    "\n",
    "Note: We have used temperature=0, but it may be beneficial to experiment with a higher temperature to get a higher diversity of questions.\n",
    "\n",
    "<span style=\"color:orange; font-weight:bold\">WARNING: This step will last a long time, and consume a lot of tokens, as it calls davinci-instruct for every section to generate a number of questions.</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1. What is the 2020 Summer Olympics?\n",
      "2. When did the 2020 Summer Olympics take place?\n",
      "3. Who won the most medals at the 2020 Summer Olympics?\n",
      "4. Who won the most gold medals at the 2020 Summer Olympics?\n",
      "5. Who won the most medals at the 2020 Summer Olympics?\n"
     ]
    }
   ],
   "source": [
    "from openai import OpenAI\n",
    "\n",
    "client = OpenAI(api_key=os.environ.get(\"OPENAI_API_KEY\", \"<your OpenAI API key if not set as env var>\"))\n",
    "\n",
    "def get_questions(context):\n",
    "    try:\n",
    "        response = client.chat.completions.create(model=\"davinci-instruct-beta-v3\",\n",
    "        prompt=f\"Write questions based on the text below\\n\\nText: {context}\\n\\nQuestions:\\n1.\",\n",
    "        temperature=0,\n",
    "        max_tokens=257,\n",
    "        top_p=1,\n",
    "        frequency_penalty=0,\n",
    "        presence_penalty=0,\n",
    "        stop=[\"\\n\\n\"])\n",
    "        return response.choices[0].text\n",
    "    except:\n",
    "        return \"\"\n",
    "\n",
    "\n",
    "df['questions']= df.context.apply(get_questions)\n",
    "df['questions'] = \"1.\" + df.questions\n",
    "print(df[['questions']].values[0][0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The prompt is designed to generate a number of questions. Example questions above were generated based on the summary section of the 2020 Summer Olympics page.\n",
    "\n",
    "We can observe that the questions 3 and 5 above repeat. Sometimes the generated questions could be ambiguous without the context. We will show that even despite these limitations we can create a successful model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The 2020 Summer Olympics (Japanese: 2020年夏季オリンピック, Hepburn: Nisen Nijū-nen Kaki Orinpikku), officially the Games of the XXXII Olympiad (第三十二回オリンピック競技大会, Dai Sanjūni-kai Orinpikku Kyōgi Taikai) and branded as Tokyo 2020 (東京2020, Tōkyō Nii Zero Nii Zero), was an international multi-sport event held from 23 July to 8 August 2021 in Tokyo, Japan, with some preliminary events that began on 21 July.\n",
      "Tokyo was selected as the host city during the 125th IOC Session in Buenos Aires, Argentina, on 7 September 2013. Originally scheduled to take place from 24 July to 9 August 2020, the event was postponed to 2021 in March 2020 as a result of the COVID-19 pandemic, the first such instance in the history of the Olympic Games (previous games had been cancelled but not rescheduled). However, the event retained the Tokyo 2020 name for marketing and branding purposes. It was largely held behind closed doors with no public spectators permitted due to the declaration of a state of emergency in the Greater Tokyo Area in response to the pandemic. The Summer Paralympics were held between 24 August and 5 September 2021, 16 days after the completion of the Olympics.The 2020 Games were the fourth Olympic Games to be held in Japan, following the Tokyo 1964 (Summer), Sapporo 1972 (Winter) and Nagano 1998 (Winter) games. Tokyo is the first city in Asia to hold the Summer Games twice. The 2020 Games were the second of three consecutive Olympics to be held in East Asia, following the 2018 Winter Olympics in Pyeongchang, South Korea and preceding the 2022 Winter Olympics in Beijing, China.\n",
      "New events were introduced in existing sports for 2020, including 3x3 basketball, freestyle BMX and mixed gender team events in a number of existing sports, as well as the return of madison cycling for men and an introduction of the same event for women. New IOC policies also allowed the host organizing committee to add new sports to the Olympic program for just one Games. The disciplines added by the Japanese Olympic Committee were baseball and softball, karate, sport climbing, surfing and skateboarding, the last four of which made their Olympic debuts, and the last three of which will remain on the Olympic program.The United States topped the medal count by both total golds (39) and total medals (113), with China finishing second by both respects (38 and 88). Host nation Japan finished third, setting a record for the most gold medals and total medals ever won by their delegation at an Olympic Games with 27 and 58. Great Britain finished fourth, with a total of 22 gold and 65 medals, becoming the first nation at the Summer Olympics to increase or equal their total medals won in the two Games subsequent to hosting them. The Russian delegation competing as the ROC (not to be confused with the Republic of China (Taiwan) which competed as Chinese Taipei, not ROC) finished fifth with 20 gold medals and third in the overall medal count, with 71 medals. Bermuda, the Philippines and Qatar won their first-ever Olympic gold medals. Burkina Faso, San Marino and Turkmenistan won their first-ever Olympic medals.\n"
     ]
    }
   ],
   "source": [
    "print(df.content.values[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.3 Create answers based on the context\n",
    "Use davinci-instruct to answer the questions given the relevant Wikipedia section contents\n",
    "\n",
    "Note: We have used temperature=0, but it may be beneficial to experiment with a higher temperature to get a higher diversity of questions.\n",
    "\n",
    "<span style=\"color:orange\">**WARNING: This step will last a long time, and consume a lot of tokens, as it calls davinci-instruct for every section to answer all the questions.**</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1. The 2020 Summer Olympics is an international multi-sport event held from 23 July to 8 August 2021 in Tokyo, Japan.\n",
      "2. The 2020 Summer Olympics took place from 23 July to 8 August 2021.\n",
      "3. The United States topped the medal count by both total golds (39) and total medals (113), with China finishing second by both respects (38 and 88).\n",
      "4. The United States topped the medal count by both total golds (39) and total medals (113), with China finishing second by both respects (38 and 88).\n",
      "5. The United States topped the medal count by both total golds (39) and total medals (113), with China finishing second by both respects (38 and 88).\n"
     ]
    }
   ],
   "source": [
    "def get_answers(row):\n",
    "    try:\n",
    "        response = client.chat.completions.create(\n",
    "            engine=\"davinci-instruct-beta-v3\",\n",
    "            prompt=f\"Write answer based on the text below\\n\\nText: {row.context}\\n\\nQuestions:\\n{row.questions}\\n\\nAnswers:\\n1.\",\n",
    "            temperature=0,\n",
    "            max_tokens=257,\n",
    "            top_p=1,\n",
    "            frequency_penalty=0,\n",
    "            presence_penalty=0\n",
    "        )\n",
    "        return response.choices[0].text\n",
    "    except Exception as e:\n",
    "        print (e)\n",
    "        return \"\"\n",
    "\n",
    "\n",
    "df['answers']= df.apply(get_answers, axis=1)\n",
    "df['answers'] = \"1.\" + df.answers\n",
    "df = df.dropna().reset_index().drop('index',axis=1)\n",
    "print(df[['answers']].values[0][0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "These are the answers to the questions above based on the context around the host city selection. \n",
    "\n",
    "We can see that answers 3-5 contain the correct answer, but instead of answering the question directly, the answer is a verbatim extraction. Despite these occasional lower quality answers, we will show that the model can learn the task reasonably well, given a high number of examples."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.4 Save the Olympics Q&A dataset based on Wikipedia sections\n",
    "We save the file for use in the [next notebook](olympics-3-train-qa.ipynb)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "df.to_csv('olympics-data/olympics_qa.csv', index=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.5 Search file (DEPRECATED)\n",
    "We create a search file ([API reference](https://beta.openai.com/docs/api-reference/files/list)), which can be used to retrieve the relevant context when a question is asked.\n",
    "\n",
    "<span style=\"color:orange; font-weight:bold\">DEPRECATED: The /search endpoint is deprecated in favour of using embeddings. Embeddings are cheaper, faster and can support a better search experience. See <a href=\"https://github.com/openai/openai-cookbook/blob/main/examples/Question_answering_using_embeddings.ipynb\">Question Answering Guide</a> for a search implementation using the embeddings</span>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = df[df.tokens<2000]\n",
    "df[['context', 'tokens']].rename(columns={'context':'text','tokens':'metadata'}).to_json('olympics-data/olympics_search.jsonl', orient='records', lines=True)\n",
    "\n",
    "search_file = client.files.create(\n",
    "  file=open(\"olympics-data/olympics_search.jsonl\"),\n",
    "  purpose='search'\n",
    ")\n",
    "olympics_search_fileid = search_file['id']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.6 Answer questions based on the context provided\n",
    "\n",
    "We will use a simple implementation of the answers endpoint. This works by simply using the [/search endpoint](https://beta.openai.com/docs/api-reference/searches), which searches over an indexed file to obtain the relevant sections which can be included in the context, following by a question and answering prompt given a specified model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Athletics at the 2020 Summer Olympics – Women's 4 × 100 metres relay\n",
      "Summary\n",
      "\n",
      "The women's 4 × 100 metres relay event at the 2020 Summer Olympics took place on 5 and 6 August 2021 at the Japan National Stadium. There were 16 competing relay teams, with each team having 5 members from which 4 were selected in each round.\n",
      "\n",
      "###\n",
      "\n",
      "Athletics at the 2020 Summer Olympics – Men's 4 × 100 metres relay\n",
      "Qualification\n",
      "\n",
      "National Olympic Committees (NOCs) could qualify one relay team in one of three following ways:\n",
      "The top 8 NOCs at the 2019 World Athletics Championships qualified a relay team.\n",
      "The top 8 NOCs at the 2021 World Athletics Relays qualified a relay team.\n",
      "Where an NOC placed in the top 8 at both the 2019 World Championships and the 2021 World Relays, the quota place was allocated to the world top list as of 29 June 2021. In this case, 4 teams did so, so there are 4 places available through the world rankings.A total of five athletes may be entered for a relay team. Should a NOC have also entered individual athletes in the corresponding individual event (100 m), the entered individual athletes must be included in the total of five (5) athletes entered for the relay event. In addition of five, NOCs can nominate a maximum of one alternate athlete for each team.\n",
      "The qualifying period was originally from 1 May 2019 to 29 June 2020. Due to the COVID-19 pandemic, the period was suspended from 6 April 2020 to 30 November 2020, with the end date extended to 29 June 2021. The qualifying time standards could be obtained in various meets during the given period that have the approval of the IAAF. Both indoor and outdoor meets are eligible. The most recent Area Championships may be counted in the ranking, even if not during the qualifying period.\n"
     ]
    }
   ],
   "source": [
    "from answers_with_ft import create_context, answer_question\n",
    "print(create_context(\"Where did women's 4 x 100 metres relay event take place during the 2020 Summer Olympics?\", olympics_search_fileid, max_len=400))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "' Japan National Stadium'"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "answer_question(olympics_search_fileid, \"davinci-instruct-beta-v3\", \n",
    "            \"Where did women's 4 x 100 metres relay event take place during the 2020 Summer Olympics?\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "After we fine-tune the model for Q&A we'll be able to use it instead of [`davinci-instruct-beta-v3`](https://beta.openai.com/docs/engines/instruct-series-beta), to obtain better answers when the question can't be answered based on the context. We see a downside of [`davinci-instruct-beta-v3`](https://beta.openai.com/docs/engines/instruct-series-beta), which always attempts to answer the question, regardless of the relevant context being present or not. (Note the second question is asking about a future event, set in 2024.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "' Japan National Stadium'"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "answer_question(olympics_search_fileid, \"davinci-instruct-beta-v3\", \n",
    "            \"Where did women's 4 x 100 metres relay event take place during the 2048 Summer Olympics?\", max_len=1000)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can see that davinci has a tendency to answer the question, even if the question can't be answered given the context provided. Note the question asked regarding 2048 Summer Olympics, which didn't happen yet, and the retrieved content has only returned results for 2020."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.7 (Optional) Investigation into how likely the search endpoint is to return the relevant context"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(0, 58)\n"
     ]
    }
   ],
   "source": [
    "def check_context(title, heading, question, max_len=1800, search_model='ada', max_rerank=10):\n",
    "    \"\"\"\n",
    "    Evaluate the performance of the search model in retrieving the correct context\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    title: str\n",
    "        The title of the Wikipedia page\n",
    "    heading: str\n",
    "        The heading of the Wikipedia section\n",
    "    qusetion: str\n",
    "        The question\n",
    "    max_len: int\n",
    "        The maximum length of the context\n",
    "    search_model: str\n",
    "        The search model to use - `ada` is most cost effective\n",
    "    max_rerank: int\n",
    "        The maximum number of reranking documents to use the search model on\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    rank: int\n",
    "        The rank of the correct context\n",
    "    token_length: int\n",
    "        The number of tokens needed to obtain the correct context\n",
    "    \"\"\"\n",
    "    \n",
    "    try:\n",
    "        # TODO: openai.Engine(search_model) is deprecated\n",
    "        results = openai.Engine(search_model).search(\n",
    "            search_model=search_model, \n",
    "            query=question, \n",
    "            max_rerank=max_rerank,\n",
    "            file=olympics_search_fileid,\n",
    "            return_metadata=True\n",
    "        )\n",
    "        index=-1\n",
    "        returns = []\n",
    "        cur_len = 0\n",
    "        for result in results['data']:\n",
    "            cur_len += int(result['metadata']) + 4 # we add 4 tokens for the separator `\\n\\n###\\n\\n`\n",
    "            if cur_len > max_len:\n",
    "                break\n",
    "            returns.append(result['text'])\n",
    "            res = result['text'].split('\\n')\n",
    "            if res[0] == title and res[1] == heading:\n",
    "                index = len(returns) - 1\n",
    "                break\n",
    "        return index, cur_len\n",
    "    except Exception as e:\n",
    "        #print (e)\n",
    "        return []\n",
    "print(check_context(\"Athletics at the 2020 Summer Olympics – Women's 4 × 100 metres relay\", \"Summary\", \"Where did women's 4 x 100 metres relay event take place during the 2020 Summer Olympics?\", max_len=10000))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We utilize the generated questions based on context to estimate how often we can retrieve the original context. These questions are noisy, so this is not a perfect estimate.\n",
    "\n",
    "Our questions and answers are prefixed with numbered bullet points, however due to the way they were generated, they are missing the first number, hence we add \"1.\" to the list of questions (and answers).\n",
    "\n",
    "We calculate the rank of the section retrieved using ada search, and the number of tokens in the context needed to retrieve the relevant section in full."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    [(132, 27104), (-1, 22939), (8, 2151), (2, 121...\n",
       "1    [(4, 1737), (0, 130), (8, 744), (96, 17208), (...\n",
       "2          [(0, 373), (0, 373), (-1, 40610), (1, 570)]\n",
       "3            [(0, 302), (0, 302), (5, 968), (8, 1425)]\n",
       "4                      [(0, 167), (0, 167), (2, 1442)]\n",
       "Name: ada, dtype: object"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ada_results = df.apply(lambda x: [\n",
    "                    check_context( x.title, \n",
    "                                   x.heading, \n",
    "                                   q[3:],     # remove the number prefix\n",
    "                                   max_len=1000000, # set a large number to get the full context \n",
    "                                   search_model='ada', \n",
    "                                   max_rerank=200,\n",
    "                                 ) \n",
    "                    for q in (x.questions).split('\\n') # split the questions\n",
    "                    if len(q) >10 # remove the empty questions\n",
    "                ], axis=1)\n",
    "ada_results.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "out = pd.concat([ada_results], axis=1)\n",
    "out.columns = ['ada']\n",
    "out.to_csv('olympics-data/search_engine_results.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def expand_lists(out):\n",
    "    \"\"\"\n",
    "    Expand a pandas series containing lists into a series, where each list element becomes a value on its own\n",
    "\n",
    "    Input is a row per paragraph, which has multiple questions\n",
    "    Output is a row per question\n",
    "    \"\"\"\n",
    "    cols = [pd.DataFrame(out[name].tolist()).stack().reset_index(level=1, drop=True).rename(name) for name in out.columns] \n",
    "    return pd.concat(cols, axis=1)\n",
    "\n",
    "out_expanded = expand_lists(out)\n",
    "out_expanded['rank'] = out_expanded.ada.apply(lambda x: x[0] if x != [] else -2)\n",
    "out_expanded['tokens'] = out_expanded.ada.apply(lambda x: x[1] if x != [] else -2)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "74.3% of relevant paragraphs are retrieved within the first 2k tokens\n"
     ]
    }
   ],
   "source": [
    "within_2k = (out_expanded.tokens < 2000).mean()\n",
    "print(f\"{within_2k*100:.1f}% of relevant paragraphs are retrieved within the first 2k tokens\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The relevant context can be obtained 74% of the time on this dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7.4% of relevant paragraphs are not retrieved within the first 200 results\n"
     ]
    }
   ],
   "source": [
    "outside_200 = (out_expanded['rank'] == -1).mean()\n",
    "print(f\"{outside_200*100:.1f}% of relevant paragraphs are not retrieved within the first 200 results\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "7.4% of the time, this is due to the keyword search part of the search algorithm not retrieving the relevant context within the first 200 results.\n",
    "18.3% of the time this is due to the semantic search not placing the relevant context within the first 2000 tokens."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# plot a histogram, and add axis descriptions and title\n",
    "out_expanded[(out_expanded['rank'] >=0)&(out_expanded['rank'] <30)]['rank'].hist(bins=29)\n",
    "plt.xlabel('rank')\n",
    "plt.ylabel('count')\n",
    "plt.title('Histogram of ranks of retrieved paragraphs')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "out_expanded[(out_expanded.tokens>=0)&(out_expanded.tokens < 2000)]['tokens'].hist(bins=29)\n",
    "plt.xlabel('tokens')\n",
    "plt.ylabel('count')\n",
    "plt.title('Histogram of the number of minimum tokens needed')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can observe that the context is most likely to be returned as one of the first results, and most likely to be returned within the first 200-500 tokens."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-2     0.000063\n",
       "-1     0.074428\n",
       " 0     0.453420\n",
       " 1     0.089515\n",
       " 2     0.047146\n",
       " 3     0.032437\n",
       " 4     0.024139\n",
       " 5     0.019676\n",
       " 6     0.015967\n",
       " 7     0.013452\n",
       " 8     0.011189\n",
       " 9     0.009869\n",
       " 10    0.009178\n",
       "Name: rank, dtype: float64"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# normalized value_counts\n",
    "out_expanded['rank'].value_counts(normalize=True).sort_index()[:13]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "probabilities of the relevant context being returned at each rank. (-2 means a processing error, -1 means the rank is >200)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.9.9 64-bit ('3.9.9')",
   "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.9.9"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "cb9817b186a29e4e9713184d901f26c1ee05ad25243d878baff7f31bb1fef480"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}