analysis.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "579b567a-2b80-4bf1-8cc1-c514da76ca50",
   "metadata": {},
   "source": [
    "# (ADA) Homework 1: Scoring the Language Model Olympics\n",
    "\n",
    "---\n",
    "\n",
    "By the end of this homework, we expect you to be able to:\n",
    "\n",
    "- Load data and handle data using pandas;\n",
    "- Navigate the documentation of Python packages by yourself;\n",
    "- Filter and tidy up noisy real-world datasets;\n",
    "- Aggregate your data in different (and hopefully helpful) ways;\n",
    "- Create meaningful visualizations to analyze the data;\n",
    "- Communicate your findings in a clear and concise manner\n",
    "\n",
    "---\n",
    "\n",
    "**Important Dates.**\n",
    "\n",
    "- Homework release: Fri 04 Oct 2024\n",
    "- Homework due: Sat 18 Oct 2024, 23:59\n",
    "- Grade release: Mon 04 Nov 2024\n",
    "\n",
    "**Some rules**\n",
    "\n",
    "- You are allowed to use any built-in Python library that comes with Anaconda. If you want to use an external library, you may do so, but must justify your choice.\n",
    "- Make sure you use the data folder provided in the repository in read-only mode. (Or alternatively, be sure you don’t change any of the files.)\n",
    "- Be sure to provide a concise textual description of your thought process, the assumptions you made, the solution you implemented, and explanations for your answers. A notebook that only has code cells will not suffice. To avoid confusion: use short comments for longer code answers.\n",
    "- For questions containing the /Discuss:/ prefix, answer not with code, but with a textual explanation (in markdown).\n",
    "- Back up any hypotheses and claims with data, since this is an important aspect of the course.\n",
    "- Please write all your comments in English, and use meaningful variable names in your code. Your repo should have a single notebook (plus the required data files) in the master/main branch. If there are multiple notebooks present, we will not grade anything.\n",
    "- We will not run your notebook for you! Rather, we will grade it as is, which means that only the results contained in your evaluated code cells will be considered, and we will not see the results in unevaluated code cells. Thus, be sure to hand in a fully-run and evaluated notebook. In order to check whether everything looks as intended, you can check the rendered notebook on the GitHub website once you have pushed your solution there.\n",
    "- In continuation to the previous point, interactive plots, such as those generated using the ‘plotly’ package, should be strictly avoided! Make sure to print results and/or dataframes that confirm you have properly addressed the task.\n",
    "\n",
    "**A Note on using Language Models (LMs)**\n",
    "\n",
    "If you try hard enough, you will likely get away with cheating. Fortunately, our job is not to police, but rather to educate! So, please consider the following:\n",
    "- Presumably, you are taking this course to learn something! LMs are not always right ([they often fail in silly ways](https://community.openai.com/t/why-9-11-is-larger-than-9-9-incredible/869824/4)). This course should prepare you to detect when they are wrong!\n",
    "- Some of the TAs on this course literally published many works on detecting machine-generated text.\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4f85896e-c0ae-4ae3-af41-46149faa2278",
   "metadata": {},
   "source": [
    "## Context\n",
    "\n",
    "Context\n",
    "AI is booming! Newspapers, influencers, and your relatives all agree that AI is important. But while almost everyone agrees that AI is the future, much is unclear about what that future looks like…\n",
    "\n",
    "Freshly graduated from the EPFL, you are hired by the Swiss government to advise on a large-scale “AI integration” initiative code-named **\"NEUTRALITY\"** (Navigating Efficient Upgrades Through Robust Artificial Learning Integration Techniques Yearly). Convinced by the stunning progress in language modeling, the government would like to battle the growing shortages in the education sector by using LMs. Your job description: investigate which LMs might be best suited!\n",
    "\n",
    "You are given the results of three LMs on the [“Massive Multitask Language Understanding (MMLU)”](https://arxiv.org/abs/2009.03300) dataset to compare. This famous dataset consists of 57 subjects with multiple-choice questions, covering diverse subjects like mathematics, computer science, history, and law. Most providers of state-of-the-art LMs use this dataset to showcase the versatility of their latest models. Unfortunately, Horta-Ribeiro, the intern responsible for collecting the results, didn’t take EPFL’s famous ADA course. As a result, the collected datasets are slightly corrupted.\n",
    "\n",
    "### A very brief primer on Language Models\n",
    "Language models (LMs) are sophisticated statistical models designed to understand and generate human-like text. At their core, LMs are trained to predict the most likely continuation of a given input text. For example, given the input \"The cat sat on the,\" an LM might predict \"mat\" as a likely continuation.\n",
    "LMs are trained on vast text samples from various sources, including books, websites, and social media. This extensive training allows them to capture patterns and relationships in language, enabling them to generate coherent and contextually appropriate text across a wide range of topics and styles.\n",
    "\n",
    "While LMs can produce text that appears to be written by intelligent humans, it's important to note that their capabilities can diverge from human intelligence in unexpected ways. They may sometimes generate factually incorrect information or struggle with complex reasoning tasks.\n",
    "\n",
    "Two key concepts in understanding LMs are:\n",
    "1. **Tokens**: LMs process text using \"tokens\" rather than individual characters. Tokens can be words, parts of words, or punctuation marks. For example, the sentence \"I love AI!\" might be tokenized as [\"I\", \"love\", \"AI\", \"!\"]. Tokenization is the first step in both training and using an LM.\n",
    "2. **Context**: The input text provided to an LM is called the \"context.\" This context informs the model's predictions or generations. A longer or more specific context often leads to more accurate and relevant outputs.\n",
    "\n",
    "[See: Wikipedia entry on language models](https://en.wikipedia.org/wiki/Large_language_model)\n",
    "\n",
    "###  Files for this assignment\n",
    "This assignment is divided into three tasks, each of which should bring you a step closer to providing a recommendation toward project NEUTRALITY’s objectives:\n",
    "\n",
    "- **Task 1**: Inspecting the results and getting your first model ranking\n",
    "- **Task 2**: Inspecting the underlying data used to generate the results for possible biases\n",
    "- **Task 3**: Learning about tokens and providing a final recommendation\n",
    "\n",
    "\n",
    "```\n",
    "📁 PROJECT_NEUTRALITY\n",
    "│\n",
    "├── 📄 analysis.ipynb (the file you're currently reading!)\n",
    "├── 📄 requirements.txt (install into your environment)\n",
    "│\n",
    "├── 📁 task_1\n",
    "├── 📁 task_2\n",
    "└── 📁 task_2.5\n",
    "```   \n",
    " "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "95ce4c12-9681-401e-9489-aa0765b19d5d",
   "metadata": {},
   "outputs": [],
   "source": [
    "# please make sure you install the packages listed in the requirements.txt file in your environment!\n",
    "# using pip\n",
    "# pip install -r requirements.txt\n",
    "#\n",
    "# using Conda:\n",
    "# conda create --name <env_name> --file requirements.txt\n",
    "#\n",
    "# some basic imports\n",
    "import os\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import warnings\n",
    "from scipy.stats import ttest_ind"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e62594ad-4f5f-4a46-80bc-deacf66b62e9",
   "metadata": {},
   "source": [
    "## Task 1 (18 points): What's in an average anyway?\n",
    "\n",
    "The files needed to complete task 1 can be found in the folder \"`data/task_1/`:\n",
    "```\n",
    "task_1/\n",
    "│\n",
    "├── mmlu_data/\n",
    "│   └── test.csv\n",
    "│\n",
    "└── lm_scores/\n",
    "    ├── lm_X.csv\n",
    "    ├── lm_Y.csv\n",
    "    └── lm_Z.csv\n",
    "```\n",
    "\n",
    "We will start by loading, (manually) inspecting, and cleaning the data. Although it doesn't seem \"glamorous\" (nor is it particularly fun...) - manually inspecting data is extremely important! In fact, it's one of the few things most AI and Data Science researchers agree on :). Next, we will take a first pass on ordering our Olympic podium between three LMs."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f8605646-79fa-4cb3-8137-b6951bd1e064",
   "metadata": {},
   "source": [
    "### 1.1 (1 pt)\n",
    " \n",
    "Load the subfiles contained in the `mmlu_data` and `lm_scores` folders into separate dataframes:\n",
    "- `df_test`\n",
    "- `df_x`\n",
    "- `df_y`\n",
    "- `df_z`\n",
    "\n",
    "for each, print their sizes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "e6ce5e96-7de6-463d-a00b-6a4b2cfc8cb3",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_x = pd.read_csv('task_1/lm_scores/lm_X.csv')\n",
    "df_y = pd.read_csv('task_1/lm_scores/lm_Y.csv')\n",
    "df_z = pd.read_csv('task_1/lm_scores/lm_Z.csv')\n",
    "df_test = pd.read_csv('task_1/mmlu_data/test.csv')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "acbda57d-7df2-4e33-b31c-52bc0af6753e",
   "metadata": {},
   "source": [
    "### 1.2 (4 pt)\n",
    "Unfortunately, LMs don't always output the format we want. In the column `result`, the value should be one of A, B, C, or D. \n",
    "\n",
    "A. For each of the LM score dataframes, use a `value_counts()` operation and print the results. \n",
    "\n",
    "B. /Discuss:/ Inspect the results and describe the types of answer formats you see. Besides the \"expected\" case, you should be able to find at least four unexpected formats."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "79936f23",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Lm_X data:\n",
      "result\n",
      "A                                                                                    2733\n",
      "A                                                                                    1657\n",
      "B                                                                                    1412\n",
      "Answer: A                                                                            1398\n",
      "C                                                                                    1134\n",
      "                                                                                     ... \n",
      "(–3, 2), so the answer is C                                                             1\n",
      "sweet, so the answer is B                                                               1\n",
      "remembering how to tie a tie, so the answer is B                                        1\n",
      "anger, so the answer is A                                                               1\n",
      "creating insurmountable obstacles to the founding of factions, so the answer is A       1\n",
      "Name: count, Length: 145, dtype: int64\n",
      "----------------------------------------------------------------------------------------------------\n",
      "Lm_Y data:\n",
      "result\n",
      "D                                                                                                                 2894\n",
      "Answer: D                                                                                                         1718\n",
      "C                                                                                                                 1701\n",
      "B                                                                                                                 1240\n",
      "D                                                                                                                 1145\n",
      "                                                                                                                  ... \n",
      "4, so the answer is D                                                                                                1\n",
      "FindName ([\"Andrea\", \"Ben\", \"Chris\"], \"Ben\"), so the answer is C                                                     1\n",
      "had some degree of a nonaggression agreement since at least 1926, so the answer is A                                 1\n",
      "women held considerable power and responsibility within the domestic sphere of social life, so the answer is C       1\n",
      "ADP + P → ATP, so the answer is D                                                                                    1\n",
      "Name: count, Length: 141, dtype: int64\n",
      "----------------------------------------------------------------------------------------------------\n",
      "Lm_Z data:\n",
      "result\n",
      "D                                                                                       2257\n",
      "C                                                                                       2191\n",
      "B                                                                                       2127\n",
      "A                                                                                       2060\n",
      "Answer: D                                                                                777\n",
      "                                                                                        ... \n",
      "III and IV only, so the answer is D                                                        1\n",
      "have a positive value of equal magnitude on its capital account., so the answer is B       1\n",
      "a recession., so the answer is A                                                           1\n",
      "decreasing SRAS with constant AD., so the answer is B                                      1\n",
      "Voting participation for racial minority voters has increased., so the answer is C         1\n",
      "Name: count, Length: 560, dtype: int64\n",
      "----------------------------------------------------------------------------------------------------\n"
     ]
    }
   ],
   "source": [
    "# A\n",
    "\n",
    "print('Lm_X data:')\n",
    "print(df_x.result.value_counts())\n",
    "print('-'*100)\n",
    "\n",
    "print('Lm_Y data:')\n",
    "print(df_y.result.value_counts())\n",
    "print('-'*100)\n",
    "\n",
    "print('Lm_Z data:')\n",
    "print(df_z.result.value_counts())\n",
    "print('-'*100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "620f46cc",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Index(['A', 'A ', 'B', 'Answer: A', 'C', 'D', 'B ', 'Answer: B', 'C ',\n",
       "       'Answer: D', 'D ', 'Answer: C', 'Not Sure', 'None of the above',\n",
       "       'Wrong, Wrong, so the answer is A'],\n",
       "      dtype='object', name='result')"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# B\n",
    "\n",
    "#\"Answer: A/B/C/D\"\n",
    "#\"...., so the answer is A/B/C/D\"\n",
    "# \"A\" vs \"A \" with the space at the end\n",
    "# \"Not Sure\"\n",
    "# \"None of the above\"\n",
    "\n",
    "df_x.result.value_counts().index[:15]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "88c5551d-1968-427b-bdd6-51d996898e7c",
   "metadata": {},
   "source": [
    "### 1.3 (5 pt)\n",
    "Oh oh... That doesn't look great. Simply dropping all invalid answers seems overly wasteful, yet fixing all of these looks like a mess! Instead, let's focus for now on fixing just those answers of length < 10 characters that require only a single `str.replace()` operation. \n",
    "\n",
    "For example, if the answer looks like `--A--`, we could fix this by using the following simple function:\n",
    "\n",
    "```\n",
    "def clean_answer(s, pattern='-'):\n",
    "    return str(s).replace(pattern, '')\n",
    "\n",
    "dirty_answer = '--A--'\n",
    "clean_answer = clean_answer(dirty_answer)\n",
    "```\n",
    "\n",
    "A. Filter the three score dataframes to include only answers with less than 10 characters. Make a deep copy of the dataframes as you filter them.\n",
    "\n",
    "B. Modify the `clean_answer()` example function to clean the answers in the filtered data frames using the `apply()` functionality. Finally, make sure **all remaining answers are one of `A, B, C, or D`.**\n",
    "\n",
    "C. /Discuss:/ Compare the sizes of the original and filtered data frames. What do you see? Why might this be a problem?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "aef1f933-20bf-426a-ac9d-a35e273b9bd2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Before cleaning:\n",
      "result\n",
      "A            2733\n",
      "A            1657\n",
      "B            1412\n",
      "Answer: A    1398\n",
      "C            1134\n",
      "D            1124\n",
      "B             793\n",
      "Answer: B     760\n",
      "C             622\n",
      "Answer: D     613\n",
      "D             596\n",
      "Answer: C     594\n",
      "Not Sure       73\n",
      "Name: count, dtype: int64\n",
      "----------------------------------------------------------------------------------------------------\n",
      "After cleaning:\n",
      "result\n",
      "A            2733\n",
      "A            1657\n",
      "B            1412\n",
      "Answer: A    1398\n",
      "C            1134\n",
      "D            1124\n",
      "B             793\n",
      "Answer: B     760\n",
      "C             622\n",
      "Answer: D     613\n",
      "D             596\n",
      "Answer: C     594\n",
      "Name: count, dtype: int64\n"
     ]
    }
   ],
   "source": [
    "# A\n",
    "df_x_10 = df_x[df_x.result.str.len() < 10]\n",
    "df_y_10 = df_y[df_y.result.str.len() < 10]\n",
    "df_z_10 = df_z[df_z.result.str.len() < 10]\n",
    "\n",
    "print('Before cleaning:')\n",
    "print(df_x_10.result.value_counts())\n",
    "print('-'*100)\n",
    "\n",
    "#Since the data is not clean, we need to clean it first\n",
    "# We will remove the \"Not Sure\" answer instead of assigning random values to it. This is feasible because the number of \"Not Sure\" answers is very low.\n",
    "\n",
    "df_x_10 = df_x_10[df_x_10.result != 'Not Sure']\n",
    "df_y_10 = df_y_10[df_y_10.result != 'Not Sure']\n",
    "df_z_10 = df_z_10[df_z_10.result != 'Not Sure']\n",
    "\n",
    "print('After cleaning:')\n",
    "print(df_x_10.result.value_counts())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "fd54f296",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Before cleaning:\n",
      "x: 13882 y: 13978 z: 13923\n",
      "After cleaning:\n",
      "x: 13436 y: 13551 z: 12753\n"
     ]
    }
   ],
   "source": [
    "# B\n",
    "def clean_answer1(s, pattern=' '):\n",
    "    #Remove any white spaces in the string\n",
    "    return str(s).replace(pattern, '')\n",
    "\n",
    "def clean_answer2(s, pattern=':'):\n",
    "    #Remove any white spaces in the string\n",
    "    s = str(s).split(pattern)\n",
    "    return s[-1]\n",
    "\n",
    "df_x_10['result'] = df_x_10['result'].apply(clean_answer1)\n",
    "df_x_10['result'] = df_x_10['result'].apply(clean_answer2)\n",
    "df_y_10['result'] = df_y_10['result'].apply(clean_answer1)\n",
    "df_y_10['result'] = df_y_10['result'].apply(clean_answer2)\n",
    "df_z_10['result'] = df_z_10['result'].apply(clean_answer1)\n",
    "df_z_10['result'] = df_z_10['result'].apply(clean_answer2)\n",
    "\n",
    "print('Before cleaning:')\n",
    "print('x:',len(df_x), 'y:', len(df_y), 'z:',len(df_z))\n",
    "print('After cleaning:')\n",
    "print('x:',len(df_x_10), 'y:', len(df_y_10), 'z:', len(df_z_10))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2415cd9b",
   "metadata": {},
   "source": [
    "C. /Discuss:/\n",
    "\n",
    "For the LM Z dataset, we observe that we had to drop 1170 datapoints, which is 8.8% of the dataset. This is a significant amount of data, especially since the data we dropped had an explanation for the answer that was given. This is crucial for Language Model tasks, as we are often looking to find explanations for the answer rather than just the answer. This lost data could be extracted by using better data pre-processing techniques, where we extracted the answers from the textual explanations given.\n",
    "\n",
    "Moreover, completely ignoring \"Not Sure\" and \"None of the above\" might compromise the actual evaluation of the models as we are not taking into account effectively \"wrong\" answers."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "da1cf129-09dd-47b1-9737-2c4d57eb8853",
   "metadata": {},
   "source": [
    "### 1.4 (3 pt)\n",
    "\n",
    "Now that our answer columns are nicely formatted, let's take a look at model performance:\n",
    "\n",
    "A. Both the `MMLU` dataframes and the language model score data frames have the columns `question_id`. For each of the language model score data frames, use an inner join operation with the `df_test` dataframe on the `question_id` column.\n",
    "\n",
    "B. Add a new column to each of the resulting dataframes called `correct`, that checks if the model's answer in `result` is the same as the expected answer in the column `answer`. Then, print the average score of each model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "e66b36f3-f5a4-4237-9b48-39b21716d7aa",
   "metadata": {},
   "outputs": [],
   "source": [
    "# A\n",
    "df_x_join = pd.merge(df_x_10, df_test, on='question_id', how='inner', suffixes=('_df_x', '_df_test'))\n",
    "df_y_join = pd.merge(df_y_10, df_test, on='question_id', how='inner', suffixes=('_df_y', '_df_test'))\n",
    "df_z_join = pd.merge(df_z_10, df_test, on='question_id', how='inner', suffixes=('_df_z', '_df_test'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "50b024d2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Average Score for LM X: 76.75 %\n",
      "Average Score for LM Y: 74.58 %\n",
      "Average Score for LM Z: 66.33 %\n"
     ]
    }
   ],
   "source": [
    "# B\n",
    "df_x_join['correct'] = df_x_join['result'] == df_x_join['answer']\n",
    "df_y_join['correct'] = df_y_join['result'] == df_y_join['answer']\n",
    "df_z_join['correct'] = df_z_join['result'] == df_z_join['answer']\n",
    "\n",
    "print('Average Score for LM X:', 100*df_x_join.correct.mean().__round__(4), '%')\n",
    "print('Average Score for LM Y:', 100*df_y_join.correct.mean().__round__(4), '%')\n",
    "print('Average Score for LM Z:', 100*df_z_join.correct.mean().__round__(4), '%')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "69decfd8-8083-4c2f-8263-a153d55efede",
   "metadata": {},
   "source": [
    "### 1.5 (5 pt)\n",
    "\n",
    "Hmmm, something doesn't seem quite right. Let's investigate how \"balanced\" this dataset is:\n",
    "\n",
    "A. For each of the 57 subjects in the MMLU, compare the number of questions answered by each model. Print the subjects for which there is a more than 10% difference.\n",
    "\n",
    "B. Propose and implement a reasonable way to rebalance the results. (e.g., while throwing away 100% of the results perfectly rebalances the results, it is not reasonable).\n",
    "\n",
    "C. Finally, print the updated accuracy on the rebalanced data.\n",
    "\n",
    "**hint:**:\n",
    "- (A) For a given subject, let model X and model Y have answered 181 and 200 questions respectively. You can consider this a 10% difference from the perspective of X since: (200 - 181) / 181 > 0.10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "19463002-732b-405b-8b44-77f702bdb665",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "subject                  \tM1_X \tM1_Y \tM1_Z \n",
      "college chemistry        \t   96\t   98\t   84\n",
      "college computer science \t   97\t   98\t   84\n",
      "computer security        \t   95\t   98\t   87\n",
      "formal logic             \t  109\t  123\t  113\n",
      "high school geography    \t  195\t  193\t  176\n",
      "logical fallacies        \t  154\t  136\t  147\n",
      "medical genetics         \t   97\t   98\t   89\n",
      "moral disputes           \t  329\t  304\t  250\n",
      "moral scenarios          \t  737\t  865\t  774\n"
     ]
    }
   ],
   "source": [
    "# A\n",
    "print(\"{:25s}\\t{:5s}\\t{:5s}\\t{:5s}\".format(\"subject\", \"M1_X\", \"M1_Y\", \"M1_Z\"))\n",
    "\n",
    "for subject in df_x_join.subject.unique():\n",
    "    filter_x = len(df_x_join[df_x_join.subject == subject])\n",
    "    filter_y = len(df_y_join[df_y_join.subject == subject])\n",
    "    filter_z = len(df_z_join[df_z_join.subject == subject])\n",
    "\n",
    "    if abs(filter_x - filter_y) > 0.1 * filter_x or abs(filter_x - filter_y) > 0.1 * filter_y or abs(filter_x - filter_z) > 0.1 * filter_x or abs(filter_x - filter_z) > 0.1 * filter_z or abs(filter_y - filter_z) > 0.1 * filter_y or abs(filter_y - filter_z) > 0.1 * filter_z:\n",
    "        print(\"{:25s}\\t{:5d}\\t{:5d}\\t{:5d}\".format(subject, filter_x, filter_y, filter_z))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "2fb8c324",
   "metadata": {},
   "outputs": [],
   "source": [
    "# B\n",
    "\n",
    "# For each subject which is imbalanced, we will take the minimum answered questions\n",
    "# and sample a random number of questions from the other 2 such that it does not cross 10% of the minimum answered questions. \n",
    "\n",
    "import numpy as np\n",
    "\n",
    "for subject in df_x_join.subject.unique():\n",
    "    filter_x = len(df_x_join[df_x_join.subject == subject])\n",
    "    filter_y = len(df_y_join[df_y_join.subject == subject])\n",
    "    filter_z = len(df_z_join[df_z_join.subject == subject])\n",
    "\n",
    "    if abs(filter_x - filter_y) > 0.1 * filter_x or abs(filter_x - filter_y) > 0.1 * filter_y or abs(filter_x - filter_z) > 0.1 * filter_x or abs(filter_x - filter_z) > 0.1 * filter_z or abs(filter_y - filter_z) > 0.1 * filter_y or abs(filter_y - filter_z) > 0.1 * filter_z:\n",
    "        min_filter = min(filter_x, filter_y, filter_z)\n",
    "        #max_filter = int(1.1 * min_filter)\n",
    "        #new_x = df_x_join[df_x_join.subject == subject].sample(np.random.randint(min_filter, 1 + min(max_filter, filter_x)), replace=False)\n",
    "        #new_y = df_y_join[df_y_join.subject == subject].sample(np.random.randint(min_filter, 1 + min(max_filter, filter_y)), replace=False)\n",
    "        #new_z = df_z_join[df_z_join.subject == subject].sample(np.random.randint(min_filter, 1 + min(max_filter, filter_z)), replace=False)  \n",
    "        new_x = df_x_join[df_x_join.subject == subject].sample(min_filter, replace=False)\n",
    "        new_y = df_y_join[df_y_join.subject == subject].sample(min_filter, replace=False)\n",
    "        new_z = df_z_join[df_z_join.subject == subject].sample(min_filter, replace=False)      \n",
    "        df_x_join = pd.concat([df_x_join[df_x_join.subject != subject], new_x])\n",
    "        df_y_join = pd.concat([df_y_join[df_y_join.subject != subject], new_y])\n",
    "        df_z_join = pd.concat([df_z_join[df_z_join.subject != subject], new_z])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "affc3746",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Average Score for LM X: 76.685 %\n",
      "Average Score for LM Y: 74.64 %\n",
      "Average Score for LM Z: 66.29 %\n"
     ]
    }
   ],
   "source": [
    "# C\n",
    "\n",
    "df_x_join['correct'] = df_x_join['result'] == df_x_join['answer']\n",
    "df_y_join['correct'] = df_y_join['result'] == df_y_join['answer']\n",
    "df_z_join['correct'] = df_z_join['result'] == df_z_join['answer']\n",
    "\n",
    "print('Average Score for LM X:', 100*df_x_join.correct.mean().__round__(5), '%')\n",
    "print('Average Score for LM Y:', 100*df_y_join.correct.mean().__round__(4), '%')\n",
    "print('Average Score for LM Z:', 100*df_z_join.correct.mean().__round__(4), '%')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "292b2f61-0529-4b6d-a3a7-af786a4d79ae",
   "metadata": {},
   "source": [
    "## Task 2 (26 points): What do you mean A > D > B > C...?\n",
    "\n",
    "Nice work! Having successfully inspected, cleaned, and rebalanced the provided data, you head over to director of the government's NEUTRALITY project. Ms. Sakota is happy with your work so far, but worried that the sloppy intern might have done more undetected damage. To be sure, she orders a new set of evaluations of all models on both MMLU and another dataset.\n",
    "\n",
    "After cleaning up and rebalancing, you are left with the concatenated score files in the second folder `task_2`:\n",
    "```\n",
    "task_2/\n",
    "│\n",
    "└── lm_scores_mmlu.csv\n",
    "│\n",
    "└── lm_scores_other.csv\n",
    "```\n",
    "\n",
    "Each has a new column called `model_name`, which is one of `X, Y` or `Z`.\n",
    "\n",
    "\n",
    "\n",
    "_NOTE: **only** use data from `task_2` and `task_2_5` for this assignment! The values in `lm_scores_mmlu.csv` will NOT be the same as the dataframes you finished in task 1. This is due to \"randomness\" or \"temperature\" in language model inference. This can slightly shift around generative results. (Conveniently: it also ensures any mistakes made in Task 1 don't propogate further ;) )_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "a889a76b-e034-4d2f-929e-0ef1f250a0a0",
   "metadata": {},
   "outputs": [],
   "source": [
    "# PROVIDED CODE\n",
    "df_mmlu = pd.read_csv('task_2/lm_scores_mmlu.csv')\n",
    "df_other = pd.read_csv('task_2/lm_scores_other.csv')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c31edde3-cc91-4d08-81c7-b5e98cf0ff9c",
   "metadata": {},
   "source": [
    "### 2.1 (4 pt)\n",
    "\n",
    "Let's explore the new results:\n",
    "\n",
    "A. Compute the mean accuracy and standard errors of each model on both datasets and print the results.\n",
    "\n",
    "B. Then, show your results in a bar plot using standard errors with a 95% confidence interval around the mean. Make sure the plot is easy to read and well annotated.\n",
    "\n",
    "C. /Discuss:/ the plot you created: (i) can you say that one of the models is the best? (ii) is there anything that seems odd?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "56fe8cca-acd1-4f5e-a938-e8d3a850f220",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MMLU\n",
      "Accuracy x = 0.74\t||\tstd_error = 0.00404\n",
      "Accuracy y = 0.76\t||\tstd_error = 0.00394\n",
      "Accuracy z = 0.66\t||\tstd_error = 0.00439\n",
      "\n",
      "Other\n",
      "Accuracy x = 0.79\t||\tstd_error = 0.00667\n",
      "Accuracy y = 0.72\t||\tstd_error = 0.00732\n",
      "Accuracy z = 0.67\t||\tstd_error = 0.00766\n",
      "\n"
     ]
    }
   ],
   "source": [
    "def accuracy(df):\n",
    "    return df[df.correct == True].correct.size / df.correct.size \n",
    "\n",
    "def std_error(df):\n",
    "    n = df.shape[0]\n",
    "    return np.std(df.correct) / np.sqrt(n)\n",
    "\n",
    "mmlu_x = df_mmlu[df_mmlu.model_name == 'X']\n",
    "mmlu_y = df_mmlu[df_mmlu.model_name == 'Y']\n",
    "mmlu_z = df_mmlu[df_mmlu.model_name == 'Z']\n",
    "\n",
    "other_x = df_other[df_other.model_name == 'X']\n",
    "other_y = df_other[df_other.model_name == 'Y']\n",
    "other_z = df_other[df_other.model_name == 'Z']\n",
    "\n",
    "print(\"MMLU\\nAccuracy x = {:.2f}\\t||\\tstd_error = {:.5f}\\nAccuracy y = {:.2f}\\t||\\tstd_error = {:.5f}\\nAccuracy z = {:.2f}\\t||\\tstd_error = {:.5f}\\n\".format(accuracy(mmlu_x), std_error(mmlu_x), accuracy(mmlu_y), std_error(mmlu_y), accuracy(mmlu_z), std_error(mmlu_z)))\n",
    "print(\"Other\\nAccuracy x = {:.2f}\\t||\\tstd_error = {:.5f}\\nAccuracy y = {:.2f}\\t||\\tstd_error = {:.5f}\\nAccuracy z = {:.2f}\\t||\\tstd_error = {:.5f}\\n\".format(accuracy(other_x), std_error(other_x), accuracy(other_y), std_error(other_y), accuracy(other_z), std_error(other_z)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "d3a176c6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.5, 0.85)"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x500 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# B\n",
    "\n",
    "mmlu_mean_x = df_mmlu[df_mmlu['model_name'] == 'X'].correct.mean()\n",
    "mmlu_mean_y = df_mmlu[df_mmlu['model_name'] == 'Y'].correct.mean()\n",
    "mmlu_mean_z = df_mmlu[df_mmlu['model_name'] == 'Z'].correct.mean()\n",
    "means_mmlu = [mmlu_mean_x, mmlu_mean_y, mmlu_mean_z]\n",
    "std_mmlu_x = df_mmlu[df_mmlu['model_name'] == 'X'].correct.std()\n",
    "std_mmlu_y = df_mmlu[df_mmlu['model_name'] == 'Y'].correct.std()\n",
    "std_mmlu_z = df_mmlu[df_mmlu['model_name'] == 'Z'].correct.std()\n",
    "std_mmlu = [std_mmlu_x, std_mmlu_y, std_mmlu_z]\n",
    "ci_mmlu_x = 1.96 * std_mmlu_x / np.sqrt(len(df_mmlu[df_mmlu['model_name'] == 'X']))\n",
    "ci_mmlu_y = 1.96 * std_mmlu_y / np.sqrt(len(df_mmlu[df_mmlu['model_name'] == 'Y']))\n",
    "ci_mmlu_z = 1.96 * std_mmlu_z / np.sqrt(len(df_mmlu[df_mmlu['model_name'] == 'Z']))\n",
    "ci_mmlu = [ci_mmlu_x, ci_mmlu_y, ci_mmlu_z]\n",
    "\n",
    "other_mean_x = df_other[df_other['model_name'] == 'X'].correct.mean()\n",
    "other_mean_y = df_other[df_other['model_name'] == 'Y'].correct.mean()\n",
    "other_mean_z = df_other[df_other['model_name'] == 'Z'].correct.mean()\n",
    "means_other = [other_mean_x, other_mean_y, other_mean_z]\n",
    "std_other_x = df_other[df_other['model_name'] == 'X'].correct.std()\n",
    "std_other_y = df_other[df_other['model_name'] == 'Y'].correct.std()\n",
    "std_other_z = df_other[df_other['model_name'] == 'Z'].correct.std()\n",
    "std_other = [std_other_x, std_other_y, std_other_z]\n",
    "ci_other_x = 1.96 * std_other_x / np.sqrt(len(df_other[df_other['model_name'] == 'X']))\n",
    "ci_other_y = 1.96 * std_other_y / np.sqrt(len(df_other[df_other['model_name'] == 'Y']))\n",
    "ci_other_z = 1.96 * std_other_z / np.sqrt(len(df_other[df_other['model_name'] == 'Z']))\n",
    "ci_other = [ci_other_x, ci_other_y, ci_other_z]\n",
    "\n",
    "# Plots\n",
    "fig, ax = plt.subplots(1, 2, figsize=(10, 5),sharey=True, sharex=True)\n",
    "fig.suptitle('Model-wise Accuracy in MMLU data with their 95% Confidence Intervals')\n",
    "\n",
    "ax[0].bar([1,2,3], means_mmlu, yerr=ci_mmlu, align='center', alpha=0.5)\n",
    "ax[0].set_xticks([1,2,3])\n",
    "ax[0].set_xticklabels(['Model X','Model Y','Model Z'])\n",
    "ax[0].set_ylim(0.5, 0.85)\n",
    "ax[0].set_ylabel('Mean Accuracy')\n",
    "\n",
    "ax[1].bar([1,2,3], means_other, yerr=ci_other, align='center', alpha=0.5, color='orange')\n",
    "ax[1].set_ylim(0.5, 0.85)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "65c9fbfe",
   "metadata": {},
   "source": [
    "C. /Discuss:/ \n",
    "\n",
    "We can confidently say that Models X and Y are better than Model Z. This is because the upper bound of the 95% confidence interval of model Z never crosses the 95% CI lower bound of either Models X and Y, thus mean that Model Z is statistically worse than the other two models. Between Models X and Y, we can not claim which of the two is better, because they have different relative performances on the two datasets as shown in the graphs."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eee0ec62-f2d1-4bae-a6f6-221320d602cb",
   "metadata": {},
   "source": [
    "### 2.2 (5 pt)\n",
    "\n",
    "Ms. Sakota has assured you that both datasets contain questions of similar difficulty, so, what could be going on here?\n",
    "\n",
    "A. What is the distribution of correct answers (A, B, C, D) for each dataset? Create a bar chart to visualize this.\n",
    "\n",
    "B. Perform a chi-square test at $\\alpha = 0.05$, of independence to determine if there's a significant difference in the distribution of correct answers between the two datasets. What do you conclude?\n",
    "\n",
    "**hints**:\n",
    "- for (A), keep in mind that df_mmlu and df_other contain the results of all models, i.e., the `question_id` column is duplicated.\n",
    "- for (A), take care to clearly annotate the bar chart, e.g., title, y-label, legend.\n",
    "- for (B), clearly state the null hypothesis and alternative hypothesis\n",
    "- use the `chi2_contingency` function from `scipy.stats`\n",
    "- format your results from answer (A) as a 2D array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "30b16f70-93e0-4a19-8a6d-b3ae5a75ae65",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "        MMLU Data  Other Data\n",
      "answer                       \n",
      "D            3739         641\n",
      "C            3403         924\n",
      "B            2943        1116\n",
      "A            1611        1078\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA1sAAAIhCAYAAAC48qAWAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAABtMklEQVR4nO3de3zP9f//8fvbzpvtbTM7ZWYOCXMoiqmcGYVEUVhE1Ido4VOpT06fonSij0iFRQoVcqgxRGnOtXJYkhyzsZjNYYbt9fvDb++vt21stpd5c7teLu/Lxfv1er5fr8dr7/fzbfc9X6/ny2IYhiEAAAAAQIkqU9oFAAAAAMDNiLAFAAAAACYgbAEAAACACQhbAAAAAGACwhYAAAAAmICwBQAAAAAmIGwBAAAAgAkIWwAAAABgAsIWAAAAAJiAsAXcQGJjY2WxWGwPd3d3BQUFqUWLFho/fryOHj2a5zWjR4+WxWIp0n7OnDmj0aNHa82aNUV6XX77qly5sjp06FCk7VzN559/rokTJ+a7zmKxaPTo0SW6v5K2atUqNWzYUF5eXrJYLFq0aNEV2x85ckQvvfSS6tSpo7Jly8rd3V3Vq1fXc889p927d1+fokvYuHHjrnrc+fnnn3/k5uYmi8WiLVu2lHxhN4E+ffqocuXKJba9ffv22b5zCupbffv2tbW5VPPmzWWxWFSlShUZhpHndT/88IPtdbGxsbblud91Bb3HuTW9/fbb+a5/++23ZbFYtG/fvkId4/VQuXJl9enTp1Btjx07phEjRqhWrVry9PSUj4+PGjdurA8++EDnz5+3a3ul7+vc7+R//vmnBI7g2uTWkPvw9PRUxYoVFRUVpf/97386efLkNW87ISFBo0eP1okTJ0quYOA6I2wBN6CZM2dq/fr1io+P1wcffKD69evrzTffVM2aNbVy5Uq7tk899ZTWr19fpO2fOXNGY8aMKXLYupZ9XYsrha3169frqaeeMr2Ga2UYhrp16yYXFxctXrxY69evV7NmzQpsv2nTJtWpU0fTp0/XI488ogULFiguLk7Dhw/Xzz//rHvuuec6Vl9yrjVszZ49W+fOnZMkTZ8+vYSrujm8+uqrWrhwYYlv19vbW7GxscrJybFbfurUKX355Zfy8fEp8HV79+7V6tWr86ybMWNGga+7Vf3++++68847NW3aNPXs2VPLli3T3Llzddddd+m5555TmzZtdObMGVv7a/2+vt7i4uK0fv16xcXF6e2331alSpX0wgsvqHbt2vr111+vaZsJCQkaM2YMYQsOzbm0CwCQV0REhBo2bGh73rVrVz3//PO677771KVLF+3evVuBgYGSpIoVK6pixYqm1nPmzBnbXyvN3tfVNG7cuFT3fzWHDx/W8ePH9fDDD6tVq1ZXbJuRkaGHHnpI7u7uSkhIsPvZNm/eXE8//bS++uqrEqkr9z3MT2Zmpjw8PEpkP8U1Y8YMBQQEKCwsTF988YXefffdG6a2knKl96IwqlatWoLV/J/u3bvrk08+0apVq9SmTRvb8nnz5ik7O1udO3fWZ599lud1lSpVkre3t2bMmGH3mT958qS+/PJL9ezZUx9//LEpNTua7Oxsde3aVRkZGdq0aZNuv/1227oHHnhAzZo102OPPaahQ4fqww8/LMVK7RXmM9ugQQP5+/vbnj/22GN69tln1axZM3Xq1El//PGH3NzczC4VuOEwsgU4iEqVKumdd97RyZMnNW3aNNvy/E7tW716tZo3b67y5cvLw8NDlSpVUteuXXXmzBnt27dPFSpUkCSNGTPGdupH7ukvudv7+eef9cgjj8jX19f2y92VTllcuHCh6tatK3d3d1WpUkXvv/++3frc04YuP+1nzZo1slgstr/aNm/eXMuWLdP+/fvtTk3Jld+pTtu3b9dDDz0kX19fubu7q379+vr000/z3c8XX3yhV155RSEhIfLx8VHr1q21a9eugn/wl1i3bp1atWolb29veXp6qkmTJlq2bJlt/ejRo22B6cUXX5TFYrni6V4ff/yxUlJSNGHChAJD7COPPGL3fPHixYqMjJSnp6e8vb3Vpk2bPKONV3oPc0/7XLBgge688065u7trzJgxkqSUlBQ9/fTTqlixolxdXRUeHq4xY8bowoULdtvPysrS2LFjVbNmTbm7u6t8+fJq0aKFEhISJF18j06fPq1PP/3U9v41b978qj/fjRs3avv27YqOjlb//v2Vnp6ur7/+Ok+75s2bKyIiQps3b9b9998vT09PValSRW+88YbdqExOTo5ee+011ahRQx4eHipXrpzq1q2rSZMmSZJ27Nghi8WiL7/80vaarVu3ymKxqHbt2nb77NSpkxo0aGC3bN68eYqMjJSXl5fKli2rqKgo/fLLL3Zt+vTpo7Jly2rbtm1q27atvL29bYHkl19+UYcOHRQQECA3NzeFhITowQcf1KFDh674c8rvNEKLxaJnn31Ws2fPVs2aNeXp6al69epp6dKlV9zWpWrUqKEmTZpoxowZdstnzJihLl26yGq1Fvjavn37asGCBXYjEHPnzpV08Zfu0rJlyxY99thjqly5sjw8PFS5cmU9/vjj2r9/v1273O+n77//Xv/617/k7++v8uXLq0uXLjp8+LBd2/Pnz+uFF15QUFCQPD09dd9992nTpk2FqmfhwoXauXOnXnrpJbuglat79+5q27atpk+frpSUlKt+X+c6cuSIHn/8cVmtVgUGBqpv375KT0+3a2MYhqZMmaL69evLw8NDvr6+euSRR/TXX3/ZtcvtXz/88IOaNGkiT09P9e3bt1DHd7l69erplVde0YEDBzRv3jzb8vj4eD300EOqWLGi3N3dVa1aNT399NN2p0OOHj1a//73vyVJ4eHhtmPP/b9i3rx5atu2rYKDg+Xh4aGaNWvqpZde0unTp6+pVsAshC3AgTzwwANycnLSDz/8UGCbffv26cEHH5Srq6tmzJihuLg4vfHGG/Ly8tK5c+cUHBysuLg4SVK/fv20fv16rV+/Xq+++qrddrp06aJq1arpyy+/vOpfWBMTExUTE6Pnn39eCxcuVJMmTfTcc88VeL3FlUyZMkX33nuvgoKCbLVd6dTFXbt2qUmTJtqxY4fef/99LViwQLVq1VKfPn00YcKEPO1ffvll7d+/X5988ok++ugj7d69Wx07dlR2dvYV61q7dq1atmyp9PR0TZ8+XV988YW8vb3VsWNH2y8RTz31lBYsWCBJGjx4sNavX3/F071WrFghJycndezYsTA/Gn3++ed66KGH5OPjoy+++ELTp09XWlqamjdvrnXr1uVpX9B7+PPPP+vf//63hgwZori4OHXt2lUpKSm65557tHz5co0cOVLfffed+vXrp/Hjx6t///621164cEHt27fXf//7X3Xo0EELFy5UbGysmjRpogMHDki6eKqnh4eHHnjgAdv7N2XKlKseX+5pg3379tVjjz0mT0/PAk8lTElJUc+ePdWrVy8tXrxY7du314gRI+xGXiZMmKDRo0fr8ccf17JlyzRv3jz169fPFghq166t4OBgu1NzV65cKQ8PD+3cudP2S/aFCxe0du1atW7d2tZu3Lhxevzxx1WrVi3Nnz9fs2fP1smTJ3X//fdr586ddrWeO3dOnTp1UsuWLfXNN99ozJgxOn36tNq0aaMjR47ogw8+UHx8vCZOnKhKlSpd8zUuy5Yt0+TJkzV27Fh9/fXX8vPz08MPP5znl+kr6devnxYtWqS0tDRJF/tXQkKC+vXrd8XXPfbYY3JyctIXX3xhW5Z7amxpnka4b98+1ahRQxMnTtTy5cv15ptvKjk5WXfffXe+1zk99dRTcnFx0eeff64JEyZozZo16tWrl12b/v376+2339YTTzyhb775Rl27dlWXLl1sP7MriY+PlyR17ty5wDadO3fWhQsXtGbNmkJ/X3ft2lW33367vv76a7300kv6/PPP9fzzz9u1efrppxUTE6PWrVtr0aJFmjJlinbs2KEmTZroyJEjdm2Tk5PVq1cv9ejRQ99++60GDhx41WMrSKdOnSTJ7v+tPXv2KDIyUlOnTtWKFSs0cuRIbdy4Uffdd5/tmrWnnnpKgwcPliQtWLDAdux33XWXJGn37t164IEHNH36dMXFxSkmJkbz588v9PcpcN0YAG4YM2fONCQZmzdvLrBNYGCgUbNmTdvzUaNGGZd25a+++sqQZCQmJha4jdTUVEOSMWrUqDzrcrc3cuTIAtddKiwszLBYLHn216ZNG8PHx8c4ffq03bHt3bvXrt33339vSDK+//5727IHH3zQCAsLy7f2y+t+7LHHDDc3N+PAgQN27dq3b294enoaJ06csNvPAw88YNdu/vz5hiRj/fr1+e4vV+PGjY2AgADj5MmTtmUXLlwwIiIijIoVKxo5OTmGYRjG3r17DUnGW2+9dcXtGYZh3HHHHUZQUNBV2xmGYWRnZxshISFGnTp1jOzsbNvykydPGgEBAUaTJk1sy670HoaFhRlOTk7Grl277JY//fTTRtmyZY39+/fbLX/77bcNScaOHTsMwzCMWbNmGZKMjz/++Ir1enl5Gb179y7UsRmGYZw+fdrw8fExGjdubFvWu3dvw2KxGH/++add22bNmhmSjI0bN9otr1WrlhEVFWV73qFDB6N+/fpX3G+vXr2MKlWq2J63bt3a6N+/v+Hr62t8+umnhmEYxk8//WRIMlasWGEYhmEcOHDAcHZ2NgYPHmy3rZMnTxpBQUFGt27d7I5BkjFjxgy7tlu2bDEkGYsWLbpiffnp3bt3nv4hyQgMDDQyMjJsy1JSUowyZcoY48ePv+L2Lv3Mnjx50ihbtqwxefJkwzAM49///rcRHh5u5OTkGIMGDcrT/5s1a2bUrl3bVlfDhg0NwzCMHTt2GJKMNWvWGJs3bzYkGTNnzrS97mrfdVfrR2+99Va+3ydXc+HCBePUqVOGl5eXMWnSpDz1DBw40K79hAkTDElGcnKyYRiGkZSUZEgynn/+ebt2c+bMMSRd9TPfrl07Q5Jx9uzZAtt89913hiTjzTffNAyjcN/XEyZMsFs+cOBAw93d3fa9tH79ekOS8c4779i1O3jwoOHh4WG88MILtmW5/WvVqlVXPJbLa0hNTc13fWZmpiHJaN++fb7rc3JyjPPnzxv79+83JBnffPONbV1h3+fcbaxdu9aQZPz666+Fqh24HhjZAhyMkc+MX5eqX7++XF1dNWDAAH366adF+qv2pbp27VrotrVr11a9evXslvXo0UMZGRn6+eefr2n/hbV69Wq1atVKoaGhdsv79OmjM2fO5BkVy/0ra666detKUp7Tii51+vRpbdy4UY888ojKli1rW+7k5KTo6GgdOnSo0KciXqtdu3bp8OHDio6OVpky//fVXbZsWXXt2lUbNmywu6heKvg9rFu3bp5TmJYuXaoWLVooJCREFy5csD3at28v6eLIniR99913cnd3v+bTigoyf/58ZWRk2G23b9++MgxDM2fOzNM+KCgoz+QhdevWtXsf77nnHv36668aOHCgli9froyMjDzbadWqlf766y/t3btXZ8+e1bp169SuXTu1aNHCNgqxcuVKubm56b777pMkLV++XBcuXNATTzxh97Nyd3dXs2bN8p3I4PL3olq1avL19dWLL76oDz/8MM9o2LVo0aKFvL29bc8DAwMVEBBwxc/25cqWLatHH31UM2bM0IULFzRr1iw9+eSThZrxtG/fvtqyZYu2bdum6dOnq2rVqmratOk1HUtJOXXqlF588UVVq1ZNzs7OcnZ2VtmyZXX69GklJSXlaX+174fvv/9ektSzZ0+7dt26dZOzc8lcBp/7HV+UWWbzq/vs2bO2GWyXLl0qi8WiXr162X1mg4KCVK9evTyfWV9fX7Vs2bJ4B/L/5fd/1tGjR/XMM88oNDRUzs7OcnFxUVhYmCTl+77k56+//lKPHj0UFBQkJycnubi42CYjKuw2gOuBsAU4kNOnT+vYsWMKCQkpsE3VqlW1cuVKBQQEaNCgQapataqqVq1qu06lsIKDgwvdNigoqMBlx44dK9J+i+rYsWP51pr7M7p8/+XLl7d7nnvBdmZmZoH7SEtLk2EYRdpPYVSqVEmpqamFusYgd/sF1ZCTk5PnNKaC3sP8lh85ckRLliyRi4uL3SP32qXcU65SU1MVEhJiF/hKwvTp0+Xu7q527drpxIkTOnHihOrWravKlSsrNjY2z2mel7+P0sX38tL3ccSIEXr77be1YcMGtW/fXuXLl1erVq3sphvPPTVw5cqVWrdunc6fP6+WLVuqdevWWrVqlW3dvffea5uoI/eUq7vvvjvPz2vevHl5Tk/Lndr7UlarVWvXrlX9+vX18ssvq3bt2goJCdGoUaPyTP1dWIX5mRRGv3799PPPP+v1119Xampqoaczb9q0qapXr65p06Zp9uzZtunir0VucCno9N7c6whdXFyuuJ0ePXpo8uTJeuqpp7R8+XJt2rRJmzdvVoUKFfL9uVzt+yG3H17+nefs7Jzvz/9ylSpVkiTt3bu3wDa517Ve/gekK7la3UeOHJFhGAoMDMzzmd2wYUOez2xRvv+vJjeo5n5X5uTkqG3btlqwYIFeeOEFrVq1Sps2bdKGDRvsar6SU6dO6f7779fGjRv12muvac2aNdq8ebPtNO6ifuYBMzEbIeBAli1bpuzs7KtONnD//ffr/vvvV3Z2trZs2aL//e9/iomJUWBgYKEvVi/KL0kpKSkFLsv9JcDd3V3SxckVLlXc+8OUL19eycnJeZbnXm9z6exY18rX11dlypQp8f1ERUVpxYoVWrJkyVXfl9yfY0E1lClTRr6+vnbLC3oP81vu7++vunXr6vXXX8/3Nbm/KFWoUEHr1q1TTk5OiQWuP/74w3bNWe4vo5dbvny5HnjggSJt19nZWUOHDtXQoUN14sQJrVy5Ui+//LKioqJ08OBB2wybt99+u1auXKnKlSurYcOGKleunFq1aqWBAwdq48aN2rBhg20SEen/3uuvvvrK9tf4KynofahTp47mzp0rwzD022+/KTY2VmPHjpWHh4deeumlIh1rSbr33ntVo0YNjR07Vm3atCnSL/1PPvmk/vOf/8hisah3797XXIO/v7+cnJz0999/57v+77//lpOT0xUDTnp6upYuXapRo0bZ/TyzsrJ0/Pjxa6ord38pKSm67bbbbMsvXLhQqD+4tGnTRh999JEWLVpU4Hu8aNEiOTs7F2pSmcLy9/eXxWLRjz/+mO+MgJcvu9aQnJ/FixdLku14tm/frl9//VWxsbF2n5E///yz0NtcvXq1Dh8+rDVr1tjdWoMp4nEjYmQLcBAHDhzQ8OHDZbVa9fTTTxfqNU5OTmrUqJE++OADSbKd0leY0Zyi2LFjR577qHz++efy9va2XcycO3vab7/9Ztcu9z/iSxXlr/GtWrWy/cd7qVmzZsnT07NEpor38vJSo0aNtGDBAru6cnJy9Nlnn9l+YS+qfv36KSgoSC+88EKBv1Tm/qW2Ro0auu222/T555/bnZZz+vRpff3117YZCq9Vhw4dtH37dlWtWlUNGzbM88gNW+3bt9fZs2ftblCbn6K8h7mTYHz88cf6/vvv7R7ffvutXFxc8syQV1TlypXTI488okGDBun48eN2s2K2bt1aq1evVnx8vG3K89tvv12VKlXSyJEjdf78ebvJMaKiouTs7Kw9e/bk+7O69LYNhWGxWFSvXj299957KleunOmn3hbGf/7zH3Xs2FHDhg0r0ut69+6tjh076t///rddGCkqd3d33XvvvVq8eLHOnj1rt+7s2bNavHix7rvvPtsfcfJjsVhkGEaeIPHJJ59cdUKcguQGhjlz5tgtnz9/fp5ZO/Pz8MMPq1atWnrjjTf0xx9/5Fk/b948rVixQk899ZRt9Kwkvq87dOggwzD0999/5/t5rVOnzjVv+0p+/fVXjRs3TpUrV1a3bt0k/V+Qu/x9uXSW3VwFHXtRtgGUNka2gBvQ9u3bbefUHz16VD/++KNmzpwpJycnLVy40DYVcH4+/PBDrV69Wg8++KAqVaqks2fP2n5Rzf2F0dvbW2FhYfrmm2/UqlUr+fn5yd/f/4rTlF9JSEiIOnXqpNGjRys4OFifffaZ4uPj9eabb9oCwN13360aNWpo+PDhunDhgnx9fbVw4cJ8Z9GrU6eOFixYoKlTp6pBgwYqU6ZMgb/Ajho1yna90ciRI+Xn56c5c+Zo2bJlmjBhwhWnqy6K8ePHq02bNmrRooWGDx8uV1dXTZkyRdu3b9cXX3xxTX8Jtlqt+uabb9ShQwfdeeedevbZZxUZGSlXV1ft3r1bn332mX799Vd16dJFZcqU0YQJE9SzZ0916NBBTz/9tLKysvTWW2/pxIkTeuONN4p1fGPHjlV8fLyaNGmiIUOGqEaNGjp79qz27dunb7/9Vh9++KEqVqyoxx9/XDNnztQzzzyjXbt2qUWLFsrJydHGjRtVs2ZN2whdnTp1tGbNGi1ZskTBwcHy9vZWjRo18uw397qgmjVrFniz6o4dO2rx4sVKTU294mc/v9fl3rOuQoUK2r9/vyZOnKiwsDBVr17d1q5Vq1aaMmWK/vnnH7ubabdq1UozZ86Ur6+v3bTvlStX1tixY/XKK6/or7/+Urt27eTr66sjR45o06ZN8vLyshsJy8/SpUs1ZcoUde7cWVWqVJFhGLap0y+9x1Vp6dWrV55Z+AojJCSkSDezXr16dZ7bQUgXZ15944031KJFC0VGRiomJkaVKlXSgQMHNHHiRB05csQ2tXxBfHx81LRpU7311lu277e1a9dq+vTpKleuXNEO7P+rWbOmevXqpYkTJ8rFxUWtW7fW9u3b9fbbbxdq1kUnJyd9/fXXatOmjSIjIzVs2DBFRkYqKytLS5Ys0UcffaRmzZrpnXfesb2mJL6v7733Xg0YMEBPPvmktmzZoqZNm8rLy0vJyclat26d6tSpo3/961/X8iOx2bp1q6xWq86fP6/Dhw9r1apVmj17tgICArRkyRK5urpKku644w5VrVpVL730kgzDkJ+fn5YsWWK7RvJSuSFw0qRJ6t27t1xcXGy3KPD19dUzzzyjUaNGycXFRXPmzLnmmycDpiqdeTkA5Cd3Rqzch6urqxEQEGA0a9bMGDdunHH06NE8r7l8hsD169cbDz/8sBEWFma4ubkZ5cuXN5o1a2YsXrzY7nUrV6407rzzTsPNzc1uFq0rzSxV0GyEDz74oPHVV18ZtWvXNlxdXY3KlSsb7777bp7X//HHH0bbtm0NHx8fo0KFCsbgwYONZcuW5ZmN8Pjx48YjjzxilCtXzrBYLHb7VD6zcm3bts3o2LGjYbVaDVdXV6NevXp2M58Zxv/NRvjll1/aLc+d9ezy9vn58ccfjZYtWxpeXl6Gh4eH0bhxY2PJkiX5bq8wsxHmSklJMV588UWjdu3ahqenp+Hm5mZUq1bNePrpp41t27bZtV20aJHRqFEjw93d3fDy8jJatWpl/PTTT3ZtrvQe5r5f+UlNTTWGDBlihIeHGy4uLoafn5/RoEED45VXXjFOnTpla5eZmWmMHDnSqF69uuHq6mqUL1/eaNmypZGQkGBrk5iYaNx7772Gp6enIclo1qxZvvtctGiRIcmYOHFigT+fuLg4u5nULp0B71KXz9L3zjvvGE2aNDH8/f0NV1dXo1KlSka/fv2Mffv22b0uLS3NKFOmjOHl5WWcO3fOtjx3hrkuXboUWHuLFi0MHx8fw83NzQgLCzMeeeQRY+XKlXY1eXl55Xnt77//bjz++ONG1apVDQ8PD8NqtRr33HOPERsbW+DPoaDjNIyL/WLQoEF52oaFhV11hrzCfmavNhthQa40G2FBj9zZ57Zs2WI8/PDDhr+/v+Hk5GT4+/sbDz/8sLF169Yr7jPXoUOHjK5duxq+vr6Gt7e30a5dO2P79u15fi4FzY6Y32ypWVlZxrBhw4yAgADD3d3daNy4sbF+/fpC/axz/fPPP8ZLL71k3HHHHYa7u7tRtmxZ45577jEmT55s9xnMVdTv64Jmf50xY4bRqFEj23dY1apVjSeeeMLYsmWLrU1h3tNL5daQ+3BzczOCg4ONtm3bGpMmTbKbITPXzp07jTZt2hje3t6Gr6+v8eijjxoHDhzI9/t9xIgRRkhIiFGmTBm79yIhIcGIjIw0PD09jQoVKhhPPfWU8fPPPxf6+xy4XiyGcZWpzQAAAAAARcY1WwAAAABgAsIWAAAAAJiAsAUAAAAAJiBsAQAAAIAJCFsAAAAAYALCFgAAAACYgJsaF1JOTo4OHz4sb2/va7p5KQAAAICbg2EYOnnypEJCQlSmTMHjV4StQjp8+LBCQ0NLuwwAAAAAN4iDBw+qYsWKBa4nbBWSt7e3pIs/UB8fn1KuBgAAAEBpycjIUGhoqC0jFISwVUi5pw76+PgQtgAAAABc9fIiJsgAAAAAABMQtgAAAADABIQtAAAAADAB12wBAAAABcjOztb58+dLuwxcZ05OTnJ2di72LZ8IWwAAAEA+Tp06pUOHDskwjNIuBaXA09NTwcHBcnV1veZtELYAAACAy2RnZ+vQoUPy9PRUhQoVij3CAcdhGIbOnTun1NRU7d27V9WrV7/ijYuvhLAFAAAAXOb8+fMyDEMVKlSQh4dHaZeD68zDw0MuLi7av3+/zp07J3d392vaDhNkAAAAAAVgROvWda2jWXbbKIE6AAAAAACXIWwBAAAAgAm4ZgsAAAAopOt9ViETITo2RrYAAACAm0SfPn1ksVj0zDPP5Fk3cOBAWSwW9enTp1jtO3funO++mzdvrpiYmDzLFy1adNVr3ywWi+3h5eWl6tWrq0+fPtq6desVX1eUOkoDYQsAAAC4iYSGhmru3LnKzMy0LTt79qy++OILVapUqdjtzTJz5kwlJydrx44d+uCDD3Tq1Ck1atRIs2bNum41lDTCFgAAAHATueuuu1SpUiUtWLDAtmzBggUKDQ3VnXfeWez2ZilXrpyCgoJUuXJltW3bVl999ZV69uypZ599VmlpaZKkY8eO6fHHH1fFihXl6empOnXq6IsvvrBto0+fPlq7dq0mTZpkGynbt2+fsrOz1a9fP4WHh8vDw0M1atTQpEmTTD8mwhYAAABwk3nyySc1c+ZM2/MZM2aob9++Jdb+enn++ed18uRJxcfHS7o44tagQQMtXbpU27dv14ABAxQdHa2NGzdKkiZNmqTIyEj1799fycnJSk5OVmhoqHJyclSxYkXNnz9fO3fu1MiRI/Xyyy9r/vz5ptZP2AIAAABuMtHR0Vq3bp327dun/fv366efflKvXr1KrP31cscdd0iS9u3bJ0m67bbbNHz4cNWvX19VqlTR4MGDFRUVpS+//FKSZLVa5erqKk9PTwUFBSkoKEhOTk5ycXHRmDFjdPfddys8PFw9e/ZUnz59TA9bzEYIAAAA3GT8/f314IMP6tNPP5VhGHrwwQfl7+9fYu2vF+P/T8eYO8FGdna23njjDc2bN09///23srKylJWVJS8vr6tu68MPP9Qnn3yi/fv3KzMzU+fOnVP9+vXNLJ+wBQAAANyM+vbtq2effVaS9MEHH5R4+8v5+PgoPT09z/ITJ07Ix8enyNuTpKSkJElSeHi4JOmdd97Re++9p4kTJ6pOnTry8vJSTEyMzp07d8XtzJ8/X88//7zeeecdRUZGytvbW2+99Zbt9EOzELYAAACAm1C7du1sISQqKqrE21/ujjvu0HfffZdn+ebNm1WjRo0ib0+SJk6cKB8fH7Vu3VqS9OOPP+qhhx6yneKYk5Oj3bt3q2bNmrbXuLq6Kjs72247P/74o5o0aaKBAwfalu3Zs+eaaioKwtYt5HrfhM8M3NgPAACgcJycnGwjQ05OTiXWPj09XYmJiXbL/Pz8NHDgQE2ePFmDBg3SgAED5OHhofj4eE2fPl2zZ8++6v5PnDihlJQUZWVl6Y8//tC0adO0aNEizZo1S+XKlZMkVatWTV9//bUSEhLk6+urd999VykpKXZhq3Llytq4caP27dunsmXLys/PT9WqVdOsWbO0fPlyhYeHa/bs2dq8ebNtxMwshC0AAACgkBztD79FPX2vMO3XrFmTZ0r43r17KzY2Vj/++KNeeeUVtW3bVmfPntXtt9+u2NhYPfroo1fd7pNPPilJcnd312233ab77rtPmzZt0l133WVr8+qrr2rv3r2KioqSp6enBgwYoM6dO9udvjh8+HD17t1btWrVUmZmpvbu3atnnnlGiYmJ6t69uywWix5//HENHDgw35G4kmQxDEf7yJSOjIwMWa1WpaenX/M5p6WNkS0AAIDCOXv2rPbu3avw8HC5u7uXdjkoBVf6DBQ2GzD1OwAAAACYgLAFAAAAACYgbAEAAACACQhbAAAAAGACwhYAAAAAmICwBQAAAAAmIGwBAAAAgAkIWwAAAABgAsIWAAAAAJiAsAUAAAAUlsVyfR/XWWxsrMqVK3fd93uzImwBAAAAN5GDBw+qX79+CgkJkaurq8LCwvTcc8/p2LFjdu0qV66siRMnlk6Rl9RgsVhksVjk4eGhypUrq1u3blq9enWRt9WnTx917ty55IssBsIWAAAAcJP466+/1LBhQ/3xxx/64osv9Oeff+rDDz/UqlWrFBkZqePHj5dKXefPny9w3dixY5WcnKxdu3Zp1qxZKleunFq3bq3XX3/9OlZoDsIWAAAAcJMYNGiQXF1dtWLFCjVr1kyVKlVS+/bttXLlSv3999965ZVXJEnNmzfX/v379fzzz9tGli61fPly1axZU2XLllW7du2UnJxst37mzJmqWbOm3N3ddccdd2jKlCm2dfv27ZPFYtH8+fPVvHlzubu767PPPiuwZm9vbwUFBalSpUpq2rSpPvroI7366qsaOXKkdu3aJUnKzs5Wv379FB4eLg8PD9WoUUOTJk2ybWP06NH69NNP9c0339iOZ82aNZKkF198Ubfffrs8PT1VpUoVvfrqq1cMfyWJsAUAAADcBI4fP67ly5dr4MCB8vDwsFsXFBSknj17at68eTIMQwsWLFDFihVto0qXhqkzZ87o7bff1uzZs/XDDz/owIEDGj58uG39xx9/rFdeeUWvv/66kpKSNG7cOL366qv69NNP7fb54osvasiQIUpKSlJUVFSRjuW5556TYRj65ptvJEk5OTmqWLGi5s+fr507d2rkyJF6+eWXNX/+fEnS8OHD1a1bN1swTE5OVpMmTSRdDHOxsbHauXOnJk2apI8//ljvvfdekeq5Vs7XZS8AAAAATLV7924ZhqGaNWvmu75mzZpKS0tTamqqAgIC5OTkZBtVutT58+f14YcfqmrVqpKkZ599VmPHjrWt/+9//6t33nlHXbp0kSSFh4dr586dmjZtmnr37m1rFxMTY2tTVH5+fgoICNC+ffskSS4uLhozZoxtfXh4uBISEjR//nx169ZNZcuWlYeHh7KysvIcz3/+8x/bvytXrqxhw4Zp3rx5euGFF66ptqIgbAEAAAC3AMMwJCnPKYOX8/T0tAUtSQoODtbRo0clSampqbYJOPr3729rc+HCBVmtVrvtNGzYsNj1Xlrrhx9+qE8++UT79+9XZmamzp07p/r16191O1999ZUmTpyoP//8U6dOndKFCxfk4+NTrNoKi9MIAQAAgJtAtWrVZLFYtHPnznzX//777/L19ZW/v/8Vt+Pi4mL33GKx2IJaTk6OpIunEiYmJtoe27dv14YNG+xe5+Xlda2HomPHjik1NVXh4eGSpPnz5+v5559X3759tWLFCiUmJurJJ5/UuXPnrridDRs26LHHHlP79u21dOlS/fLLL3rllVeu+rqSwsgWAAAAcBMoX7682rRpoylTpuj555+3u24rJSVFc+bM0RNPPGEbLXJ1dVV2dnaR9hEYGKjbbrtNf/31l3r27Fmi9V9q0qRJKlOmjG0q9x9//FFNmjTRwIEDbW327Nlj95r8juenn35SWFiYbWIQSdq/f79pdV+OkS0AAADgJjF58mRlZWUpKipKP/zwgw4ePKi4uDi1adNGt912m9106pUrV9YPP/ygv//+W//880+h9zF69GiNHz9ekyZN0h9//KFt27Zp5syZevfdd6+p5pMnTyolJUUHDx7UDz/8oAEDBui1117T66+/rmrVqkm6OGq3ZcsWLV++XH/88YdeffVVbd682W47lStX1m+//aZdu3bpn3/+0fnz51WtWjUdOHBAc+fO1Z49e/T+++9r4cKF11TntSBsAQAAAIVlGNf3UUTVq1fXli1bVLVqVXXv3l1Vq1bVgAED1KJFC61fv15+fn62tmPHjtW+fftUtWpVVahQodD7eOqpp/TJJ58oNjZWderUUbNmzRQbG2s75a+oRo4cqeDgYFWrVk3R0dFKT0/XqlWr9OKLL9raPPPMM+rSpYu6d++uRo0a6dixY3ajXJLUv39/1ahRQw0bNlSFChX0008/6aGHHtLzzz+vZ599VvXr11dCQoJeffXVa6rzWlgM4xrexVtQRkaGrFar0tPTr9sFdSXtKtdCOgQ+rQAA4Ho4e/as9u7dq/DwcLm7u5d2OSgFV/oMFDYblOrI1tSpU1W3bl35+PjIx8dHkZGR+u6772zr+/TpY7spWe6jcePGdtvIysrS4MGD5e/vLy8vL3Xq1EmHDh2ya5OWlqbo6GhZrVZZrVZFR0frxIkT1+MQAQAAANyiSjVsVaxYUW+88Ya2bNmiLVu2qGXLlnrooYe0Y8cOW5tLb0yWnJysb7/91m4bMTExWrhwoebOnat169bp1KlT6tChg93FcT169FBiYqLi4uIUFxenxMRERUdHX7fjBAAAAHDrKdXZCDt27Gj3/PXXX9fUqVO1YcMG1a5dW5Lk5uaW58ZkudLT0zV9+nTNnj1brVu3liR99tlnCg0N1cqVKxUVFaWkpCTFxcVpw4YNatSokaSLU1VGRkZq165dqlGjholHCAAAAOBWdcNMkJGdna25c+fq9OnTioyMtC1fs2aNAgICdPvtt6t///62G6pJ0tatW3X+/Hm1bdvWtiwkJEQRERFKSEiQJK1fv15Wq9UWtCSpcePGslqttjb5ycrKUkZGht0DAAAAAAqr1MPWtm3bVLZsWbm5uemZZ57RwoULVatWLUlS+/btNWfOHK1evVrvvPOONm/erJYtWyorK0vSxfsFuLq6ytfX126bgYGBSklJsbUJCAjIs9+AgABbm/yMHz/edo2X1WpVaGhoSR0yAAAAHARzyd26SuK9L/WbGteoUUOJiYk6ceKEvv76a/Xu3Vtr165VrVq11L17d1u7iIgINWzYUGFhYVq2bJm6dOlS4DYNw7DdrE2S3b8LanO5ESNGaOjQobbnGRkZBC4AAIBbhJOTkyTp3LlzdjcHxq3jzJkzkiQXF5dr3kaphy1XV1fbzcoaNmyozZs3a9KkSZo2bVqetsHBwQoLC9Pu3bslSUFBQTp37pzS0tLsRreOHj2qJk2a2NocOXIkz7ZSU1MVGBhYYF1ubm5yc3Mr1rEBAADAMTk7O8vT01OpqalycXFRmTKlfkIYrhPDMHTmzBkdPXpU5cqVswXva1HqYetyhmHYThO83LFjx3Tw4EEFBwdLkho0aCAXFxfFx8erW7dukqTk5GRt375dEyZMkCRFRkYqPT1dmzZt0j333CNJ2rhxo9LT022BDAAAALiUxWJRcHCw9u7dq/3795d2OSgF5cqVK3CivsIq1bD18ssvq3379goNDdXJkyc1d+5crVmzRnFxcTp16pRGjx6trl27Kjg4WPv27dPLL78sf39/Pfzww5Ikq9Wqfv36adiwYSpfvrz8/Pw0fPhw1alTxzY7Yc2aNdWuXTv179/fNlo2YMAAdejQgZkIAQAAUCBXV1dVr15d586dK+1ScJ25uLgUa0QrV6mGrSNHjig6OlrJycmyWq2qW7eu4uLi1KZNG2VmZmrbtm2aNWuWTpw4oeDgYLVo0ULz5s2Tt7e3bRvvvfeenJ2d1a1bN2VmZqpVq1aKjY21++HMmTNHQ4YMsc1a2KlTJ02ePPm6Hy8AAAAcS5kyZeTu7l7aZcBBWQymWCmUjIwMWa1Wpaeny8fHp7TLuSZXmA/EYfBpBQAAQGkrbDbgSj8AAAAAMAFhCwAAAABMQNgCAAAAABMQtgAAAADABDfcfbYAwEyOPlEMk8QAAOA4GNkCAAAAABMQtgAAAADABIQtAAAAADABYQsAAAAATEDYAgAAAAATELYAAAAAwASELQAAAAAwAWELAAAAAExA2AIAAAAAExC2AAAAAMAEhC0AAAAAMAFhCwAAAABMQNgCAAAAABMQtgAAAADABIQtAAAAADABYQsAAAAATEDYAgAAAAATELYAAAAAwASELQAAAAAwAWELAAAAAExA2AIAAAAAExC2AAAAAMAEhC0AAAAAMAFhCwAAAABMQNgCAAAAABMQtgAAAADABIQtAAAAADABYQsAAAAATEDYAgAAAAATELYAAAAAwASELQAAAAAwAWELAAAAAExA2AIAAAAAExC2AAAAAMAEhC0AAAAAMAFhCwAAAABMQNgCAAAAABMQtgAAAADABIQtAAAAADABYQsAAAAATEDYAgAAAAATELYAAAAAwASELQAAAAAwQamGralTp6pu3bry8fGRj4+PIiMj9d1339nWG4ah0aNHKyQkRB4eHmrevLl27Nhht42srCwNHjxY/v7+8vLyUqdOnXTo0CG7NmlpaYqOjpbVapXValV0dLROnDhxPQ4RAAAAwC2qVMNWxYoV9cYbb2jLli3asmWLWrZsqYceesgWqCZMmKB3331XkydP1ubNmxUUFKQ2bdro5MmTtm3ExMRo4cKFmjt3rtatW6dTp06pQ4cOys7OtrXp0aOHEhMTFRcXp7i4OCUmJio6Ovq6Hy8AAACAW4fFMAyjtIu4lJ+fn9566y317dtXISEhiomJ0Ysvvijp4ihWYGCg3nzzTT399NNKT09XhQoVNHv2bHXv3l2SdPjwYYWGhurbb79VVFSUkpKSVKtWLW3YsEGNGjWSJG3YsEGRkZH6/fffVaNGjULVlZGRIavVqvT0dPn4+Jhz8CazWEq7guK7sT6tcESO3g/oAwAAlL7CZoMb5pqt7OxszZ07V6dPn1ZkZKT27t2rlJQUtW3b1tbGzc1NzZo1U0JCgiRp69atOn/+vF2bkJAQRURE2NqsX79eVqvVFrQkqXHjxrJarbY2+cnKylJGRobdAwAAAAAKq9TD1rZt21S2bFm5ubnpmWee0cKFC1WrVi2lpKRIkgIDA+3aBwYG2talpKTI1dVVvr6+V2wTEBCQZ78BAQG2NvkZP3687Rovq9Wq0NDQYh0nAAAAgFtLqYetGjVqKDExURs2bNC//vUv9e7dWzt37rStt1x2zo9hGHmWXe7yNvm1v9p2RowYofT0dNvj4MGDhT0kAAAAACj9sOXq6qpq1aqpYcOGGj9+vOrVq6dJkyYpKChIkvKMPh09etQ22hUUFKRz584pLS3tim2OHDmSZ7+pqal5Rs0u5ebmZpslMfcBAAAAAIVV6mHrcoZhKCsrS+Hh4QoKClJ8fLxt3blz57R27Vo1adJEktSgQQO5uLjYtUlOTtb27dttbSIjI5Wenq5NmzbZ2mzcuFHp6em2NgAAAABQ0pxLc+cvv/yy2rdvr9DQUJ08eVJz587VmjVrFBcXJ4vFopiYGI0bN07Vq1dX9erVNW7cOHl6eqpHjx6SJKvVqn79+mnYsGEqX768/Pz8NHz4cNWpU0etW7eWJNWsWVPt2rVT//79NW3aNEnSgAED1KFDh0LPRAgAAAAARVWqYevIkSOKjo5WcnKyrFar6tatq7i4OLVp00aS9MILLygzM1MDBw5UWlqaGjVqpBUrVsjb29u2jffee0/Ozs7q1q2bMjMz1apVK8XGxsrJycnWZs6cORoyZIht1sJOnTpp8uTJ1/dgAQAAANxSbrj7bN2ouM/WjYFPK4rL0fsBfQAlgX4AAMXjcPfZAgAAAICbCWELAAAAAExA2AIAAAAAExC2AAAAAMAEhC0AAAAAMAFhCwAAAABMQNgCAAAAABMQtgAAAADABIQtAAAAADABYQsAAAAATEDYAgAAAAATELYAAAAAwASELQAAAAAwAWELAAAAAExA2AIAAAAAExC2AAAAAMAEhC0AAAAAMAFhCwAAAABMQNgCAAAAABMQtgAAAADABIQtAAAAADABYQsAAAAATEDYAgAAAAATELYAAAAAwASELQAAAAAwAWELAAAAAExA2AIAAAAAExC2AAAAAMAEhC0AAAAAMAFhCwAAAABMQNgCAAAAABMQtgAAAADABIQtAAAAADABYQsAAAAATEDYAgAAAAATELYAAAAAwASELQAAAAAwAWELAAAAAExA2AIAAAAAExC2AAAAAMAEhC0AAAAAMAFhCwAAAABMQNgCAAAAABMUO2xlZGRo0aJFSkpKKol6AAAAAOCmUOSw1a1bN02ePFmSlJmZqYYNG6pbt26qW7euvv766xIvEAAAAAAcUZHD1g8//KD7779fkrRw4UIZhqETJ07o/fff12uvvVbiBQIAAACAIypy2EpPT5efn58kKS4uTl27dpWnp6cefPBB7d69u8QLBAAAAABHVOSwFRoaqvXr1+v06dOKi4tT27ZtJUlpaWlyd3cv8QIBAAAAwBEVOWzFxMSoZ8+eqlixokJCQtS8eXNJF08vrFOnTpG2NX78eN19993y9vZWQECAOnfurF27dtm16dOnjywWi92jcePGdm2ysrI0ePBg+fv7y8vLS506ddKhQ4fs2qSlpSk6OlpWq1VWq1XR0dE6ceJEUQ8fAAAAAAqlyGFr4MCBWr9+vWbMmKF169apTJmLm6hSpUqRr9lau3atBg0apA0bNig+Pl4XLlxQ27Ztdfr0abt27dq1U3Jysu3x7bff2q2PiYnRwoULNXfuXK1bt06nTp1Shw4dlJ2dbWvTo0cPJSYmKi4uTnFxcUpMTFR0dHRRDx8AAAAACsViGIZR2kXkSk1NVUBAgNauXaumTZtKujiydeLECS1atCjf16Snp6tChQqaPXu2unfvLkk6fPiwQkND9e233yoqKkpJSUmqVauWNmzYoEaNGkmSNmzYoMjISP3++++qUaPGVWvLyMiQ1WpVenq6fHx8SuaArzOLpbQrKL4b59MKR+Xo/YA+gJJAPwCA4ilsNnAu6oazs7MVGxurVatW6ejRo8rJybFbv3r16qJX+/+lp6dLkm0Cjlxr1qxRQECAypUrp2bNmun1119XQECAJGnr1q06f/687doxSQoJCVFERIQSEhIUFRWl9evXy2q12oKWJDVu3FhWq1UJCQn5hq2srCxlZWXZnmdkZFzzcQEAAAC49RQ5bD333HOKjY3Vgw8+qIiICFlK6M9jhmFo6NChuu+++xQREWFb3r59ez366KMKCwvT3r179eqrr6ply5baunWr3NzclJKSIldXV/n6+tptLzAwUCkpKZKklJQUWzi7VEBAgK3N5caPH68xY8aUyLEBAAAAuPUUOWzNnTtX8+fP1wMPPFCihTz77LP67bfftG7dOrvluacGSlJERIQaNmyosLAwLVu2TF26dClwe4Zh2AXB/ELh5W0uNWLECA0dOtT2PCMjQ6GhoYU+HgAAAAC3tiJPkOHq6qpq1aqVaBGDBw/W4sWL9f3336tixYpXbBscHKywsDDbPb2CgoJ07tw5paWl2bU7evSoAgMDbW2OHDmSZ1upqam2Npdzc3OTj4+P3QMAAAAACqvIYWvYsGGaNGmSSmJeDcMw9Oyzz2rBggVavXq1wsPDr/qaY8eO6eDBgwoODpYkNWjQQC4uLoqPj7e1SU5O1vbt29WkSRNJUmRkpNLT07Vp0yZbm40bNyo9Pd3WBgAAAABKUpFnI3z44Yf1/fffy8/PT7Vr15aLi4vd+gULFhR6WwMHDtTnn3+ub775xm6SCqvVKg8PD506dUqjR49W165dFRwcrH379unll1/WgQMHlJSUJG9vb0nSv/71Ly1dulSxsbHy8/PT8OHDdezYMW3dulVOTk6SLl77dfjwYU2bNk2SNGDAAIWFhWnJkiWFqpXZCG8MzECF4nL0fkAfQEmgHwBA8Zg2G2G5cuX08MMPF6u4XFOnTpUk242Rc82cOVN9+vSRk5OTtm3bplmzZunEiRMKDg5WixYtNG/ePFvQkqT33ntPzs7O6tatmzIzM9WqVSvFxsbagpYkzZkzR0OGDLHNWtipUydNnjy5RI4DAAAAAC53Q91n60bGyNaNgU8risvR+wF9ACWBfgAAxWPayFau1NRU7dq1SxaLRbfffrsqVKhwrZsCAAAAgJtOkSfIOH36tPr27avg4GA1bdpU999/v0JCQtSvXz+dOXPGjBoBAAAAwOEUOWwNHTpUa9eu1ZIlS3TixAmdOHFC33zzjdauXathw4aZUSMAAAAAOJwiX7Pl7++vr776Ks+kFt9//726deum1NTUkqzvhsE1WzcGztNHcTl6P6APoCTQDwCgeAqbDYo8snXmzJl8bwQcEBDAaYQAAAAA8P8VOWxFRkZq1KhROnv2rG1ZZmamxowZo8jIyBItDgAAAAAcVZFnI5w0aZLatWunihUrql69erJYLEpMTJS7u7uWL19uRo0AAAAA4HCKHLYiIiK0e/duffbZZ/r9999lGIYee+wx9ezZUx4eHmbUCAAAAAAO55rus+Xh4aH+/fuXdC0AAAAAcNMoVNhavHix2rdvLxcXFy1evPiKbTt16lQihQEAAACAIyvU1O9lypRRSkqKAgICVKZMwXNqWCwWZWdnl2iBNwqmfr8xMN0visvR+wF9ACWBfgAAxVPYbFCoka2cnJx8/w0AAAAAyF+Rp36fNWuWsrKy8iw/d+6cZs2aVSJFAQAAAICjK9RphJdycnJScnKyAgIC7JYfO3ZMAQEBnEZ4A3P000YkTh1B8Tl6P6APoCTQDwCgeAqbDYo8smUYhiz5fEsfOnRIVqu1qJsDAAAAgJtSoad+v/POO2WxWGSxWNSqVSs5O//fS7Ozs7V37161a9fOlCIBAAAAwNEUOmx17txZkpSYmKioqCiVLVvWts7V1VWVK1dW165dS7xAAAAAAHBEhQ5bo0aNkiRVrlxZjz32mNzc3EwrCgAAAAAcXZGv2WrZsqVSU1Ntzzdt2qSYmBh99NFHJVoYAAAAADiyIoetHj166Pvvv5ckpaSkqHXr1tq0aZNefvlljR07tsQLBAAAAABHVOSwtX37dt1zzz2SpPnz56tOnTpKSEjQ559/rtjY2JKuDwAAAAAcUpHD1vnz523Xa61cuVKdOnWSJN1xxx1KTk4u2eoAAAAAwEEVOWzVrl1bH374oX788UfFx8fbpns/fPiwypcvX+IFAgAAAIAjKnLYevPNNzVt2jQ1b95cjz/+uOrVqydJWrx4se30QgAAAAC41VkMwzCK+qLs7GxlZGTI19fXtmzfvn3y9PRUQEBAiRZ4o8jIyJDValV6erp8fHxKu5xrYrGUdgXFV/RPK2DP0fsBfQAlgX4AAMVT2GxQ5JEtSTIMQ1u3btW0adN08uRJSRdvbOzp6Xlt1QIAAADATabQNzXOtX//frVr104HDhxQVlaW2rRpI29vb02YMEFnz57Vhx9+aEadAAAAAOBQijyy9dxzz6lhw4ZKS0uTh4eHbfnDDz+sVatWlWhxAAAAAOCoijyytW7dOv30009ydXW1Wx4WFqa///67xAoDAAAAAEdW5JGtnJwcZWdn51l+6NAheXt7l0hRAAAAAODoihy22rRpo4kTJ9qeWywWnTp1SqNGjdIDDzxQkrUBAAAAgMMq8tTvhw8fVosWLeTk5KTdu3erYcOG2r17t/z9/fXDDz8w9fsNzNGn+pWY7hfF5+j9gD6AkkA/AIDiKWw2KPI1WyEhIUpMTNQXX3yhn3/+WTk5OerXr5969uxpN2EGAAAAANzKrummxrciRrZuDHxaUVyO3g/oAygJ9AMAKB7TRrZmzZp1xfVPPPFEUTcJAAAAADedIo9s+fr62j0/f/68zpw5I1dXV3l6eur48eMlWuCNgpGtGwN/zURxOXo/oA+gJNAPAKB4CpsNijwbYVpamt3j1KlT2rVrl+677z598cUXxSoaAAAAAG4WRQ5b+alevbreeOMNPffccyWxOQAAAABweCUStiTJyclJhw8fLqnNAQAAAIBDK/IEGYsXL7Z7bhiGkpOTNXnyZN17770lVhgAAAAAOLIih63OnTvbPbdYLKpQoYJatmypd955p6TqAgAAAACHVuSwlZOTY0YdAAAAAHBTueZrtv755x9lZGSUZC0AAAAAcNMoUtg6ceKEBg0aJH9/fwUGBsrX11dBQUEaMWKEzpw5Y1aNAAAAAOBwCn0a4fHjxxUZGam///5bPXv2VM2aNWUYhpKSkvS///1P8fHxWrdunX799Vdt3LhRQ4YMMbNuAAAAALihFTpsjR07Vq6urtqzZ48CAwPzrGvbtq2io6O1YsUKvf/++yVeKAAAAAA4kkKHrUWLFmnatGl5gpYkBQUFacKECXrggQc0atQo9e7du0SLBAAAAABHU+hrtpKTk1W7du0C10dERKhMmTIaNWpUoXc+fvx43X333fL29lZAQIA6d+6sXbt22bUxDEOjR49WSEiIPDw81Lx5c+3YscOuTVZWlgYPHix/f395eXmpU6dOOnTokF2btLQ0RUdHy2q1ymq1Kjo6WidOnCh0rQAAAABQFIUOW/7+/tq3b1+B6/fu3auAgIAi7Xzt2rUaNGiQNmzYoPj4eF24cEFt27bV6dOnbW0mTJigd999V5MnT9bmzZsVFBSkNm3a6OTJk7Y2MTExWrhwoebOnat169bp1KlT6tChg7Kzs21tevToocTERMXFxSkuLk6JiYmKjo4uUr0AAAAAUFgWwzCMwjTs16+f/vzzT8XHx8vV1dVuXVZWlqKiolSlShXNmDHjmotJTU1VQECA1q5dq6ZNm8owDIWEhCgmJkYvvviibV+BgYF688039fTTTys9PV0VKlTQ7Nmz1b17d0nS4cOHFRoaqm+//VZRUVFKSkpSrVq1tGHDBjVq1EiStGHDBkVGRur3339XjRo1rlpbRkaGrFar0tPT5ePjc83HWJosltKuoPgK92kFCubo/YA+gJJAPwCA4ilsNij0NVtjxoxRw4YNVb16dQ0aNEh33HGHJGnnzp2aMmWKsrKyNGvWrGIVnZ6eLkny8/OTdHG0LCUlRW3btrW1cXNzU7NmzZSQkKCnn35aW7du1fnz5+3ahISEKCIiQgkJCYqKitL69etltVptQUuSGjduLKvVqoSEhHzDVlZWlrKysmzPuacYAAAAgKIodNiqWLGi1q9fr4EDB2rEiBHKHRCzWCxq06aNJk+erEqVKl1zIYZhaOjQobrvvvsUEREhSUpJSZGkPJNyBAYGav/+/bY2rq6u8vX1zdMm9/UpKSn5nuIYEBBga3O58ePHa8yYMdd8PAAAAABubYUOW5IUHh6u7777Tmlpadq9e7ckqVq1araRqOJ49tln9dtvv2ndunV51lkuO9/BMIw8yy53eZv82l9pOyNGjNDQoUNtzzMyMhQaGnrFfQIAAABAriKFrVy+vr665557SqyIwYMHa/Hixfrhhx9UsWJF2/KgoCBJF0emgoODbcuPHj1qG+0KCgrSuXPnlJaWZje6dfToUTVp0sTW5siRI3n2m5qamu9U9tLF0xXd3NyKf3AAAAAAbkmFno3QDIZh6Nlnn9WCBQu0evVqhYeH260PDw9XUFCQ4uPjbcvOnTuntWvX2oJUgwYN5OLiYtcmOTlZ27dvt7WJjIxUenq6Nm3aZGuzceNGpaen29oAAAAAQEm6ppGtkjJo0CB9/vnn+uabb+Tt7W27fspqtcrDw0MWi0UxMTEaN26cqlevrurVq2vcuHHy9PRUjx49bG379eunYcOGqXz58vLz89Pw4cNVp04dtW7dWpJUs2ZNtWvXTv3799e0adMkSQMGDFCHDh0KNRMhAAAAABRVqYatqVOnSpKaN29ut3zmzJnq06ePJOmFF15QZmamBg4cqLS0NDVq1EgrVqyQt7e3rf17770nZ2dndevWTZmZmWrVqpViY2Pl5ORkazNnzhwNGTLENmthp06dNHnyZHMPEAAAAMAtq1D32brrrru0atUq+fr6auzYsRo+fLg8PT2vR303DO6zdWPg3iooLkfvB/QBlAT6AQAUT2GzQaGu2UpKStLp06clXbzf1qlTp0qmSgAAAAC4SRXqNML69evrySef1H333SfDMPT222+rbNmy+bYdOXJkiRYIAAAAAI6oUKcR7tq1S6NGjdKePXv0888/q1atWnJ2zpvTLBaLfv75Z1MKLW2cRnhj4NQRFJej9wP6AEoC/QAAiqew2aBQYetSZcqUUUpKigICAopdpCMhbN0Y+A8WxeXo/YA+gJJAPwCA4ilsNijybIQ5OTnFKgwAAAAAbgXXNPX7nj17NHHiRCUlJclisahmzZp67rnnVLVq1ZKuDwAAAAAcUqFmI7zU8uXLVatWLW3atEl169ZVRESENm7cqNq1ays+Pt6MGgEAAADA4RT5mq0777xTUVFReuONN+yWv/TSS1qxYgUTZNzAHP0cfYnz9FF8jt4P6AMoCfQDACieEr3P1qWSkpLUr1+/PMv79u2rnTt3FnVzAAAAAHBTKnLYqlChghITE/MsT0xMvOVmKAQAAACAghR5goz+/ftrwIAB+uuvv9SkSRNZLBatW7dOb775poYNG2ZGjQAAAADgcIp8zZZhGJo4caLeeecdHT58WJIUEhKif//73xoyZIgsjn4ieAG4ZuvGwHn6KC5H7wf0AZQE+gEAFI9pNzW+1MmTJyVJ3t7e17oJh0HYujHwHyyKy9H7AX0AJYF+AADFY9pNjS91K4QsAAAAALgWRZ4gAwAAAABwdYQtAAAAADABYQsAAAAATFCksHX+/Hm1aNFCf/zxh1n1AAAAAMBNoUhhy8XFRdu3b79pp3cHAAAAgJJS5NMIn3jiCU2fPt2MWgAAAADgplHkqd/PnTunTz75RPHx8WrYsKG8vLzs1r/77rslVhwAAAAAOKoih63t27frrrvukqQ8125xeiEAAAAAXFTksPX999+bUQcAAAAA3FSueer3P//8U8uXL1dmZqYkyTCMEisKAAAAABxdkcPWsWPH1KpVK91+++164IEHlJycLEl66qmnNGzYsBIvEAAAAAAcUZHD1vPPPy8XFxcdOHBAnp6etuXdu3dXXFxciRYHAAAAAI6qyNdsrVixQsuXL1fFihXtllevXl379+8vscIAAAAAwJEVeWTr9OnTdiNauf755x+5ubmVSFEAAAAA4OiKHLaaNm2qWbNm2Z5bLBbl5OTorbfeUosWLUq0OAAAAABwVEU+jfCtt95S8+bNtWXLFp07d04vvPCCduzYoePHj+unn34yo0YAAAAAcDhFHtmqVauWfvvtN91zzz1q06aNTp8+rS5duuiXX35R1apVzagRAAAAAByOxeAGWYWSkZEhq9Wq9PR0+fj4lHY518RiKe0Kio9PK4rL0fsBfQAlgX4AAMVT2GxQ5NMIJSktLU3Tp09XUlKSLBaLatasqSeffFJ+fn7XXDAAAAAA3EyKfBrh2rVrFR4ervfff19paWk6fvy43n//fYWHh2vt2rVm1AgAAAAADqfIpxFGRESoSZMmmjp1qpycnCRJ2dnZGjhwoH766Sdt377dlEJLG6cR3hg4dQTF5ej9gD6AkkA/AIDiKWw2KPLI1p49ezRs2DBb0JIkJycnDR06VHv27Lm2agEAAADgJlPksHXXXXcpKSkpz/KkpCTVr1+/JGoCAAAAAIdXqAkyfvvtN9u/hwwZoueee05//vmnGjduLEnasGGDPvjgA73xxhvmVAkAAAAADqZQ12yVKVNGFotFV2tqsViUnZ1dYsXdSLhm68bAefooLkfvB/QBlAT6AQAUT4lO/b53794SKwwAAAAoTY7+BweJPzo4ikKFrbCwMLPrAAAAAICbyjXd1Pjvv//WTz/9pKNHjyonJ8du3ZAhQ0qkMAAAAABwZEUOWzNnztQzzzwjV1dXlS9fXpZLxmEtFgthCwAAAAB0DWFr5MiRGjlypEaMGKEyZYo8czwAAAAA3BKKnJbOnDmjxx57jKAFAAAAAFdQ5MTUr18/ffnll2bUAgAAAAA3jULdZ+tS2dnZ6tChgzIzM1WnTh25uLjYrX/33XdLtMAbBffZujEwzSmKy9H7AX0AJYF+gFudo/cBiX5Q2kr0PluXGjdunJYvX64aNWpIUp4JMgAAAAAA13Aa4bvvvqsZM2YoKSlJa9as0ffff297rF69ukjb+uGHH9SxY0eFhITIYrFo0aJFduv79Okji8Vi92jcuLFdm6ysLA0ePFj+/v7y8vJSp06ddOjQIbs2aWlpio6OltVqldVqVXR0tE6cOFHUQwcAAACAQity2HJzc9O9995bIjs/ffq06tWrp8mTJxfYpl27dkpOTrY9vv32W7v1MTExWrhwoebOnat169bp1KlT6tChg7Kzs21tevToocTERMXFxSkuLk6JiYmKjo4ukWMAAAAAgPwU+TTC5557Tv/73//0/vvvF3vn7du3V/v27a/Yxs3NTUFBQfmuS09P1/Tp0zV79my1bt1akvTZZ58pNDRUK1euVFRUlJKSkhQXF6cNGzaoUaNGkqSPP/5YkZGR2rVrl+10SAAAAAAoSUUOW5s2bdLq1au1dOlS1a5dO88EGQsWLCix4iRpzZo1CggIULly5dSsWTO9/vrrCggIkCRt3bpV58+fV9u2bW3tQ0JCFBERoYSEBEVFRWn9+vWyWq22oCVJjRs3ltVqVUJCQoFhKysrS1lZWbbnGRkZJXpcAAAAAG5uRQ5b5cqVU5cuXcyoJY/27dvr0UcfVVhYmPbu3atXX31VLVu21NatW+Xm5qaUlBS5urrK19fX7nWBgYFKSUmRJKWkpNjC2aUCAgJsbfIzfvx4jRkzpmQPCAAAAMAto8hha+bMmWbUka/u3bvb/h0REaGGDRsqLCxMy5Ytu2LgMwzjqrMkXt7mciNGjNDQoUNtzzMyMhQaGlrUQwAAAABwiyryBBmlKTg4WGFhYdq9e7ckKSgoSOfOnVNaWppdu6NHjyowMNDW5siRI3m2lZqaamuTHzc3N/n4+Ng9AAAAAKCwijyyFR4efsURob/++qtYBV3JsWPHdPDgQQUHB0uSGjRoIBcXF8XHx6tbt26SpOTkZG3fvl0TJkyQJEVGRio9PV2bNm3SPffcI0nauHGj0tPT1aRJE9NqBQAAAHBrK3LYiomJsXt+/vx5/fLLL4qLi9O///3vIm3r1KlT+vPPP23P9+7dq8TERPn5+cnPz0+jR49W165dFRwcrH379unll1+Wv7+/Hn74YUmS1WpVv379NGzYMJUvX15+fn4aPny46tSpY5udsGbNmmrXrp369++vadOmSZIGDBigDh06MBMhAAAAANNc09Tv+fnggw+0ZcuWIm1ry5YtatGihe157jVSvXv31tSpU7Vt2zbNmjVLJ06cUHBwsFq0aKF58+bJ29vb9pr33ntPzs7O6tatmzIzM9WqVSvFxsbKycnJ1mbOnDkaMmSIbdbCTp06XfHeXgAAAABQXBbDMIyS2NBff/2l+vXr37RTpGdkZMhqtSo9Pd1hr9+6wtmfDqNkPq24lTl6P6APoCTQD3Crc/Q+INEPSlths0GJTZDx1Vdfyc/Pr6Q2BwAAAAAOrcinEd555512E2QYhqGUlBSlpqZqypQpJVocAAAAADiqIoetzp072z0vU6aMKlSooObNm+uOO+4oqboAAAAAwKGV2DVbNzuu2box8GlFcTl6P6APoCTQD3Crc/Q+INEPStt1v2YLAAAAAPB/Cn0aYZkyZa54M2NJslgsunDhQrGLAgAAAABHV+iwtXDhwgLXJSQk6H//+584IxEAAAAALip02HrooYfyLPv99981YsQILVmyRD179tR///vfEi0OAAAAABzVNV2zdfjwYfXv319169bVhQsXlJiYqE8//VSVKlUq6foAAAAAwCEVKWylp6frxRdfVLVq1bRjxw6tWrVKS5YsUUREhFn1AQAAAIBDKvRphBMmTNCbb76poKAgffHFF/meVggAAAAAuKjQ99kqU6aMPDw81Lp1azk5ORXYbsGCBSVW3I2E+2zdGJiDBcXl6P2APoCSQD/Arc7R+4BEPyhthc0GhR7ZeuKJJ6469TsAAAAA4KJCh63Y2FgTywAAAACAm8s1zUYIAAAAALgywhYAAAAAmICwBQAAAAAmIGwBAAAAgAkIWwAAAABgAsIWAAAAAJiAsAUAAAAAJiBsAQAAAIAJCFsAAAAAYALCFgAAAACYgLAFAAAAACYgbAEAAACACQhbAAAAAGACwhYAAAAAmICwBQAAAAAmIGwBAAAAgAkIWwAAAABgAsIWAAAAAJiAsAUAAAAAJiBsAQAAAIAJCFsAAAAAYALCFgAAAACYgLAFAAAAACYgbAEAAACACZxLuwAAAIAisVhKu4LiM4zSrgDAdcDIFgAAAACYgLAFAAAAACYgbAEAAACACQhbAAAAAGACJsgAAAAAHI2jTxRzi0wSw8gWAAAAAJiAsAUAAAAAJiBsAQAAAIAJCFsAAAAAYIJSDVs//PCDOnbsqJCQEFksFi1atMhuvWEYGj16tEJCQuTh4aHmzZtrx44ddm2ysrI0ePBg+fv7y8vLS506ddKhQ4fs2qSlpSk6OlpWq1VWq1XR0dE6ceKEyUcHAAAA4FZWqmHr9OnTqlevniZPnpzv+gkTJujdd9/V5MmTtXnzZgUFBalNmzY6efKkrU1MTIwWLlyouXPnat26dTp16pQ6dOig7OxsW5sePXooMTFRcXFxiouLU2JioqKjo00/PgAAAAC3Loth3BjzLlosFi1cuFCdO3eWdHFUKyQkRDExMXrxxRclXRzFCgwM1Jtvvqmnn35a6enpqlChgmbPnq3u3btLkg4fPqzQ0FB9++23ioqKUlJSkmrVqqUNGzaoUaNGkqQNGzYoMjJSv//+u2rUqFGo+jIyMmS1WpWeni4fH5+S/wFcB44+Q6h0y8wSChM5ej+gD6AkOHw/kIMfgERnLmWO3gekm6AfOHgfKGw2uGGv2dq7d69SUlLUtm1b2zI3Nzc1a9ZMCQkJkqStW7fq/Pnzdm1CQkIUERFha7N+/XpZrVZb0JKkxo0by2q12trkJysrSxkZGXYPAAAAACisGzZspaSkSJICAwPtlgcGBtrWpaSkyNXVVb6+vldsExAQkGf7AQEBtjb5GT9+vO0aL6vVqtDQ0GIdDwAAAIBbyw0btnJZLhvnNQwjz7LLXd4mv/ZX286IESOUnp5uexw8eLCIlQMAAAC4ld2wYSsoKEiS8ow+HT161DbaFRQUpHPnziktLe2KbY4cOZJn+6mpqXlGzS7l5uYmHx8fuwcAAAAAFNYNG7bCw8MVFBSk+Ph427Jz585p7dq1atKkiSSpQYMGcnFxsWuTnJys7du329pERkYqPT1dmzZtsrXZuHGj0tPTbW0AAAAAoKQ5l+bOT506pT///NP2fO/evUpMTJSfn58qVaqkmJgYjRs3TtWrV1f16tU1btw4eXp6qkePHpIkq9Wqfv36adiwYSpfvrz8/Pw0fPhw1alTR61bt5Yk1axZU+3atVP//v01bdo0SdKAAQPUoUOHQs9ECAAAAABFVapha8uWLWrRooXt+dChQyVJvXv3VmxsrF544QVlZmZq4MCBSktLU6NGjbRixQp5e3vbXvPee+/J2dlZ3bp1U2Zmplq1aqXY2Fg5OTnZ2syZM0dDhgyxzVrYqVOnAu/tBQAAAAAl4Ya5z9aNjvts3Rj4tKK4HL0f0AdQEhy+Hzj6/YUkOnMpc/Q+IN0E/cDB+4DD32cLAAAAABwZYQsAAAAATFCq12wBAIropjj3xbFPHQEAoLAY2QIAAAAAExC2AAAAAMAEhC0AAAAAMAFhCwAAAABMQNgCAAAAABMQtgAAAADABIQtAAAAADABYQsAAAAATEDYAgAAAAATELYAAAAAwASELQAAAAAwAWELAAAAAExA2AIAAAAAExC2AAAAAMAEhC0AAAAAMAFhCwAAAABMQNgCAAAAABMQtgAAAADABIQtAAAAADABYQsAAAAATEDYAgAAAAATELYAAAAAwASELQAAAAAwAWELAAAAAExA2AIAAAAAExC2AAAAAMAEhC0AAAAAMAFhCwAAAABMQNgCAAAAABMQtgAAAADABIQtAAAAADABYQsAAAAATOBc2gUARWKxlHYFxWMYpV0BAAAArhNGtgAAAADABIQtAAAAADABYQsAAAAATEDYAgAAAAATELYAAAAAwASELQAAAAAwAWELAAAAAExA2AIAAAAAExC2AAAAAMAEhC0AAAAAMAFhCwAAAABMQNgCAAAAABPc0GFr9OjRslgsdo+goCDbesMwNHr0aIWEhMjDw0PNmzfXjh077LaRlZWlwYMHy9/fX15eXurUqZMOHTp0vQ8FAAAAwC3mhg5bklS7dm0lJyfbHtu2bbOtmzBhgt59911NnjxZmzdvVlBQkNq0aaOTJ0/a2sTExGjhwoWaO3eu1q1bp1OnTqlDhw7Kzs4ujcMBAAAAcItwLu0CrsbZ2dluNCuXYRiaOHGiXnnlFXXp0kWS9OmnnyowMFCff/65nn76aaWnp2v69OmaPXu2WrduLUn67LPPFBoaqpUrVyoqKuq6HgsAAACAW8cNP7K1e/duhYSEKDw8XI899pj++usvSdLevXuVkpKitm3b2tq6ubmpWbNmSkhIkCRt3bpV58+ft2sTEhKiiIgIW5uCZGVlKSMjw+4BAAAAAIV1Q4etRo0aadasWVq+fLk+/vhjpaSkqEmTJjp27JhSUlIkSYGBgXavCQwMtK1LSUmRq6urfH19C2xTkPHjx8tqtdoeoaGhJXhkAAAAAG52N3TYat++vbp27ao6deqodevWWrZsmaSLpwvmslgsdq8xDCPPsssVps2IESOUnp5uexw8ePAajwIAAADAreiGDluX8/LyUp06dbR7927bdVyXj1AdPXrUNtoVFBSkc+fOKS0trcA2BXFzc5OPj4/dAwAAAAAKy6HCVlZWlpKSkhQcHKzw8HAFBQUpPj7etv7cuXNau3atmjRpIklq0KCBXFxc7NokJydr+/bttjYAAAAAYIYbejbC4cOHq2PHjqpUqZKOHj2q1157TRkZGerdu7csFotiYmI0btw4Va9eXdWrV9e4cePk6empHj16SJKsVqv69eunYcOGqXz58vLz89Pw4cNtpyUCAAAAgFlu6LB16NAhPf744/rnn39UoUIFNW7cWBs2bFBYWJgk6YUXXlBmZqYGDhyotLQ0NWrUSCtWrJC3t7dtG++9956cnZ3VrVs3ZWZmqlWrVoqNjZWTk1NpHRYAAACAW4DFMAyjtItwBBkZGbJarUpPT3fY67euMieIQzDk4AdBdyt1jt4PHL4PSPSDGwD94AZAPyhVjt4HpJugHzh4HyhsNnCoa7YAAAAAwFEQtgAAAADABIQtAAAAADABYQsAAAAATEDYAgAAAAATELYAAAAAwASELQAAAAAwAWELAAAAAExA2AIAAAAAExC2AAAAAMAEhC0AAAAAMAFhCwAAAABMQNgCAAAAABMQtgAAAADABIQtAAAAADABYQsAAAAATEDYAgAAAAATELYAAAAAwASELQAAAAAwAWELAAAAAExA2AIAAAAAExC2AAAAAMAEhC0AAAAAMAFhCwAAAABMQNgCAAAAABMQtgAAAADABIQtAAAAADABYQsAAAAATEDYAgAAAAATELYAAAAAwASELQAAAAAwAWELAAAAAExA2AIAAAAAExC2AAAAAMAEhC0AAAAAMAFhCwAAAABMQNgCAAAAABMQtgAAAADABIQtAAAAADABYQsAAAAATEDYAgAAAAATELYAAAAAwASELQAAAAAwAWELAAAAAExA2AIAAAAAExC2AAAAAMAEhC0AAAAAMAFhCwAAAABMcEuFrSlTpig8PFzu7u5q0KCBfvzxx9IuCQAAAMBN6pYJW/PmzVNMTIxeeeUV/fLLL7r//vvVvn17HThwoLRLAwAAAHATshiGYZR2EddDo0aNdNddd2nq1Km2ZTVr1lTnzp01fvz4q74+IyNDVqtV6enp8vHxMbNU01gspV1B8Rly8IO4NbrbDc3R+4HD9wGJfnADoB/cAOgHpcrR+4B0E/QDB+8Dhc0GztexplJz7tw5bd26VS+99JLd8rZt2yohISHf12RlZSkrK8v2PD09XdLFHyxKj8P/9Pn8oJhuik8Q/QDFdFN8gugHKCaH/wQ5eB/IzQRXG7e6JcLWP//8o+zsbAUGBtotDwwMVEpKSr6vGT9+vMaMGZNneWhoqCk1onCspV1AcVkd/ghQym6KTxD9AMV0U3yC6AcoJof/BN0kfeDkyZOyXuFYbomwlcty2ZixYRh5luUaMWKEhg4danuek5Oj48ePq3z58gW+BubKyMhQaGioDh486LCncgLFQR8A6AeARD+4ERiGoZMnTyokJOSK7W6JsOXv7y8nJ6c8o1hHjx7NM9qVy83NTW5ubnbLypUrZ1aJKAIfHx++WHBLow8A9ANAoh+UtiuNaOW6JWYjdHV1VYMGDRQfH2+3PD4+Xk2aNCmlqgAAAADczG6JkS1JGjp0qKKjo9WwYUNFRkbqo48+0oEDB/TMM8+UdmkAAAAAbkK3TNjq3r27jh07prFjxyo5OVkRERH69ttvFRYWVtqloZDc3Nw0atSoPKd3ArcK+gBAPwAk+oEjuWXuswUAAAAA19Mtcc0WAAAAAFxvhC0AAAAAMAFhCwAAAABMQNgCAAAAABMQtnBD69OnjywWiywWi1xcXBQYGKg2bdpoxowZysnJKe3ygOsmJSVFgwcPVpUqVeTm5qbQ0FB17NhRq1atKu3SgOvi0v8PLBaLypcvr3bt2um3334r7dKA6yohIUFOTk5q165daZeCQiBs4YbXrl07JScna9++ffruu+/UokULPffcc+rQoYMuXLhQ2uUBptu3b58aNGig1atXa8KECdq2bZvi4uLUokULDRo0qLTLA66b3P8PkpOTtWrVKjk7O6tDhw6lXRZwXc2YMUODBw/WunXrdODAgdIuB1dxy9xnC47Lzc1NQUFBkqTbbrtNd911lxo3bqxWrVopNjZWTz31VClXCJhr4MCBslgs2rRpk7y8vGzLa9eurb59+5ZiZcD1den/B0FBQXrxxRfVtGlTpaamqkKFCqVcHWC+06dPa/78+dq8ebNSUlIUGxurkSNHlnZZuAJGtuCQWrZsqXr16mnBggWlXQpgquPHjysuLk6DBg2yC1q5ypUrd/2LAm4Ap06d0pw5c1StWjWVL1++tMsBrot58+apRo0aqlGjhnr16qWZM2eKW+be2AhbcFh33HGH9u3bV9plAKb6888/ZRiG7rjjjtIuBSh1S5cuVdmyZVW2bFl5e3tr8eLFmjdvnsqU4dcZ3BqmT5+uXr16Sbp4Wu2pU6e4dvcGx7cTHJZhGLJYLKVdBmCq3L9Y8lkHpBYtWigxMVGJiYnauHGj2rZtq/bt22v//v2lXRpgul27dmnTpk167LHHJEnOzs7q3r27ZsyYUcqV4Uq4ZgsOKykpSeHh4aVdBmCq6tWry2KxKCkpSZ07dy7tcoBS5eXlpWrVqtmeN2jQQFarVR9//LFee+21UqwMMN/06dN14cIF3XbbbbZlhmHIxcVFaWlp8vX1LcXqUBBGtuCQVq9erW3btqlr166lXQpgKj8/P0VFRemDDz7Q6dOn86w/ceLE9S8KuEFYLBaVKVNGmZmZpV0KYKoLFy5o1qxZeuedd2yju4mJifr1118VFhamOXPmlHaJKAAjW7jhZWVlKSUlRdnZ2Tpy5Iji4uI0fvx4dejQQU888URplweYbsqUKWrSpInuuecejR07VnXr1tWFCxcUHx+vqVOnKikpqbRLBK6L3P8PJCktLU2TJ0/WqVOn1LFjx1KuDDDX0qVLlZaWpn79+slqtdqte+SRRzR9+nQ9++yzpVQdroSwhRteXFycgoOD5ezsLF9fX9WrV0/vv/++evfuzUXRuCWEh4fr559/1uuvv65hw4YpOTlZFSpUUIMGDTR16tTSLg+4bnL/P5Akb29v3XHHHfryyy/VvHnz0i0MMNn06dPVunXrPEFLkrp27apx48bp559/1l133VUK1eFKLAbzRQIAAABAiWNYAAAAAABMQNgCAAAAABMQtgAAAADABIQtAAAAADABYQsAAAAATEDYAgAAAAATELYAAAAAwASELQAAAAAwAWELAAAAAExA2AIAmC4lJUWDBw9WlSpV5ObmptDQUHXs2FGrVq0q7dLyFRsbq3LlyhW6fWZmpnx9feXn56fMzEzzCgMAOBTCFgDAVPv27VODBg20evVqTZgwQdu2bVNcXJxatGihQYMGXfN2z58/X6TlZvr6668VERGhWrVqacGCBdd9/8VhGIYuXLhQ2mUAwE2JsAUAMNXAgQNlsVi0adMmPfLII7r99ttVu3ZtDR06VBs2bLC1O3DggB566CGVLVtWPj4+6tatm44cOWJbP3r0aNWvX18zZsywjZAZhiGLxaIPP/xQDz30kLy8vPTaa69JkpYsWaIGDRrI3d1dVapU0ZgxY+xCxYkTJzRgwAAFBgbK3d1dERERWrp0qdasWaMnn3xS6enpslgsslgsGj169BWPcfr06erVq5d69eql6dOn51lvsVj0ySef6OGHH5anp6eqV6+uxYsX29anpaWpZ8+eqlChgjw8PFS9enXNnDlTktS1a1cNHjzY1jYmJkYWi0U7duyQJF24cEHe3t5avny5pIvhacKECapSpYo8PDxUr149ffXVV7bXr1mzRhaLRcuXL1fDhg3l5uamH3/88arvIwDgGhgAAJjk2LFjhsViMcaNG3fFdjk5Ocadd95p3HfffcaWLVuMDRs2GHfddZfRrFkzW5tRo0YZXl5eRlRUlPHzzz8bv/76q5GTk2NIMgICAozp06cbe/bsMfbt22fExcUZPj4+RmxsrLFnzx5jxYoVRuXKlY3Ro0cbhmEY2dnZRuPGjY3atWsbK1asMPbs2WMsWbLE+Pbbb42srCxj4sSJho+Pj5GcnGwkJycbJ0+eLLD2P//803BzczOOHz9uHDt2zHBzczP27Nlj10aSUbFiRePzzz83du/ebQwZMsQoW7ascezYMcMwDGPQoEFG/fr1jc2bNxt79+414uPjjcWLFxuGYRjvv/++ERERYdtW/fr1DX9/f+ODDz4wDMMwEhISDGdnZ1uNL7/8snHHHXcYcXFxxp49e4yZM2cabm5uxpo1awzDMIzvv//ekGTUrVvXWLFihfHnn38a//zzT2HeTgBAERG2AACm2bhxoyHJWLBgwRXbrVixwnBycjIOHDhgW7Zjxw5DkrFp0ybDMC6GLRcXF+Po0aN2r5VkxMTE2C27//778wS82bNnG8HBwYZhGMby5cuNMmXKGLt27cq3npkzZxpWq7VQx/jyyy8bnTt3tj1/6KGHjFdeeSVPjf/5z39sz0+dOmVYLBbju+++MwzDMDp27Gg8+eST+W7/t99+MywWi5GammocP37ccHFxMV577TXj0UcfNQzDMMaNG2c0atTItl13d3cjISHBbhv9+vUzHn/8ccMw/i9sLVq0qFDHBwC4dpxGCAAwjWEYki6eRnclSUlJCg0NVWhoqG1ZrVq1VK5cOSUlJdmWhYWFqUKFCnle37BhQ7vnW7du1dixY1W2bFnbo3///kpOTtaZM2eUmJioihUr6vbbby/O4Sk7O1uffvqpevXqZVvWq1cvffrpp8rOzrZrW7duXdu/vby85O3traNHj0qS/vWvf2nu3LmqX7++XnjhBSUkJNjaRkREqHz58lq7dq1+/PFH1atXT506ddLatWslXTwtsFmzZpKknTt36uzZs2rTpo3dsc+aNUt79uy54s8MAFDynEu7AADAzat69eqyWCxKSkpS586dC2xn/P9rr6623MvLK9/XX748JydHY8aMUZcuXfK0dXd3l4eHRyGP4MqWL1+uv//+W927d7dbnp2drRUrVqh9+/a2ZS4uLnZtLBaLcnJyJEnt27fX/v37tWzZMq1cuVKtWrXSoEGD9Pbbb8tisahp06Zas2aNXF1d1bx5c0VERCg7O1vbtm1TQkKCYmJibMctScuWLdNtt91mtz83Nze75wX9LAEAJYeRLQCAafz8/BQVFaUPPvhAp0+fzrP+xIkTki6OYh04cEAHDx60rdu5c6fS09NVs2bNIu/3rrvu0q5du1StWrU8jzJlyqhu3bo6dOiQ/vjjj3xf7+rqmmdkKj/Tp0/XY489psTERLtHz549850o40oqVKigPn366LPPPtPEiRP10Ucf2dY1b95ca9as0Zo1a9S8eXNZLBbdf//9evvtt5WZmal7771X0sWfo5ubmw4cOJDnuC8dNQQAXB+MbAEATDVlyhQ1adJE99xzj8aOHau6devqwoULio+P19SpU5WUlKTWrVurbt266tmzpyZOnKgLFy5o4MCBatas2TWd7jZy5Eh16NBBoaGhevTRR1WmTBn99ttv2rZtm1577TU1a9ZMTZs2VdeuXfXuu++qWrVq+v3332WxWNSuXTtVrlxZp06d0qpVq1SvXj15enrK09PTbh+pqalasmSJFi9erIiICLt1vXv31oMPPqjU1NR8T3vMr94GDRqodu3aysrK0tKlS+1CZvPmzfXcc8/J2dlZ999/v23ZsGHDdNddd8nHx0eS5O3treHDh+v5559XTk6O7rvvPmVkZCghIUFly5ZV7969i/yzBABcO0a2AACmCg8P188//6wWLVpo2LBhioiIUJs2bbRq1SpNnTpV0sVT6hYtWiRfX181bdpUrVu3VpUqVTRv3rxr2mdUVJSWLl2q+Ph43X333WrcuLHeffddhYWF2dp8/fXXuvvuu/X444+rVq1aeuGFF2yjWU2aNNEzzzyj7t27q0KFCpowYUKefcyaNUteXl5q1apVnnUtWrSQt7e3Zs+eXah6XV1dNWLECNWtW1dNmzaVk5OT5s6da1sfEREhf39/1atXzxasmjVrpuzsbNv1Wrn++9//auTIkRo/frxq1qypqKgoLVmyROHh4YWqBQBQcixG7tXLAAAAAIASw8gWAAAAAJiAsAUAAAAAJiBsAQAAAIAJCFsAAAAAYALCFgAAAACYgLAFAAAAACYgbAEAAACACQhbAAAAAGACwhYAAAAAmICwBQAAAAAmIGwBAAAAgAn+HzBw46uMzCB0AAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 1000x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# A\n",
    "#df_mmlu.drop_duplicates( subset='question_id' , inplace=False).answer.value_counts().plot(kind='barh')\n",
    "\n",
    "df_dist = pd.concat([df_mmlu.drop_duplicates( subset='question_id' , inplace=False).answer.value_counts(), df_other.drop_duplicates( subset='question_id' , inplace=False).answer.value_counts()], axis=1)\n",
    "\n",
    "df_dist.columns = ['MMLU Data', 'Other Data']\n",
    "\n",
    "print(df_dist)\n",
    "\n",
    "ax = df_dist.plot.bar(rot=0, color={\"MMLU Data\": \"blue\", \"Other Data\": \"red\"}, figsize=(10,6))\n",
    "ax.set_xlabel('Correct Answer')\n",
    "ax.set_ylabel('Number of Questions')\n",
    "plt.title('Distribution of Correct Answers in MMLU and Other Data')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "92392cd7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Chi-Square Statistic: 629.3958675644751\n",
      "P-Value: 4.270849602795191e-136\n",
      "Degrees of Freedom: 3\n"
     ]
    }
   ],
   "source": [
    "# B\n",
    "from scipy.stats import chi2_contingency\n",
    "\n",
    "\n",
    "# Null Hypothesis: The distribution of correct answers is independent of the dataset. Alternatively, the distribution of correct answers is the same in both datasets.\n",
    "# Alternative Hypothesis: The distribution of correct answers is dependent on the dataset.\n",
    "\n",
    "chi2, p, dof, ex = chi2_contingency(np.array(df_dist))\n",
    "print('Chi-Square Statistic:', chi2)\n",
    "print('P-Value:', p)\n",
    "print('Degrees of Freedom:', dof)\n",
    "\n",
    "# Since the P-value is less than 0.05, we reject the null hypothesis and conclude that the distribution of correct answers \n",
    "# is dependent on the dataset, and hence they differ for the MMLU dataset and the \"Other dataset\"."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2d3125ad-5a7e-44e7-999a-a0ff99855d39",
   "metadata": {},
   "source": [
    "### 2.3 (7 pt)\n",
    "\n",
    "Let's dive in deeper:\n",
    "\n",
    "A. What is language model X's mean accuracy conditioned on the four answer options for each dataset?\n",
    "\n",
    "B. Compare LM X's performance when the correct answer is \"A\" between the two datasets. Use a T-test with CI = 0.95. What do you conclude?\n",
    "\n",
    "C. Compare LM X's performance when the correct answer is \"A\" vs. \"C or D\" for each dataset. Use a T-test with CI = 0.95. What do you conclude?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "39097a11-8efe-46d1-8bc3-5587bb58d199",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model X and MMLU Data:\n",
      "A: 0.973\n",
      "B: 0.799\n",
      "C: 0.708\n",
      "D: 0.634\n",
      "----------------------------------------------------------------------------------------------------\n",
      "Model X and Other Data:\n",
      "A: 0.974\n",
      "B: 0.806\n",
      "C: 0.676\n",
      "D: 0.604\n"
     ]
    }
   ],
   "source": [
    "# A\n",
    "print('Model X and MMLU Data:')\n",
    "df_mmlu_x = df_mmlu[df_mmlu['model_name'] == 'X']\n",
    "print('A: {:.3f}'.format(df_mmlu_x[df_mmlu_x['answer'] == 'A'].correct.mean()))\n",
    "print('B: {:.3f}'.format(df_mmlu_x[df_mmlu_x['answer'] == 'B'].correct.mean()))\n",
    "print('C: {:.3f}'.format(df_mmlu_x[df_mmlu_x['answer'] == 'C'].correct.mean()))\n",
    "print('D: {:.3f}'.format(df_mmlu_x[df_mmlu_x['answer'] == 'D'].correct.mean()))\n",
    "\n",
    "print('-'*100)\n",
    "print('Model X and Other Data:')\n",
    "df_other_x = df_other[df_other['model_name'] == 'X']\n",
    "print('A: {:.3f}'.format(df_other_x[df_other_x['answer'] == 'A'].correct.mean()))\n",
    "print('B: {:.3f}'.format(df_other_x[df_other_x['answer'] == 'B'].correct.mean()))\n",
    "print('C: {:.3f}'.format(df_other_x[df_other_x['answer'] == 'C'].correct.mean()))\n",
    "print('D: {:.3f}'.format(df_other_x[df_other_x['answer'] == 'D'].correct.mean()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "9ae67c09",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "P-Value for A: 0.8332191972699248\n"
     ]
    }
   ],
   "source": [
    "# B\n",
    "from scipy.stats import ttest_ind\n",
    "\n",
    "#H0: LM X's performance when the correct answer is \"A\" between the two datasets is the same\n",
    "#H1: LM X's performance when the correct answer is \"A\" between the two datasets is different\n",
    "\n",
    "tstat, pval = ttest_ind(df_mmlu_x[df_mmlu_x['answer'] == 'A'].correct, df_other_x[df_other_x['answer'] == 'A'].correct)\n",
    "print('\\nP-Value for A:', pval)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2784c34b",
   "metadata": {},
   "source": [
    "Since the P-Value is greater then 0.05, we accept the null hypothesis H0: the performance of the model X when answer is \"A\" is the same in the 2 datasets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "636af6a6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "P-Value for A vs C/D in MMLU Data: 5.334906497224946e-139\n",
      "P-Value for A vs C/D in Other Data: 5.900859805611251e-96\n"
     ]
    }
   ],
   "source": [
    "# C\n",
    "#H0: LM X's performance when the correct answer is \"A\" vs LM X's performance when the correct answer is \"C or D\" is the same in mmlu\n",
    "\n",
    "df_mmlu_x[df_mmlu_x['answer'] == 'A'].correct.value_counts()\n",
    "df_mmlu_x[(df_mmlu_x['answer'] == 'C') | (df_mmlu_x['answer'] == 'D')].correct.value_counts()\n",
    "\n",
    "df_other_x[df_other_x['answer'] == 'A'].correct.value_counts()\n",
    "df_other_x[(df_other_x['answer'] == 'C') | (df_other_x['answer'] == 'D')].correct.value_counts()\n",
    "\n",
    "tstat, pval = ttest_ind(df_mmlu_x[df_mmlu_x['answer'] == 'A'].correct, df_mmlu_x[(df_mmlu_x['answer'] == 'C') | (df_mmlu_x['answer'] == 'D')].correct)\n",
    "print('P-Value for A vs C/D in MMLU Data:', pval)\n",
    "\n",
    "tstat, pval = ttest_ind(df_other_x[df_other_x['answer'] == 'A'].correct, df_other_x[(df_other_x['answer'] == 'C') | (df_other_x['answer'] == 'D')].correct)\n",
    "print('P-Value for A vs C/D in Other Data:', pval)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3d98d61a",
   "metadata": {},
   "source": [
    "For both of the datasets we can refuse the null hypothesis, because in both of the cases the P-Value is lower than 0.05, meaning that the performance of the model X depends on the correct answer"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "33848ff9-2604-4e48-b5df-3207dc81e9a9",
   "metadata": {},
   "source": [
    "### 2.4 (2 pt)\n",
    "\n",
    "What an intriguing finding! \n",
    "\n",
    "A. Print the mean accuracies conditioned on the correct answer for all LMs for each dataset.\n",
    "\n",
    "B. /Discuss:/ What do you observe?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "ec53ce2c-866e-440a-ac79-7813cb756782",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mean Accuracy for Model X for \"correct\" answer A on MMLU Data 0.97269\n",
      "Mean Accuracy for Model X for \"correct\" answer B on MMLU Data 0.79918\n",
      "Mean Accuracy for Model X for \"correct\" answer C on MMLU Data 0.7079\n",
      "Mean Accuracy for Model X for \"correct\" answer D on MMLU Data 0.63359\n",
      "----------------------------------------------------------------------------------------------------\n",
      "Mean Accuracy for Model X for \"correct\" answer A on Other Data 0.97403\n",
      "Mean Accuracy for Model X for \"correct\" answer B on Other Data 0.80645\n",
      "Mean Accuracy for Model X for \"correct\" answer C on Other Data 0.67641\n",
      "Mean Accuracy for Model X for \"correct\" answer D on Other Data 0.60374\n",
      "----------------------------------------------------------------------------------------------------\n",
      "Mean Accuracy for Model Y for \"correct\" answer A on MMLU Data 0.62384\n",
      "Mean Accuracy for Model Y for \"correct\" answer B on MMLU Data 0.68807\n",
      "Mean Accuracy for Model Y for \"correct\" answer C on MMLU Data 0.73347\n",
      "Mean Accuracy for Model Y for \"correct\" answer D on MMLU Data 0.90425\n",
      "----------------------------------------------------------------------------------------------------\n",
      "Mean Accuracy for Model Y for \"correct\" answer A on Other Data 0.62523\n",
      "Mean Accuracy for Model Y for \"correct\" answer B on Other Data 0.66398\n",
      "Mean Accuracy for Model Y for \"correct\" answer C on Other Data 0.76299\n",
      "Mean Accuracy for Model Y for \"correct\" answer D on Other Data 0.92044\n",
      "----------------------------------------------------------------------------------------------------\n",
      "Mean Accuracy for Model Z for \"correct\" answer A on MMLU Data 0.64308\n",
      "Mean Accuracy for Model Z for \"correct\" answer B on MMLU Data 0.64118\n",
      "Mean Accuracy for Model Z for \"correct\" answer C on MMLU Data 0.66912\n",
      "Mean Accuracy for Model Z for \"correct\" answer D on MMLU Data 0.66114\n",
      "----------------------------------------------------------------------------------------------------\n",
      "Mean Accuracy for Model Z for \"correct\" answer A on Other Data 0.68089\n",
      "Mean Accuracy for Model Z for \"correct\" answer B on Other Data 0.66756\n",
      "Mean Accuracy for Model Z for \"correct\" answer C on Other Data 0.66234\n",
      "Mean Accuracy for Model Z for \"correct\" answer D on Other Data 0.67707\n"
     ]
    }
   ],
   "source": [
    "# A\n",
    "\n",
    "print('Mean Accuracy for Model X for \"correct\" answer A on MMLU Data', df_mmlu_x[df_mmlu_x['answer'] == 'A'].correct.mean().round(5))\n",
    "print('Mean Accuracy for Model X for \"correct\" answer B on MMLU Data', df_mmlu_x[df_mmlu_x['answer'] == 'B'].correct.mean().round(5))\n",
    "print('Mean Accuracy for Model X for \"correct\" answer C on MMLU Data', df_mmlu_x[df_mmlu_x['answer'] == 'C'].correct.mean().round(5))\n",
    "print('Mean Accuracy for Model X for \"correct\" answer D on MMLU Data', df_mmlu_x[df_mmlu_x['answer'] == 'D'].correct.mean().round(5))\n",
    "print('-'*100) \n",
    "print('Mean Accuracy for Model X for \"correct\" answer A on Other Data', df_other_x[df_other_x['answer'] == 'A'].correct.mean().round(5))\n",
    "print('Mean Accuracy for Model X for \"correct\" answer B on Other Data', df_other_x[df_other_x['answer'] == 'B'].correct.mean().round(5))\n",
    "print('Mean Accuracy for Model X for \"correct\" answer C on Other Data', df_other_x[df_other_x['answer'] == 'C'].correct.mean().round(5))\n",
    "print('Mean Accuracy for Model X for \"correct\" answer D on Other Data', df_other_x[df_other_x['answer'] == 'D'].correct.mean().round(5))\n",
    "print('-'*100)\n",
    "df_mmlu_y = df_mmlu[df_mmlu['model_name'] == 'Y']\n",
    "print('Mean Accuracy for Model Y for \"correct\" answer A on MMLU Data', df_mmlu_y[df_mmlu_y['answer'] == 'A'].correct.mean().round(5))\n",
    "print('Mean Accuracy for Model Y for \"correct\" answer B on MMLU Data', df_mmlu_y[df_mmlu_y['answer'] == 'B'].correct.mean().round(5))\n",
    "print('Mean Accuracy for Model Y for \"correct\" answer C on MMLU Data', df_mmlu_y[df_mmlu_y['answer'] == 'C'].correct.mean().round(5))\n",
    "print('Mean Accuracy for Model Y for \"correct\" answer D on MMLU Data', df_mmlu_y[df_mmlu_y['answer'] == 'D'].correct.mean().round(5))\n",
    "print('-'*100)\n",
    "print('Mean Accuracy for Model Y for \"correct\" answer A on Other Data', df_other[df_other['model_name'] == 'Y'][df_other[df_other['model_name'] == 'Y']['answer'] == 'A'].correct.mean().round(5))\n",
    "print('Mean Accuracy for Model Y for \"correct\" answer B on Other Data', df_other[df_other['model_name'] == 'Y'][df_other[df_other['model_name'] == 'Y']['answer'] == 'B'].correct.mean().round(5))\n",
    "print('Mean Accuracy for Model Y for \"correct\" answer C on Other Data', df_other[df_other['model_name'] == 'Y'][df_other[df_other['model_name'] == 'Y']['answer'] == 'C'].correct.mean().round(5))\n",
    "print('Mean Accuracy for Model Y for \"correct\" answer D on Other Data', df_other[df_other['model_name'] == 'Y'][df_other[df_other['model_name'] == 'Y']['answer'] == 'D'].correct.mean().round(5))\n",
    "print('-'*100)\n",
    "df_mmlu_z = df_mmlu[df_mmlu['model_name'] == 'Z']\n",
    "print('Mean Accuracy for Model Z for \"correct\" answer A on MMLU Data', df_mmlu_z[df_mmlu_z['answer'] == 'A'].correct.mean().round(5))\n",
    "print('Mean Accuracy for Model Z for \"correct\" answer B on MMLU Data', df_mmlu_z[df_mmlu_z['answer'] == 'B'].correct.mean().round(5))\n",
    "print('Mean Accuracy for Model Z for \"correct\" answer C on MMLU Data', df_mmlu_z[df_mmlu_z['answer'] == 'C'].correct.mean().round(5))\n",
    "print('Mean Accuracy for Model Z for \"correct\" answer D on MMLU Data', df_mmlu_z[df_mmlu_z['answer'] == 'D'].correct.mean().round(5))\n",
    "print('-'*100)\n",
    "print('Mean Accuracy for Model Z for \"correct\" answer A on Other Data', df_other[df_other['model_name'] == 'Z'][df_other[df_other['model_name'] == 'Z']['answer'] == 'A'].correct.mean().round(5))\n",
    "print('Mean Accuracy for Model Z for \"correct\" answer B on Other Data', df_other[df_other['model_name'] == 'Z'][df_other[df_other['model_name'] == 'Z']['answer'] == 'B'].correct.mean().round(5))\n",
    "print('Mean Accuracy for Model Z for \"correct\" answer C on Other Data', df_other[df_other['model_name'] == 'Z'][df_other[df_other['model_name'] == 'Z']['answer'] == 'C'].correct.mean().round(5))\n",
    "print('Mean Accuracy for Model Z for \"correct\" answer D on Other Data', df_other[df_other['model_name'] == 'Z'][df_other[df_other['model_name'] == 'Z']['answer'] == 'D'].correct.mean().round(5))\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "c2e2683c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.5, 1.0)"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 2000x600 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import seaborn as sns\n",
    "\n",
    "fig, ax = plt.subplots(1, 2, figsize=(20, 6),sharey = True , sharex=True)\n",
    "fig.suptitle(' mean accuracies conditioned on the correct answer for all LMs for each dataset' )\n",
    "order = ['A', 'B', 'C', 'D']\n",
    "sns.barplot(x=\"answer\", y=\"correct\", data=df_mmlu, ax=ax[0], hue='model_name', legend=True, order=order)\n",
    "sns.barplot(x=\"answer\", y=\"correct\", data=df_other, ax=ax[1], hue='model_name', legend=True, order=order)\n",
    "ax[0].set_ylabel('Accuracy')  \n",
    "ax[0].set_title('mmlu')  \n",
    "ax[1].set_title('other')  \n",
    "ax[1].tick_params()\n",
    "plt.ylim(0.5, 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4ce58e47",
   "metadata": {},
   "source": [
    "B. /Discuss:/\n",
    "\n",
    "model_x has a better accuracy when the right answer is A in both other and mmlu, while model_y has a better accuracy when the right answer is D in both other and mmlu. model_z is more balanced in both datasets with an average accuracy lower than the other two models, as clearly shown in the plots."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ccdd9d3c-5a03-4b30-84f7-a7dfbee1373e",
   "metadata": {},
   "source": [
    "### 2.5 (2 pt)\n",
    "\n",
    "Concerned with your findings so far, you quickly consult with Ms. Sakota. After thinking it over, Ms. Sakota concludes that more tests are needed. She orders a second round of MMLU results. However, the clever Ms. Sakota thinks of the following twist: while keeping questions fixed, she randomly permutes the position of the correct answer. The new results can be found in the folder `data/task_2_5/`:\n",
    "```\n",
    "task_2_5/\n",
    "│\n",
    "└── lm_scores_mmlu_shuffle.csv\n",
    "```\n",
    "\n",
    "/Discuss:/ Why would Ms. Sakota do this?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "64cc586a",
   "metadata": {},
   "source": [
    "/Discuss:/\n",
    "\n",
    "Re-testing the models on the permuted answers serves to verify that the models respond according to the content of the answers, independent of the letter corresponding to the right answer."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b9150ae0-dbaa-4c88-bf80-ec03127c6945",
   "metadata": {},
   "source": [
    "### 2.6 (4 pt)\n",
    "\n",
    "Increasingly sceptical of the language models' performance, you read up on proper testing practices. You stumble upon the concept of [test-rested stability](https://en.wikipedia.org/wiki/Repeatability), which roughtly states that:\n",
    "\n",
    "\"_Measurements taken by a single person or instrument on the same item, under the same conditions, and in a short period of time, should have the same results._\"\n",
    "\n",
    "In our case, we would assume an LM would have the same performance on a given question regardless of the correct answer position. One way of testing this is by using the following metric:\n",
    "\n",
    "$$\\text{test-retest metric} = \\frac{1}{N}\\sum_{i=1}^N \\frac{1}{M}\\sum_{j=1}^M c^i_0 c_j^i,$$\n",
    "\n",
    "where $c^i_0 \\in \\{0, 1\\}$ indicates whether the model answers the $i^{\\text{th}}$ question correctly (1 if correct, 0 if incorrect). $c_j^i$ indicates whether the model answers the $i^{\\text{th}}$ question correctly in the $j^{\\text{th}}$ shuffled version of the answer label content. Finally, $M$ is the total number of shuffles and $N$ is the dataset size.\n",
    "\n",
    "Task: compute the test-retest metric for each language model using the original `lm_scores_mmlu.csv` file and the new `lm_scores_mmlu_shuffle.csv` file. Using a bar plot, visualize your results by comparing the accuracy of the original `lm_scores_mmlu.csv` and the test-retest scores.\n",
    "\n",
    "**hints**\n",
    "- what is $M$ in our case?\n",
    "\n",
    "(bonus: no points, but so much sweet, sweet knowledge - check out [the following article](https://arxiv.org/pdf/2406.19470v1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "5b55fcfc-6de9-4cd3-bf2d-bde399ae2fbc",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True    35088\n",
       "Name: count, dtype: int64"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_mmlu_shuffle = pd.read_csv('task_2_5/lm_scores_mmlu_shuffle.csv')\n",
    "#I make sure that each row of the 2 dataframes has the same model_name and the same question_id\n",
    "((df_mmlu['question_id']==df_mmlu_shuffle['question_id']) & (df_mmlu['model_name']==df_mmlu_shuffle['model_name'])).value_counts()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "94517541",
   "metadata": {},
   "outputs": [],
   "source": [
    "#add column correct_shuffle and answer_shuffle and both_correct, and than group by model \n",
    "df_mmlu['correct_shuffle']=df_mmlu_shuffle['correct']\n",
    "df_mmlu['answer_shuffle']=df_mmlu_shuffle['answer']\n",
    "df_mmlu['both_correct']=df_mmlu['correct'] & df_mmlu['correct_shuffle'] \n",
    "df_mmlu_group_model=df_mmlu.groupby('model_name')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "d2a26615-d7ee-421b-81e2-2f456e3daf98",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "metric for Ml_x: 0.588, metric for Ml_y: 0.572 , metric for Ml_z: 0.442  \n"
     ]
    }
   ],
   "source": [
    "def compute_metric(model_name):\n",
    "    df_model=df_mmlu[df_mmlu['model_name']==model_name]\n",
    "    N=df_model.shape[0]\n",
    "    metric = (1/N) * np.sum(df_model['correct'].astype(int) * df_model['correct_shuffle'].astype(int))\n",
    "    return metric\n",
    "print(\"metric for Ml_x: {:.3f}, metric for Ml_y: {:.3f} , metric for Ml_z: {:.3f}  \".format(compute_metric('X'), compute_metric('Y'), compute_metric('Z')))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "81e20201-c849-4950-8eb9-0ab3d24e97e1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1.0, ' accuracy of lm_scores_mmlu.csv vs accuracy of test-retest scores for each language model.')"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fig, ax = plt.subplots(figsize=(10, 6))\n",
    "df_mmlu_shuffle['dataset']='test-retest'\n",
    "df_mmlu['dataset']='mmlu'\n",
    "df_to_show=pd.concat([df_mmlu, df_mmlu_shuffle], axis=0)\n",
    "sns.barplot(x=\"model_name\", ax=ax, y=\"correct\",data=df_to_show, hue=\"dataset\")\n",
    "plt.show()\n",
    "ax.set_title(\" accuracy of lm_scores_mmlu.csv vs accuracy of test-retest scores for each language model.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b70bee6e-0c81-4f5a-b1a8-16a96aa2ae17",
   "metadata": {},
   "source": [
    "### 2.7 (2 pt)\n",
    "\n",
    "A. Using the unshuffled data: For each LM, print the distribution of the answers they give as well as the accuracy conditioned on the answer they give.\n",
    "\n",
    "B. /Discuss:/ Describe what you observe\n",
    "\n",
    "[bonus: not scored, but again _that sweet, sweet knowledge_] Could you think of a plausible explanation?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "4956581b-d047-46cb-ae71-1508a9a0b466",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Distribution of Answers for Model X and MMLU Data: result\n",
      "A    4259\n",
      "B    2659\n",
      "C    2409\n",
      "D    2369\n",
      "Name: count, dtype: int64\n",
      "Accuracy of Model X on MMLU Data for Answer A: 0.36792674336698755\n",
      "Accuracy of Model X on MMLU Data for Answer B: 0.884543061301241\n",
      "Accuracy of Model X on MMLU Data for Answer C: 1.0\n",
      "Accuracy of Model X on MMLU Data for Answer D: 1.0\n",
      "----------------------------------------------------------------------------------------------------\n",
      "Distribution of Answers for Model X and Other Data: result\n",
      "A    1766\n",
      "B     981\n",
      "C     625\n",
      "D     387\n",
      "Name: count, dtype: int64\n",
      "Accuracy of Model X on Other Data for Answer A: 0.594563986409966\n",
      "Accuracy of Model X on Other Data for Answer B: 0.9174311926605505\n",
      "Accuracy of Model X on Other Data for Answer C: 1.0\n",
      "Accuracy of Model X on Other Data for Answer D: 1.0\n",
      "----------------------------------------------------------------------------------------------------\n",
      "Distribution of Answers for Model Y and MMLU Data: result\n",
      "D    5353\n",
      "C    3015\n",
      "B    2256\n",
      "A    1072\n",
      "Name: count, dtype: int64\n",
      "Accuracy of Model Y on MMLU Data for Answer A: 0.9375\n",
      "Accuracy of Model Y on MMLU Data for Answer B: 0.8976063829787234\n",
      "Accuracy of Model Y on MMLU Data for Answer C: 0.8278606965174129\n",
      "Accuracy of Model Y on MMLU Data for Answer D: 0.6316084438632542\n",
      "----------------------------------------------------------------------------------------------------\n",
      "Distribution of Answers for Model Y and Other Data: result\n",
      "D    1356\n",
      "C     909\n",
      "B     802\n",
      "A     692\n",
      "Name: count, dtype: int64\n",
      "Accuracy of Model Y on Other Data for Answer A: 0.9739884393063584\n",
      "Accuracy of Model Y on Other Data for Answer B: 0.9239401496259352\n",
      "Accuracy of Model Y on Other Data for Answer C: 0.7755775577557755\n",
      "Accuracy of Model Y on Other Data for Answer D: 0.4351032448377581\n",
      "----------------------------------------------------------------------------------------------------\n",
      "Distribution of Answers for Model Z and MMLU Data: result\n",
      "D    3398\n",
      "C    3237\n",
      "B    2885\n",
      "A    2176\n",
      "Name: count, dtype: int64\n",
      "Accuracy of Model Z on MMLU Data for Answer A: 0.47610294117647056\n",
      "Accuracy of Model Z on MMLU Data for Answer B: 0.6540727902946274\n",
      "Accuracy of Model Z on MMLU Data for Answer C: 0.7034291010194624\n",
      "Accuracy of Model Z on MMLU Data for Answer D: 0.7274867569158329\n",
      "----------------------------------------------------------------------------------------------------\n",
      "Distribution of Answers for Model Z and Other Data: result\n",
      "A    1034\n",
      "B    1004\n",
      "C     931\n",
      "D     790\n",
      "Name: count, dtype: int64\n",
      "Accuracy of Model Z on Other Data for Answer A: 0.7098646034816247\n",
      "Accuracy of Model Z on Other Data for Answer B: 0.7420318725099602\n",
      "Accuracy of Model Z on Other Data for Answer C: 0.6573576799140709\n",
      "Accuracy of Model Z on Other Data for Answer D: 0.549367088607595\n"
     ]
    }
   ],
   "source": [
    "# A\n",
    "print(f'Distribution of Answers for Model X and MMLU Data: {df_mmlu_x[\"result\"].value_counts()}')\n",
    "print(f'Accuracy of Model X on MMLU Data for Answer A: {df_mmlu_x[df_mmlu_x[\"result\"] == \"A\"][\"correct\"].mean()}')\n",
    "print(f'Accuracy of Model X on MMLU Data for Answer B: {df_mmlu_x[df_mmlu_x[\"result\"] == \"B\"][\"correct\"].mean()}')\n",
    "print(f'Accuracy of Model X on MMLU Data for Answer C: {df_mmlu_x[df_mmlu_x[\"result\"] == \"C\"][\"correct\"].mean()}')\n",
    "print(f'Accuracy of Model X on MMLU Data for Answer D: {df_mmlu_x[df_mmlu_x[\"result\"] == \"D\"][\"correct\"].mean()}')\n",
    "print('-'*100)\n",
    "print(f'Distribution of Answers for Model X and Other Data: {df_other_x[\"result\"].value_counts()}')\n",
    "print(f'Accuracy of Model X on Other Data for Answer A: {df_other_x[df_other_x[\"result\"] == \"A\"][\"correct\"].mean()}')\n",
    "print(f'Accuracy of Model X on Other Data for Answer B: {df_other_x[df_other_x[\"result\"] == \"B\"][\"correct\"].mean()}')\n",
    "print(f'Accuracy of Model X on Other Data for Answer C: {df_other_x[df_other_x[\"result\"] == \"C\"][\"correct\"].mean()}')\n",
    "print(f'Accuracy of Model X on Other Data for Answer D: {df_other_x[df_other_x[\"result\"] == \"D\"][\"correct\"].mean()}')\n",
    "print('-'*100)\n",
    "\n",
    "\n",
    "print(f'Distribution of Answers for Model Y and MMLU Data: {df_mmlu_y[\"result\"].value_counts()}')\n",
    "print(f'Accuracy of Model Y on MMLU Data for Answer A: {df_mmlu_y[df_mmlu_y[\"result\"] == \"A\"][\"correct\"].mean()}')\n",
    "print(f'Accuracy of Model Y on MMLU Data for Answer B: {df_mmlu_y[df_mmlu_y[\"result\"] == \"B\"][\"correct\"].mean()}')\n",
    "print(f'Accuracy of Model Y on MMLU Data for Answer C: {df_mmlu_y[df_mmlu_y[\"result\"] == \"C\"][\"correct\"].mean()}')\n",
    "print(f'Accuracy of Model Y on MMLU Data for Answer D: {df_mmlu_y[df_mmlu_y[\"result\"] == \"D\"][\"correct\"].mean()}')\n",
    "print('-'*100)\n",
    "print(f'Distribution of Answers for Model Y and Other Data: {df_other[df_other[\"model_name\"] == \"Y\"][\"result\"].value_counts()}')\n",
    "df_other_y = df_other[df_other[\"model_name\"] == \"Y\"]\n",
    "print(f'Accuracy of Model Y on Other Data for Answer A: {df_other_y[df_other_y[\"result\"] == \"A\"][\"correct\"].mean()}')\n",
    "print(f'Accuracy of Model Y on Other Data for Answer B: {df_other_y[df_other_y[\"result\"] == \"B\"][\"correct\"].mean()}')\n",
    "print(f'Accuracy of Model Y on Other Data for Answer C: {df_other_y[df_other_y[\"result\"] == \"C\"][\"correct\"].mean()}')\n",
    "print(f'Accuracy of Model Y on Other Data for Answer D: {df_other_y[df_other_y[\"result\"] == \"D\"][\"correct\"].mean()}')\n",
    "print('-'*100)\n",
    "\n",
    "\n",
    "print(f'Distribution of Answers for Model Z and MMLU Data: {df_mmlu_z[\"result\"].value_counts()}')\n",
    "print(f'Accuracy of Model Z on MMLU Data for Answer A: {df_mmlu_z[df_mmlu_z[\"result\"] == \"A\"][\"correct\"].mean()}')\n",
    "print(f'Accuracy of Model Z on MMLU Data for Answer B: {df_mmlu_z[df_mmlu_z[\"result\"] == \"B\"][\"correct\"].mean()}')\n",
    "print(f'Accuracy of Model Z on MMLU Data for Answer C: {df_mmlu_z[df_mmlu_z[\"result\"] == \"C\"][\"correct\"].mean()}')\n",
    "print(f'Accuracy of Model Z on MMLU Data for Answer D: {df_mmlu_z[df_mmlu_z[\"result\"] == \"D\"][\"correct\"].mean()}')\n",
    "print('-'*100)\n",
    "df_other_z = df_other[df_other[\"model_name\"] == \"Z\"]\n",
    "print(f'Distribution of Answers for Model Z and Other Data: {df_other[df_other[\"model_name\"] == \"Z\"][\"result\"].value_counts()}')\n",
    "print(f'Accuracy of Model Z on Other Data for Answer A: {df_other_z[df_other_z[\"result\"] == \"A\"][\"correct\"].mean()}')\n",
    "print(f'Accuracy of Model Z on Other Data for Answer B: {df_other_z[df_other_z[\"result\"] == \"B\"][\"correct\"].mean()}')\n",
    "print(f'Accuracy of Model Z on Other Data for Answer C: {df_other_z[df_other_z[\"result\"] == \"C\"][\"correct\"].mean()}')\n",
    "print(f'Accuracy of Model Z on Other Data for Answer D: {df_other_z[df_other_z[\"result\"] == \"D\"][\"correct\"].mean()}')\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "65639228",
   "metadata": {},
   "source": [
    "B. /Discuss:/\n",
    "\n",
    "From the results found, Model X has significant performances when the correct answer is \"B\", \"C\" or \"D\", but low when the answer is \"A\". There is also a high variance in the accuracy of the prediction depending on the correct answer.\n",
    "\n",
    "Model Y has good performances when the correct answers are \"A\", \"B\" or \"C\", but performs worse for answer \"D\". With a comparatively lower variance than Model X.\n",
    "\n",
    "Model Z performs comparatively worse than the other models on average. Model Z is also the only one that shows a significant difference in accuracy between the two datasets."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ce3186fe-ef8e-4af3-9a07-a6081d454e5a",
   "metadata": {},
   "source": [
    "## Task 3 (16 points): What do Questions and Answers look like for a Language Model?\n",
    "\n",
    "While you feel pretty good about the tests you conducted so far, something still bothers you: what if the language models don't see the data like you do? Suddenly, you receive a phone call from a wise AI sage in the West, _Westoda_:\n",
    "\n",
    "```\n",
    "\"Hmm, correct you are, young padawan, to question how the world is seen by large language models! Simple 'text' it is not, hmm? No, no, no! Characters and words, the way of puny humans, this is not, heh heh heh.\n",
    "\n",
    "'Tokens', they use, yes! Mysterious and powerful, these tokens are. Expand our vocabulary, they do, beyond the simple 'a to Z'. Chunky blocks of text, they become, yes! 'Hello world', a simple phrase it may seem. But to a language model, '[24912, 2375]' it might appear, yes! Confusing, it is, hmm?\n",
    "\n",
    "Wise, it would be, to explore these MMLU data points through the eyes of a language model, you think? Yes, yes! Much to learn, there is. The ways of the tokens, understand you must, if truly comprehend the great LMs, you wish to.\n",
    "Meditate on this, you should. The force of natural language processing, strong it is. But patience, you must have, my young padawan. For only through great study and contemplation, will the mysteries of the tokens reveal themselves to you, they will. Yes, hmmm!\"\n",
    "```\n",
    "\n",
    "Admittingly, Westoda at times speaks in riddles… However, he was explaining a crucial aspect of modern LMs called [Tokenization](https://learn.microsoft.com/en-us/dotnet/ai/conceptual/understanding-tokens):\n",
    "\n",
    "\n",
    "“Tokens are words, character sets, or combinations of words and punctuation that are used by [language models (LMs)] to decompose text into. Tokenization is the first step in training”\n",
    "\n",
    "Instead of characters, LMs process natural language using “tokens”. While this is useful for a number of reasons, it does at times introduce some “unintuitive” behavior…"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "e2c66517-938b-4331-9eea-1b23fe4ad9e7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "humans see: \"hello world\" --> language models see: [24912, 2375]\n"
     ]
    }
   ],
   "source": [
    "# PROVIDED CODE\n",
    "\n",
    "try:\n",
    "    import tiktoken\n",
    "except Exception as e:\n",
    "    print('installing tiktoken package')\n",
    "    \n",
    "    !pip install tiktoken\n",
    "    \n",
    "    import tiktoken\n",
    "\n",
    "def tokenize_text(s):\n",
    "    enc = tiktoken.encoding_for_model('gpt-4o')\n",
    "    tokens = enc.encode(str(s))\n",
    "    return tokens\n",
    "\n",
    "example_string = 'hello world'\n",
    "print(f'humans see: \"{example_string}\" --> language models see: {tokenize_text(example_string)}')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3c8019ee-7d52-496f-afff-c96f2f9db08c",
   "metadata": {},
   "source": [
    "### 3.1 (5 pt)\n",
    "\n",
    "Use the provided code in the cell above to \"see the world through the eyes of a language model\":\n",
    "\n",
    "A. Tokenize the questions of the original MMLU data provided in task 1: `task_1/mmlu_data/test.csv` and plot the token distribution (the frequency of each token).\n",
    "\n",
    "B. Same as (A), but now for the answers in columns (columns \"A\", \"B\", \"C\", and \"D\").\n",
    "\n",
    "C. Isolate the tokens for the strings \"A\", \"B\", \"C\", and \"D\", then, for their occurances in both questions and answers, print their relative distribution to each other.\n",
    "\n",
    "**hint**\n",
    "- There are a _lot_ of tokens, consider using a cutoff point and log scale\n",
    "- For (c), they should sum to 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "a9a1e97b-3a31-41b1-a9c3-fb84cb1740d9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "all_questions=df_test['question']\n",
    "#tokenize_question: list as long as the number of questions.\n",
    "#the 'list element in position i contains the tokens related to the i th question\n",
    "tokenize_question=list(all_questions.map(lambda x:tokenize_text(x)))\n",
    "array_cumulative=plt.hist(np.concatenate(tokenize_question), bins=100,log=True,histtype='step')\n",
    "plt.title('Histogram of token distribution in questions')\n",
    "plt.ylabel('# of token (log scale)')\n",
    "plt.xlabel('token')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "fe1f8be8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.loglog(array_cumulative[1][1:],array_cumulative[0])\n",
    "plt.title('Histogram of token distribution')\n",
    "plt.ylabel('# of token (log scale)')\n",
    "plt.xlabel('token (log scale)')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "cd392df7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# same as above, but for the columns answers(A,B,C,D) instead of question\n",
    "all_question_A=df_test['A']\n",
    "all_question_B=df_test['B']\n",
    "all_question_C=df_test['C']\n",
    "all_question_D=df_test['D']\n",
    "\n",
    "tokenize_question_A=list(all_question_A.map(lambda x:tokenize_text(x)))\n",
    "tokenize_question_B=list(all_question_B.map(lambda x:tokenize_text(x)))\n",
    "tokenize_question_C=list(all_question_C.map(lambda x:tokenize_text(x)))\n",
    "tokenize_question_D=list(all_question_D.map(lambda x:tokenize_text(x)))\n",
    "\n",
    "tokenize_question_arr_A= np.concatenate(tokenize_question_A)\n",
    "tokenize_question_arr_B= np.concatenate(tokenize_question_B)\n",
    "tokenize_question_arr_C= np.concatenate(tokenize_question_C)\n",
    "tokenize_question_arr_D= np.concatenate(tokenize_question_D)\n",
    "\n",
    "#Merge the tokens of all answers and show in a histogram \n",
    "tokenize_all_question=np.concatenate((tokenize_question_arr_A, tokenize_question_arr_B,tokenize_question_arr_C,tokenize_question_arr_D))\n",
    "plt.hist(tokenize_all_question, bins=100,log=True,histtype='step')\n",
    "plt.title('Histogram of token distribution in ansewrs')\n",
    "plt.ylabel('# of token (log scale)')\n",
    "plt.xlabel('token')\n",
    "plt.show()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "4655c064-e722-4258-9125-09632fe91d63",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "relative distribution:  A_token:  79.17%  B_token:  6.02%,  C_token:  10.15%,  D_token:  4.66%\n"
     ]
    }
   ],
   "source": [
    "# C\n",
    "A_TOKENIZED=tokenize_text('A')[0]\n",
    "B_TOKENIZED=tokenize_text('B')[0]\n",
    "C_TOKENIZED=tokenize_text('C')[0]\n",
    "D_TOKENIZED=tokenize_text('D')[0]\n",
    "\n",
    "#question_answers_pair_tokenized : list as long as the number of questions.\n",
    "#the 'list element in position i contains the tokens related to the i th question and answer 'A', 'B' 'C', 'D'\n",
    "question_answers_pair_tokenized= [q+a+b+c+d for q, a, b, c, d in zip(tokenize_question,\n",
    "tokenize_question_A,\n",
    "tokenize_question_B,\n",
    "tokenize_question_C,\n",
    "tokenize_question_D\n",
    ")]\n",
    "\n",
    "#each list contains at index i the number of occurrences of that token in question-answers pair at row i of database\n",
    "A_occurrences=[]\n",
    "B_occurrences=[]\n",
    "C_occurrences=[]\n",
    "D_occurrences=[]\n",
    "\n",
    "#contains at index i the  total number of token in question-answers pair at row i of database\n",
    "number_of_total_token=[]\n",
    "\n",
    "#calculate the occurrences of A_TOKENIZED, B_TOKENIZED, C_TOKENIZED,D_TOKENIZED in eaach question-answers pair\n",
    "for index, pair in enumerate(question_answers_pair_tokenized):\n",
    "    A_occurrences.append(pair.count(A_TOKENIZED))\n",
    "    B_occurrences.append(pair.count(B_TOKENIZED))\n",
    "    C_occurrences.append(pair.count(C_TOKENIZED))\n",
    "    D_occurrences.append(pair.count(D_TOKENIZED))\n",
    "    number_of_total_token.append(len(pair))\n",
    "total_occurrences_A=sum(A_occurrences)\n",
    "total_occurrences_B=sum(B_occurrences)\n",
    "total_occurrences_C=sum(C_occurrences)\n",
    "total_occurrences_D=sum(D_occurrences)\n",
    "total_occurrences=total_occurrences_A+total_occurrences_B+total_occurrences_C+total_occurrences_D\n",
    "print(\"relative distribution:  A_token:  {:.2f}%  B_token:  {:.2f}%,  C_token:  {:.2f}%,  D_token:  {:.2f}%\".format( 100* total_occurrences_A/total_occurrences,  100* total_occurrences_B/total_occurrences, 100* total_occurrences_C/total_occurrences, 100* total_occurrences_D/total_occurrences))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a674929c-68e1-4cd8-97b3-efa0cdae4874",
   "metadata": {},
   "source": [
    "### 3.2 (3 pt)\n",
    "\n",
    "What if the number of \"A\", \"B\", \"C\", and \"D\" tokens in the question and answer pairs could influence a language model's decisions?\n",
    "\n",
    "A. For each combined question-answers pair, compute: \n",
    "1. the number of \"A\", \"B\", \"C\", and \"D\" tokens; and\n",
    "2. the total number of tokens.\n",
    "3. then, group by the \"correct\" answer and compute the mean frequency of A, B, C, and D tokens and the total number of tokens. \n",
    "4. finally, print your results\n",
    "\n",
    "B. /Discuss:/ What do you think of the hypothesis that the frequency of A, B, C, and D tokens could influence answers?\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "53426de3",
   "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>frequency_token_A</th>\n",
       "      <th>frequency_token_B</th>\n",
       "      <th>frequency_token_C</th>\n",
       "      <th>frequency_token_D</th>\n",
       "      <th>mean_total_tokens</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>answer</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>A</th>\n",
       "      <td>0.243017</td>\n",
       "      <td>0.018932</td>\n",
       "      <td>0.025140</td>\n",
       "      <td>0.013035</td>\n",
       "      <td>93.187151</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>B</th>\n",
       "      <td>0.231947</td>\n",
       "      <td>0.019642</td>\n",
       "      <td>0.029463</td>\n",
       "      <td>0.012709</td>\n",
       "      <td>88.846332</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>C</th>\n",
       "      <td>0.226410</td>\n",
       "      <td>0.018984</td>\n",
       "      <td>0.034897</td>\n",
       "      <td>0.015355</td>\n",
       "      <td>92.653825</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>D</th>\n",
       "      <td>0.242850</td>\n",
       "      <td>0.014566</td>\n",
       "      <td>0.030985</td>\n",
       "      <td>0.014301</td>\n",
       "      <td>92.110169</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "        frequency_token_A  frequency_token_B  frequency_token_C  \\\n",
       "answer                                                            \n",
       "A                0.243017           0.018932           0.025140   \n",
       "B                0.231947           0.019642           0.029463   \n",
       "C                0.226410           0.018984           0.034897   \n",
       "D                0.242850           0.014566           0.030985   \n",
       "\n",
       "        frequency_token_D  mean_total_tokens  \n",
       "answer                                        \n",
       "A                0.013035          93.187151  \n",
       "B                0.012709          88.846332  \n",
       "C                0.015355          92.653825  \n",
       "D                0.014301          92.110169  "
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# A\n",
    "\n",
    "#for each question-answers pair add the nummber of token_A, token_B, token_C , token_D \n",
    "#and the total number of token , all the values are calculated abboce\n",
    "\n",
    "df_test['num_A_token']=A_occurrences\n",
    "df_test['num_B_token']=B_occurrences\n",
    "df_test['num_C_token']=C_occurrences\n",
    "df_test['num_D_token']=D_occurrences\n",
    "df_test['num_total_token']=number_of_total_token\n",
    "for index, row in df_test.iterrows():\n",
    "    #print(\"num of token A: {}, num of token B: {} , num of token C: {} ,  num of token D: {} ,  num of token: {} \".format(row['num_A_token'] ,row['num_B_token'] ,row['num_C_token'] ,row['num_D_token'], row['num_total_token']))\n",
    "    pass\n",
    "\n",
    "#group by correct answer\n",
    "df_test_answer=df_test.groupby('answer')[['num_A_token', 'num_B_token', 'num_C_token','num_D_token', 'num_total_token']].agg(['mean'])\n",
    "#rename columns for bettere visualizationss\n",
    "df_test_answer.columns = ['frequency_token_A', 'frequency_token_B', 'frequency_token_C', 'frequency_token_D', 'mean_total_tokens']\n",
    "\n",
    "df_test_answer\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3ea8a279",
   "metadata": {},
   "source": [
    "B. /Discuss:/\n",
    "\n",
    "Since the frequency of frequency_token_A frequency_token_B frequency_token_C frequency_token_D is the nearly the same regardless the correct answers, we believe they don't influence the response"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "af25ef95-d2ce-4112-87f7-8b0a52755e2a",
   "metadata": {},
   "source": [
    "### 3.3 (4 pt)\n",
    "\n",
    "Three of the most important considerations when deciding between language models are:\n",
    "\n",
    "Quality\n",
    "Costs\n",
    "Speed\n",
    "\n",
    "So far, much of your analysis has focused on quality. However, the government has indicated that they are quite concerned about both the total costs and speed as well. Specifically, it has been brought to their attention that a new `turbo` model has been launched! \n",
    "\n",
    "This model is both cheaper and faster than the models you evaluated so far. However, there is a catch: the context length* is much smaller than that of the other LMS. Namely, it can only process **300** tokens during inference. Meanwhile, the other models can process up to 100K tokens! \n",
    "\n",
    "*_The “context length” refers to the number of tokens that can be given to an LM as input._\n",
    "\n",
    "A. Are there subjects where using the cheaper model might be problematic? I.e., where part of the question and answer(s) might not fit completely in the context?\n",
    "\n",
    "B. /Discuss:/ Can you think of a strategy that would balance the needs of the government?\n",
    "\n",
    "**hint**:\n",
    "- An LM needs to have both the question and the different answer options in its context"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "a88a6fa3-2735-44d7-9944-076cc9f679ed",
   "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>#_question_answers_exceed</th>\n",
       "      <th>#_question_exceed</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>subject</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>college medicine</th>\n",
       "      <td>5</td>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>high school computer science</th>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>high school european history</th>\n",
       "      <td>93</td>\n",
       "      <td>66</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>high school statistics</th>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>high school us history</th>\n",
       "      <td>85</td>\n",
       "      <td>46</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>high school world history</th>\n",
       "      <td>122</td>\n",
       "      <td>92</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>professional law</th>\n",
       "      <td>315</td>\n",
       "      <td>113</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>professional medicine</th>\n",
       "      <td>14</td>\n",
       "      <td>8</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>security studies</th>\n",
       "      <td>4</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>virology</th>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                              #_question_answers_exceed  #_question_exceed\n",
       "subject                                                                   \n",
       "college medicine                                      5                  5\n",
       "high school computer science                          1                  0\n",
       "high school european history                         93                 66\n",
       "high school statistics                                1                  0\n",
       "high school us history                               85                 46\n",
       "high school world history                           122                 92\n",
       "professional law                                    315                113\n",
       "professional medicine                                14                  8\n",
       "security studies                                      4                  0\n",
       "virology                                              1                  0"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#add a column corresponding to the number of token contained in the questiomn\n",
    "df_test['total_token_question']=list(map(lambda x: len(x), tokenize_question))\n",
    "\n",
    "#add a column exceed_max, the value if true if the number of token in that question-answers pair exceeds the limit\n",
    "df_test['exceed_max']=df_test['num_total_token']>300\n",
    "\n",
    "#add a column question_exceed_max, the value if true if the number of token in the question only exceeds the limit\n",
    "df_test['question_exceed_max']=df_test['total_token_question']>300\n",
    "\n",
    "#group by subject and show how many question-answers pair exceed the limit buy sum exceed_max value\n",
    "df_test_subject=df_test.groupby('subject')[['exceed_max', 'question_exceed_max']].agg(['sum'])\n",
    "df_test_subject.columns = ['#_question_answers_exceed', '#_question_exceed']\n",
    "\n",
    "df_test_subject[df_test_subject['#_question_answers_exceed']>0]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "47f8a44a",
   "metadata": {},
   "source": [
    "B. /Dicsuss:/\n",
    "\n",
    "The best strategy is to use the fast model for all subjects that have short questions and answer, while the old slower model is necessary for subject that have a significant percentage of long answers and questions. The number of questions and answers that exceed the 300 tokens must be therefore confronted with the total number of questions to fully understand the relevance of those questions. If the percentage is very slow and we can afford to lose some accuracy, the government could think about dropping some questions/answers (this strictly depends on the requirements of the model)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "110f07bf-558f-467c-8f66-d88db561d455",
   "metadata": {},
   "source": [
    "### 3.4 (4 pt)\n",
    "\n",
    "/Discuss:/ The time has come to give your final recommendation on the use of LMs in education to the government! Taking into account everything you analyzed in all the preceding tasks (1, 2, and 3), please write a short recommendation consisting of 4 bullet points discussing your concerns.\n",
    "\n",
    "**hint**\n",
    "- Try to use the MECE framework: _Mutually Exclusive Collectively Exhaustive_"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "434a5fa5",
   "metadata": {},
   "source": [
    "/Discuss:/\n",
    "1. For a correct analysis, data must be cleaned and tested, and models should be balanced to have an accurate view. 'Not Sure' answers or similar should be taken into account to get a full evaluation of a model.\n",
    "\n",
    "2. To get an accurate evaluation of the models, it is important to do testing on different datasets as shown in point 2.1 B)\n",
    "\n",
    "3. \n",
    "\n",
    "4. Use different models based on the requirements of the data. i.e. use the fast model for subjects that don't require long questions and answers, and the slower one only when it's needed."
   ]
  }
 ],
 "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.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}