02-results-analysis.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Resource System Ordering Analysis"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import scipy.stats as stats\n",
    "import numpy as np\n",
    "import csv\n",
    "import glob\n",
    "import os"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Experiment Config"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_folder(folder):\n",
    "    if not os.path.exists(f'figs/results/{folder}'):\n",
    "        os.mkdir(f'figs/results/{folder}')  \n",
    "        print(\"Directory '% s' created\" % folder)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 400,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "NDCG@100\n"
     ]
    }
   ],
   "source": [
    "# Parameters configuration\n",
    "task = 'fullrank'\n",
    "metric = 'ndcg_cut_100' # 'map' or 'ndcg_cut_1000'\n",
    "\n",
    "# create plots folder\n",
    "# create_folder(folder=metric)\n",
    "\n",
    "# This snipp code should be updated later.\n",
    "if '_' in metric:\n",
    "    cut_off = metric.split('_')[2] # '1000'\n",
    "    plot_metric = metric.split('_')[0].upper()\n",
    "    plot_metric = plot_metric + '@' + cut_off\n",
    "else:\n",
    "    cut_off = ''\n",
    "    # plot_metric = metric.upper()\n",
    "    plot_metric = metric\n",
    "\n",
    "print(plot_metric)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 401,
   "metadata": {},
   "outputs": [],
   "source": [
    "# version = 'final'\n",
    "result_format = 'ndcgeval' # 'treceval' or 'ndcgeval'\n",
    "# File path\n",
    "metadata_file = 'metadata/metadata'\n",
    "# year = \"DL-20\"\n",
    "year = \"2022\"\n",
    "dl_year = \"dl\"+year"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 402,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TREC DL Past Years\n",
    "nist_qrel_file = f\"TREC-DLs-files/TREC-DL-{year}/qrels-pass.txt\"\n",
    "\n",
    "full_nist_result_file = f'final-results/all.pass.{dl_year}.{result_format}'\n",
    "partial_resource_result_file = f'final-results/all.pass.{dl_year}.SynDL.partial.{result_format}'\n",
    "full_resource_result_file = f'final-results/all.pass.{dl_year}.SynDL.full.{result_format}'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Loading metadata\n",
    "Loading the metadata file to create a dictionary of runid to subtask, loading the metadata_models file to have the pipeline structure, adding the subtask info to metadata models dataframe"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 403,
   "metadata": {},
   "outputs": [],
   "source": [
    "runid_to_subtasks = dict()\n",
    "with open(metadata_file, 'rt', encoding = 'utf8') as f:\n",
    "    reader = csv.reader(f, delimiter = ':')\n",
    "    for [runid, group, _, _, _, _, maintask, _, subtask, _, _, _, _, model, _, _, _, _] in reader:\n",
    "        runid_to_subtasks[runid] = subtask.split('-')[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 404,
   "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>run_id</th>\n",
       "      <th>LLM</th>\n",
       "      <th>pipeline</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>colbertv2</td>\n",
       "      <td>-</td>\n",
       "      <td>Colbert-v2 and using pre-trained checkpoint an...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>cip_run_7</td>\n",
       "      <td>MonoT5/GPT-3.5</td>\n",
       "      <td>Unicoil+doct5query (pyserini)%0A2. MonoT5-3b (...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>cip_run_1</td>\n",
       "      <td>MonoT5/GPT-3.5/GPT-4</td>\n",
       "      <td>Unicoil+doct5query (pyserini)%0A2. MonoT5-3b (...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>cip_run_2</td>\n",
       "      <td>MonoT5/GPT-3.5/GPT-4</td>\n",
       "      <td>Unicoil+doct5query (pyserini)%0A2. MonoT5-3b (...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>cip_run_3</td>\n",
       "      <td>MonoT5/GPT-3.5</td>\n",
       "      <td>Unicoil+doct5query (pyserini)%0A2. MonoT5-3b (...</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      run_id                   LLM  \\\n",
       "0  colbertv2                     -   \n",
       "1  cip_run_7        MonoT5/GPT-3.5   \n",
       "2  cip_run_1  MonoT5/GPT-3.5/GPT-4   \n",
       "3  cip_run_2  MonoT5/GPT-3.5/GPT-4   \n",
       "4  cip_run_3        MonoT5/GPT-3.5   \n",
       "\n",
       "                                            pipeline  \n",
       "0  Colbert-v2 and using pre-trained checkpoint an...  \n",
       "1  Unicoil+doct5query (pyserini)%0A2. MonoT5-3b (...  \n",
       "2  Unicoil+doct5query (pyserini)%0A2. MonoT5-3b (...  \n",
       "3  Unicoil+doct5query (pyserini)%0A2. MonoT5-3b (...  \n",
       "4  Unicoil+doct5query (pyserini)%0A2. MonoT5-3b (...  "
      ]
     },
     "execution_count": 404,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# loading metadeta informaiton for runs, we have the type of pipeline as a metadata here\n",
    "metadata_models_df = pd.read_csv('metadata/metadata_models.csv', sep=\"\\t\")\n",
    "metadata_models_df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 405,
   "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>run_id</th>\n",
       "      <th>LLM</th>\n",
       "      <th>pipeline</th>\n",
       "      <th>subtask</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>colbertv2</td>\n",
       "      <td>-</td>\n",
       "      <td>Colbert-v2 and using pre-trained checkpoint an...</td>\n",
       "      <td>fullrank</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>cip_run_7</td>\n",
       "      <td>MonoT5/GPT-3.5</td>\n",
       "      <td>Unicoil+doct5query (pyserini)%0A2. MonoT5-3b (...</td>\n",
       "      <td>fullrank</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>cip_run_1</td>\n",
       "      <td>MonoT5/GPT-3.5/GPT-4</td>\n",
       "      <td>Unicoil+doct5query (pyserini)%0A2. MonoT5-3b (...</td>\n",
       "      <td>fullrank</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      run_id                   LLM  \\\n",
       "0  colbertv2                     -   \n",
       "1  cip_run_7        MonoT5/GPT-3.5   \n",
       "2  cip_run_1  MonoT5/GPT-3.5/GPT-4   \n",
       "\n",
       "                                            pipeline   subtask  \n",
       "0  Colbert-v2 and using pre-trained checkpoint an...  fullrank  \n",
       "1  Unicoil+doct5query (pyserini)%0A2. MonoT5-3b (...  fullrank  \n",
       "2  Unicoil+doct5query (pyserini)%0A2. MonoT5-3b (...  fullrank  "
      ]
     },
     "execution_count": 405,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "metadata_models_df['subtask'] = metadata_models_df['run_id'].map(runid_to_subtasks)\n",
    "metadata_models_df.head(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Loading System Performance based on NIST Qrel"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 406,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "queries_judged 76\n",
      "real_queries_judged 76\n",
      "t5_queries_judged 0\n",
      "gpt4_queries_judged 0\n"
     ]
    }
   ],
   "source": [
    "nist_qrels = pd.read_csv(nist_qrel_file, sep=' ', header=None, names=['qid', 'Q0', 'docid', 'rel'])\n",
    "\n",
    "queries_judged = set(nist_qrels['qid'])\n",
    "\n",
    "real_queries_judged = [x for x in queries_judged if x < 3000000]\n",
    "t5_queries_judged = [x for x in queries_judged if x > 3000000 and x < 3100000]\n",
    "gpt4_queries_judged = [x for x in queries_judged if x > 3100000]\n",
    "\n",
    "print('queries_judged', len(queries_judged))\n",
    "print('real_queries_judged', len(real_queries_judged))\n",
    "print('t5_queries_judged', len(t5_queries_judged))\n",
    "print('gpt4_queries_judged', len(gpt4_queries_judged))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 407,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "386416\n",
      "286459\n",
      "52218\n",
      "46080\n",
      "1659\n"
     ]
    }
   ],
   "source": [
    "print(len(nist_qrels['rel']))\n",
    "print(len([x for x in nist_qrels['rel'] if x == 0]))\n",
    "print(len([x for x in nist_qrels['rel'] if x == 1]))\n",
    "print(len([x for x in nist_qrels['rel'] if x == 2]))\n",
    "print(len([x for x in nist_qrels['rel'] if x == 3]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 408,
   "metadata": {},
   "outputs": [],
   "source": [
    "# loading qrels for different DL years\n",
    "dl23_qrels = pd.read_csv(\"TREC-DLs-files/TREC-DL-2023/qrels-pass.txt\", sep=' ', header=None, names=['qid', 'Q0', 'docid', 'rel'])\n",
    "dl22_qrels = pd.read_csv(\"TREC-DLs-files/TREC-DL-2022/qrels-pass.txt\", sep=' ', header=None, names=['qid', 'Q0', 'docid', 'rel'])\n",
    "dl21_qrels = pd.read_csv(\"TREC-DLs-files/TREC-DL-2021/qrels-pass.txt\", sep=' ', header=None, names=['qid', 'Q0', 'docid', 'rel'])\n",
    "dl20_qrels = pd.read_csv(\"TREC-DLs-files/TREC-DL-2020/qrels-pass.txt\", sep=' ', header=None, names=['qid', 'Q0', 'docid', 'rel'])\n",
    "dl19_qrels = pd.read_csv(\"TREC-DLs-files/TREC-DL-2019/qrels-pass.txt\", sep=' ', header=None, names=['qid', 'Q0', 'docid', 'rel'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Loading runs on NIST qrels "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 409,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Loading results on NIST qrel for specific year of DL\n",
    "nist_labels_result = pd.read_csv(full_nist_result_file, sep='\\t', header=None, names=['run_id', 'metric', 'qid', 'score'])\n",
    "nist_labels_result = nist_labels_result[nist_labels_result['qid'] != 'all']\n",
    "nist_labels_result['qid'] = nist_labels_result['qid'].astype(int)\n",
    "nist_labels_result = nist_labels_result[(nist_labels_result['metric'] == metric)]\n",
    "nist_labels_result['score'] = nist_labels_result['score'].astype('float64')\n",
    "\n",
    "track_queries_nist_labels = nist_labels_result[(nist_labels_result['metric'] == metric)].groupby('run_id')['score'].agg(['mean', 'count']).reset_index()\n",
    "track_queries_nist_labels = track_queries_nist_labels.rename(columns={'mean':metric})\n",
    "runid_to_score_track_nist = dict(zip(track_queries_nist_labels['run_id'], track_queries_nist_labels[metric]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 410,
   "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>run_id</th>\n",
       "      <th>metric</th>\n",
       "      <th>qid</th>\n",
       "      <th>score</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>srchvrs_p_bm25f</td>\n",
       "      <td>ndcg_cut_100</td>\n",
       "      <td>2000511</td>\n",
       "      <td>0.3352</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>16</th>\n",
       "      <td>srchvrs_p_bm25f</td>\n",
       "      <td>ndcg_cut_100</td>\n",
       "      <td>2000719</td>\n",
       "      <td>0.2325</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>26</th>\n",
       "      <td>srchvrs_p_bm25f</td>\n",
       "      <td>ndcg_cut_100</td>\n",
       "      <td>2001532</td>\n",
       "      <td>0.2562</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>36</th>\n",
       "      <td>srchvrs_p_bm25f</td>\n",
       "      <td>ndcg_cut_100</td>\n",
       "      <td>2001908</td>\n",
       "      <td>0.1986</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>46</th>\n",
       "      <td>srchvrs_p_bm25f</td>\n",
       "      <td>ndcg_cut_100</td>\n",
       "      <td>2001975</td>\n",
       "      <td>0.2020</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>76946</th>\n",
       "      <td>pass3</td>\n",
       "      <td>ndcg_cut_100</td>\n",
       "      <td>2055480</td>\n",
       "      <td>0.7295</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>76956</th>\n",
       "      <td>pass3</td>\n",
       "      <td>ndcg_cut_100</td>\n",
       "      <td>2055634</td>\n",
       "      <td>0.7238</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>76966</th>\n",
       "      <td>pass3</td>\n",
       "      <td>ndcg_cut_100</td>\n",
       "      <td>2055795</td>\n",
       "      <td>0.5634</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>76976</th>\n",
       "      <td>pass3</td>\n",
       "      <td>ndcg_cut_100</td>\n",
       "      <td>2056158</td>\n",
       "      <td>0.6018</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>76986</th>\n",
       "      <td>pass3</td>\n",
       "      <td>ndcg_cut_100</td>\n",
       "      <td>2056323</td>\n",
       "      <td>0.6204</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>7600 rows × 4 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "                run_id        metric      qid   score\n",
       "6      srchvrs_p_bm25f  ndcg_cut_100  2000511  0.3352\n",
       "16     srchvrs_p_bm25f  ndcg_cut_100  2000719  0.2325\n",
       "26     srchvrs_p_bm25f  ndcg_cut_100  2001532  0.2562\n",
       "36     srchvrs_p_bm25f  ndcg_cut_100  2001908  0.1986\n",
       "46     srchvrs_p_bm25f  ndcg_cut_100  2001975  0.2020\n",
       "...                ...           ...      ...     ...\n",
       "76946            pass3  ndcg_cut_100  2055480  0.7295\n",
       "76956            pass3  ndcg_cut_100  2055634  0.7238\n",
       "76966            pass3  ndcg_cut_100  2055795  0.5634\n",
       "76976            pass3  ndcg_cut_100  2056158  0.6018\n",
       "76986            pass3  ndcg_cut_100  2056323  0.6204\n",
       "\n",
       "[7600 rows x 4 columns]"
      ]
     },
     "execution_count": 410,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nist_labels_result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 411,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "36\n"
     ]
    }
   ],
   "source": [
    "# removing the runs that are for reranking task (4 runs for reranking) -> 39 runs will be remain\n",
    "included_runids = metadata_models_df[metadata_models_df['subtask'] == task]['run_id']\n",
    "print(len(set(included_runids)))\n",
    "\n",
    "# We have {'D_bm25_splades', 'D_naverloo-frgpt4', 'D_naverloo_bm25_RR', 'D_naverloo_bm_splade_RR', 'colbertv2'}\n",
    "# runs that have not submitted their results. So, we have 40 run_ids in metadata file in total, the rerank ones (4 runs) \n",
    "# are rmeoved from the list using the above command. Then, 36 runs we have, in whiche 5 submissions are have not submitteed their reuslt\n",
    "# so we will have 31 submissions in total.\n",
    "\n",
    "# nist_labels_result = nist_labels_result[nist_labels_result['run_id'].isin(included_runids)]\n",
    "# print(len(set(nist_labels_result['run_id'])))\n",
    "\n",
    "nist_labels_result = nist_labels_result[nist_labels_result['qid'] != 'all']\n",
    "nist_labels_result['qid'] = nist_labels_result['qid'].astype(int)\n",
    "nist_labels_result = nist_labels_result[(nist_labels_result['metric'] == metric)]\n",
    "nist_labels_result['score'] = nist_labels_result['score'].astype('float64')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 412,
   "metadata": {},
   "outputs": [],
   "source": [
    "track_queries_nist_labels = nist_labels_result[(nist_labels_result['metric'] == metric) & (nist_labels_result['qid'].isin(queries_judged))].groupby('run_id')['score'].agg(['mean', 'count']).reset_index()\n",
    "track_queries_nist_labels = track_queries_nist_labels.rename(columns={'mean':metric})\n",
    "runid_to_score_track_nist = dict(zip(track_queries_nist_labels['run_id'], track_queries_nist_labels[metric]))\n",
    "\n",
    "generated_queries_nist_labels = nist_labels_result[(nist_labels_result['metric'] == metric) & ((nist_labels_result['qid'].isin(t5_queries_judged)) | ((nist_labels_result['qid'].isin(gpt4_queries_judged)))) ].groupby('run_id')['score'].agg(['mean', 'count']).reset_index()\n",
    "generated_queries_nist_labels = generated_queries_nist_labels.rename(columns={'mean':metric})\n",
    "runid_to_score_generated_nist = dict(zip(generated_queries_nist_labels['run_id'], generated_queries_nist_labels[metric]))\n",
    "\n",
    "real_queries_nist_labels = nist_labels_result[(nist_labels_result['metric'] == metric) & (nist_labels_result['qid'].isin(real_queries_judged))].groupby('run_id')['score'].agg(['mean', 'count']).reset_index()\n",
    "real_queries_nist_labels = real_queries_nist_labels.rename(columns={'mean':metric})\n",
    "runid_to_score_real_nist = dict(zip(real_queries_nist_labels['run_id'], real_queries_nist_labels[metric]))\n",
    "\n",
    "t5_queries_nist_labels = nist_labels_result[(nist_labels_result['metric'] == metric) & (nist_labels_result['qid'].isin(t5_queries_judged))].groupby('run_id')['score'].agg(['mean', 'count']).reset_index()\n",
    "t5_queries_nist_labels = t5_queries_nist_labels.rename(columns={'mean':metric})\n",
    "runid_to_score_t5_nist = dict(zip(t5_queries_nist_labels['run_id'], t5_queries_nist_labels[metric]))\n",
    "\n",
    "gpt4_queries_nist_labels = nist_labels_result[(nist_labels_result['metric'] == metric) & (nist_labels_result['qid'].isin(gpt4_queries_judged))].groupby('run_id')['score'].agg(['mean', 'count']).reset_index()\n",
    "gpt4_queries_nist_labels = gpt4_queries_nist_labels.rename(columns={'mean':metric})\n",
    "runid_to_score_gpt4_nist = dict(zip(gpt4_queries_nist_labels['run_id'], gpt4_queries_nist_labels[metric]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Loading runs results on Resource qrels "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 413,
   "metadata": {},
   "outputs": [],
   "source": [
    "gpt4_labels_result = pd.read_csv(full_resource_result_file, sep='\\t', header=None, names=['run_id', 'metric', 'qid', 'score'])\n",
    "gpt4_labels_result.head()\n",
    "\n",
    "gpt4_labels_result = gpt4_labels_result[gpt4_labels_result['qid'] != 'all']\n",
    "gpt4_labels_result['qid'] = gpt4_labels_result['qid'].astype(int)\n",
    "gpt4_labels_result = gpt4_labels_result[(gpt4_labels_result['metric'] == metric)]\n",
    "gpt4_labels_result['score'] = gpt4_labels_result['score'].astype('float64')\n",
    "\n",
    "track_queries_gpt4_labels = gpt4_labels_result[(gpt4_labels_result['metric'] == metric)].groupby('run_id')['score'].agg(['mean', 'count']).reset_index()\n",
    "track_queries_gpt4_labels = track_queries_gpt4_labels.rename(columns={'mean':metric})\n",
    "runid_to_score_track_gpt4 = dict(zip(track_queries_gpt4_labels['run_id'], track_queries_gpt4_labels[metric]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Loading Configs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 414,
   "metadata": {},
   "outputs": [],
   "source": [
    "# loading the metadata and assigning LLM tag based on the pipeline of each run\n",
    "run_to_model = {}\n",
    "# red: gpt, yellow: t5, orange: gpt+t5, and blue: everything else\n",
    "for eachline in metadata_models_df.itertuples(index=True):\n",
    "    # if we have both T5 and GPT version in the pipeline\n",
    "    if 'T5' in eachline.LLM and 'GPT' in eachline.LLM:\n",
    "        run_to_model[eachline.run_id] = 'GPT+T5'\n",
    "    elif 'GPT' in eachline.LLM:\n",
    "        run_to_model[eachline.run_id] = 'GPT'\n",
    "    elif 'T5' in eachline.LLM:\n",
    "        run_to_model[eachline.run_id] = 'T5'\n",
    "    else:\n",
    "        run_to_model[eachline.run_id] = 'Others'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 415,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_merged_df(dict_1, dict_2):\n",
    "\n",
    "    # Convert dictionaries to DataFrames\n",
    "    df1 = pd.DataFrame(list(dict_1.items()), columns=['Key', 'Value1'])\n",
    "    df2 = pd.DataFrame(list(dict_2.items()), columns=['Key', 'Value2'])\n",
    "\n",
    "    # Merge the DataFrames based on the 'Key' column\n",
    "    merged_df = pd.merge(df1, df2, on='Key', how='outer')\n",
    "\n",
    "    return merged_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 416,
   "metadata": {},
   "outputs": [],
   "source": [
    "model_to_color = {'GPT': 'red', 'T5': 'brown', 'GPT+T5': 'orange', 'Others': 'green'}\n",
    "model_to_marker = {'GPT': 'x', 'T5': '|', 'GPT+T5': '+', 'Others': '.'}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Generating Plots for Various Types of Analysis"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 417,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_plot(x_avg_scores, y_avg_scores, query_types=['track', 'real'], label_types=['NIST', 'NIST']):\n",
    "\n",
    "    # splitting query types\n",
    "    query_type_x = query_types[0]\n",
    "    query_type_y = query_types[1]\n",
    "\n",
    "    # splitting query types\n",
    "    label_type_x = label_types[0]\n",
    "    label_type_y = label_types[1]\n",
    "\n",
    "    # if label_type_x == 'Sparse':\n",
    "    #     metric_type_x = f\"NDCG@{cut_off}\"\n",
    "    # else:\n",
    "    #     metric_type_x = f\"NDCG@{cut_off}\"\n",
    "\n",
    "    # if label_type_y == 'Sparse':\n",
    "    #     metric_type_y = f\"NDCG@{cut_off}\"\n",
    "    # else:\n",
    "    #     metric_type_y = f\"NDCG@{cut_off}\"\n",
    "\n",
    "    merged_df = get_merged_df(x_avg_scores, y_avg_scores)\n",
    "\n",
    "    for eachline in merged_df.itertuples(index=True):\n",
    "        run_model = run_to_model[eachline.Key]\n",
    "        model_color = model_to_color[run_model]\n",
    "        model_marker = model_to_marker[run_model]\n",
    "        plt.scatter(eachline.Value1, eachline.Value2, c=f\"{model_color}\", marker=f\"{model_marker}\", label=f\"{run_model}\", s=70)\n",
    "\n",
    "    if label_type_x != 'Sparse' and label_type_y != 'Sparse':\n",
    "        # axes\n",
    "        ax = plt.gca()\n",
    "        lims = [\n",
    "            np.min([ax.get_xlim(), ax.get_ylim()]),  # min of both axes\n",
    "            np.max([ax.get_xlim(), ax.get_ylim()]),  # max of both axes\n",
    "            ]\n",
    "        \n",
    "        # now plot both limits against eachother\n",
    "        ax.plot(lims, lims, color='blue', linestyle='dashed', linewidth=0.7)\n",
    "    \n",
    "    tau, p_value = stats.kendalltau(merged_df['Value1'], merged_df['Value2'])\n",
    "\n",
    "    #adding tau inside the plot \n",
    "    plt.annotate(r'Kendall $\\tau$ = %s' %np.round(tau, 4), xy=(0.03, 0.9), xycoords='axes fraction', fontsize=14)\n",
    "    \n",
    "    # plt.xlabel(f'{metric_type_x} on {query_type_x} queries ({label_type_x} Qrel)', fontsize=10)\n",
    "    # plt.ylabel(f'{metric_type_y} on {query_type_y} queries ({label_type_y} Qrel)', fontsize=10)\n",
    "\n",
    "    # plt.xlabel(f'{plot_metric} ({query_type_x}, {label_type_x} Judgments)', fontsize=13)\n",
    "    # plt.ylabel(f'{plot_metric} ({query_type_y}, {label_type_y} Judgments)', fontsize=13)\n",
    "\n",
    "    plt.xlabel(f'{plot_metric} ({query_type_x})', fontsize=16)\n",
    "    plt.ylabel(f'{plot_metric} ({query_type_y})', fontsize=16)\n",
    "\n",
    "    handles, labels = plt.gca().get_legend_handles_labels()\n",
    "    by_label = dict(zip(labels, handles))\n",
    "    plt.legend(by_label.values(), by_label.keys(), edgecolor='black', fontsize=13, loc = \"lower right\")\n",
    "\n",
    "    plt.xticks(fontsize=13)\n",
    "    plt.yticks(fontsize=13)\n",
    "\n",
    "    # plt.show()\n",
    "\n",
    "    plt.savefig(f\"figs/results/{dl_year}_{plot_metric}_colored.pdf\", bbox_inches='tight')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 418,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_plot_simple(x_avg_scores, y_avg_scores, query_types=['track', 'real'], label_types=['NIST', 'NIST']):\n",
    "\n",
    "    # splitting query types\n",
    "    query_type_x = query_types[0]\n",
    "    query_type_y = query_types[1]\n",
    "\n",
    "    merged_df = get_merged_df(x_avg_scores, y_avg_scores)\n",
    "\n",
    "    for eachline in merged_df.itertuples(index=True):\n",
    "        plt.scatter(eachline.Value1, eachline.Value2, c='black')\n",
    "\n",
    "    ax = plt.gca()\n",
    "    lims = [\n",
    "        np.min([ax.get_xlim(), ax.get_ylim()]),  # min of both axes\n",
    "        np.max([ax.get_xlim(), ax.get_ylim()]),  # max of both axes\n",
    "        ]\n",
    "        \n",
    "    # now plot both limits against eachother\n",
    "    ax.plot(lims, lims, color='black', linestyle='dashed', linewidth=0.7)\n",
    "    \n",
    "    tau, p_value = stats.kendalltau(merged_df['Value1'], merged_df['Value2'])\n",
    "\n",
    "    #adding tau inside the plot \n",
    "    plt.annotate(r'Kendall $\\tau$ = %s' %np.round(tau, 4), xy=(0.03, 0.9), xycoords='axes fraction', fontsize=16)\n",
    "\n",
    "    plt.xlabel(f'{plot_metric} ({query_type_x})', fontsize=16)\n",
    "    plt.ylabel(f'{plot_metric} ({query_type_y})', fontsize=16)\n",
    "\n",
    "    plt.xticks(fontsize=13)\n",
    "    plt.yticks(fontsize=13)\n",
    "\n",
    "    # plt.show()\n",
    "\n",
    "    plt.savefig(f\"figs/results//{dl_year}_{plot_metric}_black.pdf\", bbox_inches='tight')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.1 Generating Query Analysis Plots (Synthetic Query Analysis -- NIST Qrels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 419,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "get_plot_simple(runid_to_score_track_nist, runid_to_score_track_gpt4, query_types=[f'DL-{year}', 'SynDL'], label_types=['Human', 'GPT-4'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 420,
   "metadata": {},
   "outputs": [],
   "source": [
    "# get_plot(runid_to_score_track_nist, runid_to_score_track_gpt4, query_types=[f'DL-{year}', 'SynDL'], label_types=['Human', 'GPT-4'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.10.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}