03_downstream_ner.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Prompt selection and testing\n",
    "\n",
    "This notebook chooses the most appropriate prompt and prompt structure for the OCR correction. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [],
   "source": [
    "#import config  # Import your config.py file this contains you openai api key\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import os\n",
    "from evaluation_funcs import evaluate_ner_dict, calculate_entity_similarity, evaluate_ner_dataset, evaluate_ner_dataframes\n",
    "import seaborn as sns\n",
    "import matplotlib.pyplot as plt\n",
    "from helper_functions import  perform_ner_on_folder, perform_ner_on_results, load_json_to_dataframe\n",
    "from transformers import AutoTokenizer, AutoModelForTokenClassification\n",
    "from transformers import pipeline\n",
    "import evaluate\n",
    "from dotenv import load_dotenv, find_dotenv\n",
    "load_dotenv()\n",
    "save_appendix = os.getenv(\"save_appendix\")\n",
    "\n",
    "#downstream folder\n",
    "downstream_folder = 'data/downstream'\n",
    "downstream_ncse_folder = os.path.join(downstream_folder, 'ncse')\n",
    "downstream_smh_folder = os.path.join(downstream_folder, 'smh')\n",
    "downstream_ca_folder = os.path.join(downstream_folder, 'ca')\n",
    "\n",
    "#NCSE\n",
    "\n",
    "ncse_folder = 'data/transcription_returned_ocr'\n",
    "ncse_articles_raw = os.path.join(ncse_folder, 'transcription_raw_ocr')\n",
    "ncse_articles_transcribed = os.path.join(ncse_folder, 'transcription_files') \n",
    "ncse_articles_results = os.path.join(ncse_folder, 'corrected_folder')\n",
    "ncse_articles_transcribed_ner = os.path.join(downstream_folder,'transcription_files_ner', 'ncse') \n",
    "ncse_articles_raw_ner =  os.path.join(downstream_folder,'raw_files_ner', 'ncse') \n",
    "\n",
    "#Overproof\n",
    "overproof_folder = 'data/overproof'\n",
    "\n",
    "smh_folder =  os.path.join(overproof_folder, 'SMH')\n",
    "smh_articles_raw = os.path.join(smh_folder, 'article_level', 'raw')\n",
    "smh_articles_transcribed = os.path.join(smh_folder, 'article_level', 'corrected') #in the dataset they are reffered to as corrected but this clashes with my naming convention\n",
    "smh_articles_results = os.path.join(smh_folder, 'results')\n",
    "smh_articles_transcribed_ner = os.path.join(downstream_folder,'transcription_files_ner', 'smh') \n",
    "smh_articles_raw_ner =  os.path.join(downstream_folder,'raw_files_ner', 'smh') \n",
    "\n",
    "\n",
    "ca_folder =  os.path.join(overproof_folder, 'CA')\n",
    "ca_articles_raw = os.path.join(ca_folder, 'article_level', 'raw')\n",
    "ca_articles_transcribed = os.path.join(ca_folder, 'article_level', 'corrected') #in the dataset they are reffered to as corrected but this clashes with my naming convention\n",
    "ca_articles_results = os.path.join(ca_folder, 'results')\n",
    "ca_articles_transcribed_ner = os.path.join(downstream_folder,'transcription_files_ner', 'ca') \n",
    "ca_articles_raw_ner =  os.path.join(downstream_folder,'raw_files_ner', 'ca') \n",
    "\n",
    "# Raw data\n",
    "\n",
    "\n",
    "#for saving data to be used in the analysis\n",
    "if not os.path.exists('data/downstream'):\n",
    "    os.makedirs('data/downstream')\n",
    "\n",
    "def default_serializer(obj):\n",
    "    if isinstance(obj, np.float32):\n",
    "        return float(obj)\n",
    "    raise TypeError(f\"Type {type(obj)} not serializable\")\n",
    "\n",
    "model_name_code = pd.DataFrame(list(\n",
    "  {\n",
    "  \"Llama 3\":'meta-llama-3-70b-instruct',\n",
    " 'Gemma 7B':'gemma-7b-it',\n",
    " 'Claude 3 Opus':'claude-3-opus-20240229',\n",
    " 'Claude 3 Haiku':'claude-3-haiku-20240307',\n",
    " 'GPT-4':'gpt-4-turbo-preview',\n",
    " 'GPT-3.5':'gpt-3.5-turbo',\n",
    " 'Mixtral 8x7B':'mixtral-8x7b-32768'}.items()\n",
    " ), columns=['Model', 'type'])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "OCR CER:0.5 CLOCRC CER 0.09090909090909091\n",
      "OCR CER:0.5 CLOCRC CER 0.35294117647058826\n",
      "OCR CER:0.3333333333333333 CLOCRC CER 0.07692307692307693\n"
     ]
    }
   ],
   "source": [
    "cer = evaluate.load(\"cer\")\n",
    "\n",
    "J_gt = \"Jane Austen\"\n",
    "J_ocr = \"Jar.e Aost\"\n",
    "J_clocr = \"Jane Austin\"\n",
    "\n",
    "print(f\"OCR CER:{cer.compute(predictions=[J_gt], references=[J_ocr])} CLOCRC CER {cer.compute(predictions=[J_gt], references=[J_clocr])}\")\n",
    "\n",
    "D_gt = \"Duke of Wellington\"\n",
    "D_ocr = \"..Du k3 0f W3ll1nglgss\"\n",
    "D_clocr = \"Duke of Wellylegs\"\n",
    "\n",
    "print(f\"OCR CER:{cer.compute(predictions=[D_gt], references=[D_ocr])} CLOCRC CER {cer.compute(predictions=[D_gt], references=[D_clocr])}\")\n",
    "\n",
    "L_gt = \"Ada Lovelace\"\n",
    "L_ocr = \"AcIa L.oVe>lace\"\n",
    "L_clocr = \"Ada Loveslace\"\n",
    "\n",
    "print(f\"OCR CER:{cer.compute(predictions=[L_gt], references=[L_ocr])} CLOCRC CER {cer.compute(predictions=[L_gt], references=[L_clocr])}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Evaluate performance on downstream tasks"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Load the model and create the ner pipeline using a pre-trained model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/jonno/clocrc/.venv/lib/python3.12/site-packages/transformers/tokenization_utils_base.py:1601: FutureWarning: `clean_up_tokenization_spaces` was not set. It will be set to `True` by default. This behavior will be depracted in transformers v4.45, and will be then set to `False` by default. For more details check this issue: https://github.com/huggingface/transformers/issues/31884\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "ename": "ImportError",
     "evalue": "\nAutoModelForTokenClassification requires the PyTorch library but it was not found in your environment. Checkout the instructions on the\ninstallation page: https://pytorch.org/get-started/locally/ and follow the ones that match your environment.\nPlease note that you may need to restart your runtime after installation.\n",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mImportError\u001b[0m                               Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[4], line 10\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[38;5;66;03m#raw_data_set_df = files_to_df_func(raw_folder)\u001b[39;00m\n\u001b[1;32m      5\u001b[0m \n\u001b[1;32m      6\u001b[0m \u001b[38;5;66;03m#raw_data_set_df = raw_data_set_df.loc[raw_data_set_df['file_name'].isin(transcribed_data_set_df['file_name'])]\u001b[39;00m\n\u001b[1;32m      8\u001b[0m tokenizer \u001b[38;5;241m=\u001b[39m AutoTokenizer\u001b[38;5;241m.\u001b[39mfrom_pretrained(ner_model)\n\u001b[0;32m---> 10\u001b[0m model \u001b[38;5;241m=\u001b[39m \u001b[43mAutoModelForTokenClassification\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfrom_pretrained\u001b[49m(ner_model)\n\u001b[1;32m     12\u001b[0m perform_ner \u001b[38;5;241m=\u001b[39m pipeline(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mner\u001b[39m\u001b[38;5;124m\"\u001b[39m, model\u001b[38;5;241m=\u001b[39mmodel, tokenizer\u001b[38;5;241m=\u001b[39mtokenizer)\n",
      "File \u001b[0;32m~/clocrc/.venv/lib/python3.12/site-packages/transformers/utils/import_utils.py:1543\u001b[0m, in \u001b[0;36mDummyObject.__getattribute__\u001b[0;34m(cls, key)\u001b[0m\n\u001b[1;32m   1541\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m key\u001b[38;5;241m.\u001b[39mstartswith(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m_\u001b[39m\u001b[38;5;124m\"\u001b[39m) \u001b[38;5;129;01mand\u001b[39;00m key \u001b[38;5;241m!=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m_from_config\u001b[39m\u001b[38;5;124m\"\u001b[39m:\n\u001b[1;32m   1542\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28msuper\u001b[39m()\u001b[38;5;241m.\u001b[39m\u001b[38;5;21m__getattribute__\u001b[39m(key)\n\u001b[0;32m-> 1543\u001b[0m \u001b[43mrequires_backends\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mcls\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mcls\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_backends\u001b[49m\u001b[43m)\u001b[49m\n",
      "File \u001b[0;32m~/clocrc/.venv/lib/python3.12/site-packages/transformers/utils/import_utils.py:1531\u001b[0m, in \u001b[0;36mrequires_backends\u001b[0;34m(obj, backends)\u001b[0m\n\u001b[1;32m   1529\u001b[0m failed \u001b[38;5;241m=\u001b[39m [msg\u001b[38;5;241m.\u001b[39mformat(name) \u001b[38;5;28;01mfor\u001b[39;00m available, msg \u001b[38;5;129;01min\u001b[39;00m checks \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m available()]\n\u001b[1;32m   1530\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m failed:\n\u001b[0;32m-> 1531\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mImportError\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;241m.\u001b[39mjoin(failed))\n",
      "\u001b[0;31mImportError\u001b[0m: \nAutoModelForTokenClassification requires the PyTorch library but it was not found in your environment. Checkout the instructions on the\ninstallation page: https://pytorch.org/get-started/locally/ and follow the ones that match your environment.\nPlease note that you may need to restart your runtime after installation.\n"
     ]
    }
   ],
   "source": [
    "ner_model = \"Gladiator/microsoft-deberta-v3-large_ner_conll2003\"#\"dslim/bert-base-NER\"\n",
    "\n",
    "\n",
    "#raw_data_set_df = files_to_df_func(raw_folder)\n",
    "\n",
    "#raw_data_set_df = raw_data_set_df.loc[raw_data_set_df['file_name'].isin(transcribed_data_set_df['file_name'])]\n",
    "\n",
    "tokenizer = AutoTokenizer.from_pretrained(ner_model)\n",
    "\n",
    "model = AutoModelForTokenClassification.from_pretrained(ner_model)\n",
    "\n",
    "perform_ner = pipeline(\"ner\", model=model, tokenizer=tokenizer)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Perform NER on the transcribed dataset to get the \"ground truth\" labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "perform_ner_on_folder(ncse_articles_transcribed, ncse_articles_transcribed_ner, perform_ner)\n",
    "perform_ner_on_folder(smh_articles_transcribed, smh_articles_transcribed_ner, perform_ner)\n",
    "perform_ner_on_folder(ca_articles_transcribed, ca_articles_transcribed_ner, perform_ner)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Perform NER on the raw OCR to be able to get the improvment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "perform_ner_on_folder(ncse_articles_raw, ncse_articles_raw_ner, perform_ner)\n",
    "perform_ner_on_folder(smh_articles_raw, smh_articles_raw_ner, perform_ner)\n",
    "perform_ner_on_folder(ca_articles_raw, ca_articles_raw_ner, perform_ner)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Perform NER across the results of all the models"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "perform_ner_on_results(ncse_articles_results, downstream_ncse_folder, perform_ner)\n",
    "perform_ner_on_results(smh_articles_results, downstream_smh_folder, perform_ner)\n",
    "perform_ner_on_results(ca_articles_results, downstream_ca_folder, perform_ner)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "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>CoNES</th>\n",
       "      <th>F1_score</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>dataset</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>ca</th>\n",
       "      <td>0.716522</td>\n",
       "      <td>0.303846</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>ncse</th>\n",
       "      <td>0.682355</td>\n",
       "      <td>0.078431</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>smh</th>\n",
       "      <td>0.855585</td>\n",
       "      <td>0.382609</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "            CoNES  F1_score\n",
       "dataset                    \n",
       "ca       0.716522  0.303846\n",
       "ncse     0.682355  0.078431\n",
       "smh      0.855585  0.382609"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#The similarity scores for the raw rates\n",
    "\n",
    "folder_list = [(ncse_articles_transcribed_ner, ncse_articles_raw_ner), \n",
    "               (smh_articles_transcribed_ner, smh_articles_raw_ner),\n",
    "               (ca_articles_transcribed_ner, ca_articles_raw_ner)]\n",
    "\n",
    "raw_ner_evaluation_df = []\n",
    "\n",
    "for transcribed_ner, raw_folder in folder_list:\n",
    "\n",
    "    gt_NER = load_json_to_dataframe(transcribed_ner)\n",
    "\n",
    "    recovered_NER = load_json_to_dataframe(raw_folder)\n",
    "    \n",
    "    temp = evaluate_ner_dataframes(recovered_NER, gt_NER)\n",
    "\n",
    "    temp['dataset'] = os.path.basename(raw_folder)\n",
    "\n",
    "    raw_ner_evaluation_df.append(temp)\n",
    "\n",
    "raw_ner_evaluation_df = pd.concat(raw_ner_evaluation_df, ignore_index=True)  \n",
    "\n",
    "raw_ner_evaluation_df.groupby('dataset')[['CoNES', 'F1_score']].median()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dataset    Model  NCSE         SMH          CA     \n",
      "                 CoNES    F1 CoNES    F1 CoNES   F1\n",
      "0        Raw OCR  0.68  0.08  0.86  0.38  0.72  0.3\n"
     ]
    }
   ],
   "source": [
    "def create_metric_table_raw(df, metric_name, model_name_code):\n",
    "    \"\"\"\n",
    "    Creates a pivot table for the specified metric and formats the DataFrame for raw NER evaluation.\n",
    "    \n",
    "    Parameters:\n",
    "    - df: The original DataFrame with raw NER evaluation data.\n",
    "    - metric_name: The name of the metric to process (e.g., 'F1_score' or 'CoNES').\n",
    "    - model_name_code: DataFrame with model names and codes for merging.\n",
    "    \n",
    "    Returns:\n",
    "    - A formatted DataFrame with the pivoted metric values.\n",
    "    \"\"\"\n",
    "    # Calculate median values for the specified metric\n",
    "    metric_df = df.groupby('dataset')[[metric_name]].median().reset_index()\n",
    "\n",
    "    # Process dataset names\n",
    "    metric_df['dataset'] = metric_df['dataset'].str.upper()\n",
    "\n",
    "    # Create pivot table for the specified metric\n",
    "    pivot_df = metric_df.pivot_table(\n",
    "        index=['dataset'], \n",
    "        columns=[], \n",
    "        values=metric_name\n",
    "    ).reset_index()\n",
    "\n",
    "    # Transpose the DataFrame\n",
    "    pivot_df = pivot_df.set_index('dataset').T\n",
    "\n",
    "    # Add a 'Model' column\n",
    "    pivot_df['Model'] = 'Raw OCR'\n",
    "\n",
    "    # Set 'Model' as index\n",
    "    pivot_df.set_index('Model', inplace=True)\n",
    "\n",
    "    # Round the numeric columns to 2 decimal places\n",
    "    for dataset in pivot_df.columns:\n",
    "        pivot_df[dataset] = pivot_df[dataset].round(2)\n",
    "\n",
    "    return pivot_df\n",
    "\n",
    "# Generate tables for CoNES and F1_score\n",
    "raw_cones_df = create_metric_table_raw(raw_ner_evaluation_df, 'CoNES', model_name_code)\n",
    "raw_f1_df = create_metric_table_raw(raw_ner_evaluation_df, 'F1_score', model_name_code)\n",
    "\n",
    "# Combine the two DataFrames with a multi-index\n",
    "raw_combined_df = pd.concat({'CoNES': raw_cones_df, 'F1': raw_f1_df}, axis=1)\n",
    "\n",
    "# Reorder the column levels to have 'dataset' as the first level and 'Metric' as the second level\n",
    "raw_combined_df = raw_combined_df.reorder_levels([1, 0], axis=1)\n",
    "\n",
    "# Sort the columns alphabetically by dataset\n",
    "raw_combined_df = raw_combined_df.sort_index(axis=1, level=0).reset_index()\n",
    "\n",
    "# Select only the desired columns\n",
    "raw_combined_df = raw_combined_df[['Model', 'NCSE', 'SMH', 'CA']]\n",
    "\n",
    "# Display the final DataFrame\n",
    "print(raw_combined_df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "data/downstream/ncse\n",
      "data/downstream/smh\n",
      "data/downstream/ca\n"
     ]
    }
   ],
   "source": [
    "folder_list = [(ncse_articles_transcribed_ner, downstream_ncse_folder ), \n",
    " (smh_articles_transcribed_ner, downstream_smh_folder ),\n",
    " (ca_articles_transcribed_ner, downstream_ca_folder )\n",
    "]\n",
    "\n",
    "ner_evaluation_df = []\n",
    "\n",
    "for transcribed_ner, downstream_folder in folder_list:\n",
    "    print(downstream_folder)\n",
    "\n",
    "    gt_NER = load_json_to_dataframe(transcribed_ner)\n",
    "    \n",
    "    temp = evaluate_ner_dataset(downstream_folder, gt_NER)\n",
    "\n",
    "    temp['dataset'] = os.path.basename(downstream_folder)\n",
    "\n",
    "    ner_evaluation_df.append(temp)\n",
    "\n",
    "ner_evaluation_df = pd.concat(ner_evaluation_df, ignore_index=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "            Model  NCSE         SMH          CA      \n",
      "                  CoNES    F1 CoNES    F1 CoNES    F1\n",
      "0  Claude 3 Haiku  0.72  0.11  0.95  0.46  0.85  0.35\n",
      "1   Claude 3 Opus  0.92  0.22  0.97  0.53  0.92  0.40\n",
      "2        Gemma 7B  0.59  0.09  0.84  0.24  0.62  0.18\n",
      "3         GPT-3.5  0.82  0.13  0.94  0.42  0.88  0.34\n",
      "4     GPT-4 Boros  0.88  0.28  0.95  0.54  0.90  0.42\n",
      "5           GPT-4  0.88  0.19  0.95  0.32  0.89  0.36\n",
      "8         Llama 3  0.76  0.16  0.90  0.34  0.81  0.19\n",
      "9    Mixtral 8x7B  0.68  0.08  0.91  0.21  0.78  0.13\n"
     ]
    }
   ],
   "source": [
    "\n",
    "def create_metric_table(df, metric_name, model_name_code):\n",
    "    \"\"\"\n",
    "    Creates a pivot table for the specified metric and formats the DataFrame.\n",
    "    Returns only rows and columns without NaN values.\n",
    "    \n",
    "    Parameters:\n",
    "    - df: The original DataFrame with evaluation data.\n",
    "    - metric_name: The name of the metric to process (e.g., 'F1_score' or 'CoNES').\n",
    "    - model_name_code: DataFrame with model names and codes for merging.\n",
    "    \n",
    "    Returns:\n",
    "    - A formatted DataFrame with the pivoted metric values, excluding rows and columns with NaN values.\n",
    "    \"\"\"\n",
    "    # Calculate median values for the specified metric\n",
    "    metric_df = df.copy().groupby(['type', 'dataset'])[[metric_name]].median().reset_index()\n",
    "\n",
    "    # Process dataset names and type\n",
    "    metric_df['dataset'] = metric_df['dataset'].str.upper()\n",
    "    metric_df['prompt'] = metric_df['type'].apply(lambda row: row.split(\"_\")[0])\n",
    "    metric_df['type'] = metric_df['type'].str.replace(r'^.*?__', \"\", regex=True)\n",
    "\n",
    "    # Create pivot table for the specified metric\n",
    "    pivot_df = metric_df[metric_df['prompt'] != 'instruct'].pivot_table(\n",
    "        index=['type', 'prompt'], \n",
    "        columns='dataset', \n",
    "        values=metric_name\n",
    "    ).reset_index().merge(model_name_code, on='type', how='left')\n",
    "\n",
    "    # Adjust 'Model' column based on 'prompt'\n",
    "    pivot_df['Model'] = np.where(pivot_df['prompt'] == 'boros', pivot_df['Model'] + \" Boros\", pivot_df['Model'])\n",
    "\n",
    "    # Set 'Model' as index\n",
    "    pivot_df.set_index('Model', inplace=True)\n",
    "\n",
    "    # Remove 'type' and 'prompt' columns\n",
    "    pivot_df = pivot_df.drop(columns=['type', 'prompt'])\n",
    "\n",
    "    # Round the numeric columns to 2 decimal places\n",
    "    for dataset in pivot_df.columns:\n",
    "        pivot_df[dataset] = pivot_df[dataset].round(2)\n",
    "\n",
    "    # Remove rows and columns with any NaN values\n",
    "    pivot_df = pivot_df.dropna(how='any', axis=0).dropna(how='any', axis=1)\n",
    "\n",
    "    return pivot_df\n",
    "\n",
    "# Generate tables for CoNES and F1_score\n",
    "# Generate tables for CoNES and F1_score\n",
    "cones_df = create_metric_table(ner_evaluation_df, 'CoNES', model_name_code)\n",
    "f1_df = create_metric_table(ner_evaluation_df, 'F1_score', model_name_code)\n",
    "\n",
    "# Combine the two DataFrames with a multi-index\n",
    "combined_df = pd.concat({'CoNES': cones_df, 'F1': f1_df}, axis=1)\n",
    "\n",
    "# Reorder the column levels to have 'dataset' as the first level and 'Metric' as the second level\n",
    "combined_df = combined_df.reorder_levels([1, 0], axis=1)\n",
    "\n",
    "# Sort the columns alphabetically by dataset\n",
    "combined_df = combined_df.sort_index(axis=1, level=0).reset_index().dropna()\n",
    "\n",
    "combined_df = combined_df[['Model','NCSE', 'SMH', 'CA']]\n",
    "\n",
    "# Display the final DataFrame\n",
    "print(combined_df)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\\begin{table}\n",
      "\\caption{CoNES performance across the three datasets shows a similar pattern to the error reduction analysis, in that the best models create a significant improvement in data quality}\n",
      "\\label{tabl:ner_cones}\n",
      "\\begin{tabular}{clrrrrrr}\n",
      "\\toprule\n",
      "Model & \\multicolumn{2}{r}{NCSE} & \\multicolumn{2}{r}{SMH} & \\multicolumn{2}{r}{CA} \\\\\n",
      " & CoNES & F1 & CoNES & F1 & CoNES & F1 \\\\\n",
      "\\midrule\n",
      "Raw OCR & 0.68 & 0.08 & 0.86 & 0.38 & 0.72 & 0.30 \\\\\n",
      "Claude 3 Haiku & 0.72 & 0.11 & 0.95 & 0.46 & 0.85 & 0.35 \\\\\n",
      "Claude 3 Opus & 0.92 & 0.22 & 0.97 & 0.53 & 0.92 & 0.40 \\\\\n",
      "Gemma 7B & 0.59 & 0.09 & 0.84 & 0.24 & 0.62 & 0.18 \\\\\n",
      "GPT-3.5 & 0.82 & 0.13 & 0.94 & 0.42 & 0.88 & 0.34 \\\\\n",
      "GPT-4 Boros & 0.88 & 0.28 & 0.95 & 0.54 & 0.90 & 0.42 \\\\\n",
      "GPT-4 & 0.88 & 0.19 & 0.95 & 0.32 & 0.89 & 0.36 \\\\\n",
      "Llama 3 & 0.76 & 0.16 & 0.90 & 0.34 & 0.81 & 0.19 \\\\\n",
      "Mixtral 8x7B & 0.68 & 0.08 & 0.91 & 0.21 & 0.78 & 0.13 \\\\\n",
      "\\bottomrule\n",
      "\\end{tabular}\n",
      "\\end{table}\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Generate the LaTeX code for the DataFrame including the index\n",
    "combined_df = pd.concat([raw_combined_df, combined_df], ignore_index=True)\n",
    "latex_code = combined_df.to_latex(index=False, \n",
    "                                  float_format=\"%.2f\",\n",
    "                                  caption='CoNES performance across the three datasets shows a similar pattern to the error reduction analysis, in that the best models create a significant improvement in data quality',\n",
    "                                  label='tabl:ner_cones')\n",
    "\n",
    "# Modify the LaTeX code to center column titles and ensure index is included\n",
    "# Replace '\\begin{tabular}{' with '\\begin{tabular}{' to center the columns\n",
    "latex_code = latex_code.replace(r'\\begin{tabular}{', r'\\begin{tabular}{c')  # Add column alignment for centering\n",
    "latex_code = latex_code.replace(r'c', r'c', 1)  # Ensure the first 'c' aligns with the first column header\n",
    "\n",
    "# Print the modified LaTeX code\n",
    "print(latex_code)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\\begin{table}\n",
      "\\caption{CoNES performance across the three datasets shows a similar pattern to the error reduction analysis, in that the best models create a significant improvement in data quality}\n",
      "\\label{tabl:ner_cones}\n",
      "\\begin{tabular}{rrrrrr}\n",
      "\\toprule\n",
      "\\multicolumn{2}{r}{CA} & \\multicolumn{2}{r}{NCSE} & \\multicolumn{2}{r}{SMH} \\\\\n",
      "CoNES & F1 & CoNES & F1 & CoNES & F1 \\\\\n",
      "\\midrule\n",
      "0.85 & 0.35 & 0.72 & 0.11 & 0.95 & 0.46 \\\\\n",
      "0.92 & 0.40 & 0.92 & 0.22 & 0.97 & 0.53 \\\\\n",
      "0.62 & 0.18 & 0.59 & 0.09 & 0.84 & 0.24 \\\\\n",
      "0.88 & 0.34 & 0.82 & 0.13 & 0.94 & 0.42 \\\\\n",
      "0.90 & 0.42 & 0.88 & 0.28 & 0.95 & 0.54 \\\\\n",
      "0.89 & 0.36 & 0.88 & 0.19 & 0.95 & 0.32 \\\\\n",
      "0.83 & 0.24 & 0.72 & 0.05 & 0.92 & 0.29 \\\\\n",
      "0.00 & 0.00 & 0.00 & 0.00 & 0.00 & 0.00 \\\\\n",
      "0.81 & 0.19 & 0.76 & 0.16 & 0.90 & 0.34 \\\\\n",
      "0.78 & 0.13 & 0.68 & 0.08 & 0.91 & 0.21 \\\\\n",
      "\\bottomrule\n",
      "\\end{tabular}\n",
      "\\end{table}\n",
      "\n"
     ]
    }
   ],
   "source": [
    "\n",
    "print(combined_df.to_latex(index=False, \n",
    "                                    float_format=\"%.2f\",\n",
    "                                      caption='CoNES performance across the three datasets shows a similar pattern to the error reduction analysis, in that the best models create a significant improvement in data quality',\n",
    "                                      label='tabl:ner_cones'))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# F1 score"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "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>Model</th>\n",
       "      <th>ncse</th>\n",
       "      <th>smh</th>\n",
       "      <th>ca</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Claude 3 Haiku</td>\n",
       "      <td>0.11</td>\n",
       "      <td>0.46</td>\n",
       "      <td>0.35</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Claude 3 Opus</td>\n",
       "      <td>0.22</td>\n",
       "      <td>0.53</td>\n",
       "      <td>0.40</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Gemma 7B</td>\n",
       "      <td>0.09</td>\n",
       "      <td>0.24</td>\n",
       "      <td>0.18</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>GPT-3.5</td>\n",
       "      <td>0.13</td>\n",
       "      <td>0.42</td>\n",
       "      <td>0.34</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>GPT-4 Boros</td>\n",
       "      <td>0.28</td>\n",
       "      <td>0.54</td>\n",
       "      <td>0.42</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>GPT-4</td>\n",
       "      <td>0.19</td>\n",
       "      <td>0.32</td>\n",
       "      <td>0.36</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>Llama 3</td>\n",
       "      <td>0.16</td>\n",
       "      <td>0.34</td>\n",
       "      <td>0.19</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>Mixtral 8x7B</td>\n",
       "      <td>0.08</td>\n",
       "      <td>0.21</td>\n",
       "      <td>0.13</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "            Model  ncse   smh    ca\n",
       "0  Claude 3 Haiku  0.11  0.46  0.35\n",
       "1   Claude 3 Opus  0.22  0.53  0.40\n",
       "2        Gemma 7B  0.09  0.24  0.18\n",
       "3         GPT-3.5  0.13  0.42  0.34\n",
       "4     GPT-4 Boros  0.28  0.54  0.42\n",
       "5           GPT-4  0.19  0.32  0.36\n",
       "6         Llama 3  0.16  0.34  0.19\n",
       "7    Mixtral 8x7B  0.08  0.21  0.13"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ner_evaluation_averages_df = ner_evaluation_df.copy().groupby(['type', 'dataset'])[['F1_score']].median().sort_values(['dataset'])\n",
    "\n",
    "\n",
    "ner_evaluation_averages_df = ner_evaluation_averages_df.reset_index()\n",
    "ner_evaluation_averages_df['prompt'] = ner_evaluation_averages_df['type'].apply(lambda row: row.split(\"_\")[0])\n",
    "\n",
    "ner_evaluation_averages_df['type'] = ner_evaluation_averages_df['type'].str.replace(r'^.*?__', \"\", regex=True)\n",
    "\n",
    "cones_results_table_df = ner_evaluation_averages_df[ner_evaluation_averages_df['prompt']!='instruct'].copy()\n",
    "\n",
    "cones_results_table_df = cones_results_table_df.pivot_table(index=['type', 'prompt'], columns='dataset', values='F1_score').reset_index().merge(model_name_code, on = 'type')\n",
    "\n",
    "cones_results_table_df['Model'] = np.where(cones_results_table_df['prompt']=='boros', cones_results_table_df['Model'] + \" Boros\", cones_results_table_df['Model'])\n",
    "\n",
    "cones_results_table_df = cones_results_table_df[['Model',  'ncse', 'smh', 'ca']]\n",
    "\n",
    "cones_results_table_df[['ncse', 'smh', 'ca']] = cones_results_table_df[['ncse', 'smh', 'ca']].round(2)\n",
    "\n",
    "cones_results_table_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "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>type</th>\n",
       "      <th>dataset</th>\n",
       "      <th>CoNES</th>\n",
       "      <th>F1_score</th>\n",
       "      <th>prompt</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>llama-2-70b</td>\n",
       "      <td>ca</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>full</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>meta-llama-3-70b</td>\n",
       "      <td>ca</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>full</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>llama-2-70b</td>\n",
       "      <td>ca</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>instruct</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>meta-llama-3-70b</td>\n",
       "      <td>ca</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>instruct</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>gemma-7b-it</td>\n",
       "      <td>ca</td>\n",
       "      <td>0.615301</td>\n",
       "      <td>0.181818</td>\n",
       "      <td>full</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>60</th>\n",
       "      <td>gpt-4-turbo-preview</td>\n",
       "      <td>smh</td>\n",
       "      <td>0.953007</td>\n",
       "      <td>0.540541</td>\n",
       "      <td>boros</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>61</th>\n",
       "      <td>claude-3-haiku-20240307</td>\n",
       "      <td>smh</td>\n",
       "      <td>0.953244</td>\n",
       "      <td>0.456140</td>\n",
       "      <td>full</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>62</th>\n",
       "      <td>_gpt-4-turbo-preview</td>\n",
       "      <td>smh</td>\n",
       "      <td>0.957064</td>\n",
       "      <td>0.669618</td>\n",
       "      <td>boros</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>63</th>\n",
       "      <td>claude-3-opus-20240229</td>\n",
       "      <td>smh</td>\n",
       "      <td>0.965192</td>\n",
       "      <td>0.340357</td>\n",
       "      <td>instruct</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>64</th>\n",
       "      <td>claude-3-opus-20240229</td>\n",
       "      <td>smh</td>\n",
       "      <td>0.969903</td>\n",
       "      <td>0.528302</td>\n",
       "      <td>full</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>65 rows × 5 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "                       type dataset     CoNES  F1_score    prompt\n",
       "0               llama-2-70b      ca  0.000000  0.000000      full\n",
       "1          meta-llama-3-70b      ca  0.000000  0.000000      full\n",
       "2               llama-2-70b      ca  0.000000  0.000000  instruct\n",
       "3          meta-llama-3-70b      ca  0.000000  0.000000  instruct\n",
       "4               gemma-7b-it      ca  0.615301  0.181818      full\n",
       "..                      ...     ...       ...       ...       ...\n",
       "60      gpt-4-turbo-preview     smh  0.953007  0.540541     boros\n",
       "61  claude-3-haiku-20240307     smh  0.953244  0.456140      full\n",
       "62     _gpt-4-turbo-preview     smh  0.957064  0.669618     boros\n",
       "63   claude-3-opus-20240229     smh  0.965192  0.340357  instruct\n",
       "64   claude-3-opus-20240229     smh  0.969903  0.528302      full\n",
       "\n",
       "[65 rows x 5 columns]"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ner_evaluation_averages_df = ner_evaluation_df.copy().groupby(['type', 'dataset'])[['CoNES', 'F1_score']].median().sort_values(['dataset','CoNES'])\n",
    "\n",
    "\n",
    "ner_evaluation_averages_df = ner_evaluation_averages_df.reset_index()\n",
    "ner_evaluation_averages_df['prompt'] = ner_evaluation_averages_df['type'].apply(lambda row: row.split(\"_\")[0])\n",
    "\n",
    "ner_evaluation_averages_df['type'] = ner_evaluation_averages_df['type'].str.replace(r'^.*?__', \"\", regex=True)\n",
    "\n",
    "ner_evaluation_averages_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\\begin{table}\n",
      "\\caption{F1 performance across the three datasets shows a similar pattern to the error reduction analysis, as can be seen the improvements are much smaller than when using CoNES}\n",
      "\\label{tabl:ner_f1}\n",
      "\\begin{tabular}{lrrr}\n",
      "\\toprule\n",
      "Model & ncse & smh & ca \\\\\n",
      "\\midrule\n",
      "Claude 3 Haiku & 0.12 & 0.50 & 0.35 \\\\\n",
      "Claude 3 Opus & 0.25 & 0.49 & 0.40 \\\\\n",
      "Gemma 7B & 0.10 & 0.24 & 0.19 \\\\\n",
      "GPT-3.5 & 0.14 & 0.40 & 0.38 \\\\\n",
      "GPT-4 Boros & 0.26 & 0.50 & 0.42 \\\\\n",
      "GPT-4 & 0.19 & 0.29 & 0.38 \\\\\n",
      "Llama 3 & 0.15 & 0.36 & 0.20 \\\\\n",
      "Mixtral 8x7B & 0.09 & 0.23 & 0.15 \\\\\n",
      "\\bottomrule\n",
      "\\end{tabular}\n",
      "\\end{table}\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(cones_results_table_df.to_latex(index=False, \n",
    "                                    float_format=\"%.2f\",\n",
    "                                      caption='F1 performance across the three datasets shows a similar pattern to the error reduction analysis, as can be seen the improvements are much smaller than when using CoNES',\n",
    "                                      label='tabl:ner_f1'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "sns.scatterplot(data = ner_evaluation_averages_df, x = 'CoNES', y = 'F1_score', hue = 'dataset')\n",
    "plt.ylabel('F1 score')\n",
    "plt.title('Comparing CoNES and F1 score')\n",
    "plt.xlim([0.5, 1])\n",
    "\n",
    "plt.savefig(os.path.join(save_appendix,\"CoNES_vs_F1.pdf\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/jonno/clocrc/.venv/lib/python3.11/site-packages/numpy/lib/function_base.py:2897: RuntimeWarning: invalid value encountered in divide\n",
      "  c /= stddev[:, None]\n",
      "/home/jonno/clocrc/.venv/lib/python3.11/site-packages/numpy/lib/function_base.py:2898: RuntimeWarning: invalid value encountered in divide\n",
      "  c /= stddev[None, :]\n",
      "/tmp/ipykernel_69838/335846574.py:1: DeprecationWarning: DataFrameGroupBy.apply operated on the grouping columns. This behavior is deprecated, and in a future version of pandas the grouping columns will be excluded from the operation. Either pass `include_groups=False` to exclude the groupings or explicitly select the grouping columns after groupby to silence this warning.\n",
      "  grouped_correlation = ner_evaluation_df.groupby(['type', 'dataset']).apply(lambda group: group['CoNES'].corr(group['F1_score'])).reset_index()\n"
     ]
    },
    {
     "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>type</th>\n",
       "      <th>dataset</th>\n",
       "      <th>0</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>37</th>\n",
       "      <td>instruct__claude-3-opus-20240229</td>\n",
       "      <td>ca</td>\n",
       "      <td>-0.076923</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>17</th>\n",
       "      <td>full__gpt-4-turbo-preview</td>\n",
       "      <td>ca</td>\n",
       "      <td>0.021137</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>43</th>\n",
       "      <td>instruct__gpt-3.5-turbo</td>\n",
       "      <td>ca</td>\n",
       "      <td>0.037541</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>46</th>\n",
       "      <td>instruct__gpt-4-turbo-preview</td>\n",
       "      <td>ca</td>\n",
       "      <td>0.076324</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>full__claude-3-opus-20240229</td>\n",
       "      <td>ca</td>\n",
       "      <td>0.087461</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>50</th>\n",
       "      <td>instruct__llama-2-70b</td>\n",
       "      <td>smh</td>\n",
       "      <td>0.432949</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>boros_basic__gpt-4-turbo-preview</td>\n",
       "      <td>ncse</td>\n",
       "      <td>0.481146</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>56</th>\n",
       "      <td>instruct__meta-llama-3-70b</td>\n",
       "      <td>smh</td>\n",
       "      <td>0.573202</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>boros_complex___gpt-4-turbo-preview</td>\n",
       "      <td>smh</td>\n",
       "      <td>0.755478</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>49</th>\n",
       "      <td>instruct__llama-2-70b</td>\n",
       "      <td>ca</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>65 rows × 3 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "                                   type dataset         0\n",
       "37     instruct__claude-3-opus-20240229      ca -0.076923\n",
       "17            full__gpt-4-turbo-preview      ca  0.021137\n",
       "43              instruct__gpt-3.5-turbo      ca  0.037541\n",
       "46        instruct__gpt-4-turbo-preview      ca  0.076324\n",
       "8          full__claude-3-opus-20240229      ca  0.087461\n",
       "..                                  ...     ...       ...\n",
       "50                instruct__llama-2-70b     smh  0.432949\n",
       "0      boros_basic__gpt-4-turbo-preview    ncse  0.481146\n",
       "56           instruct__meta-llama-3-70b     smh  0.573202\n",
       "1   boros_complex___gpt-4-turbo-preview     smh  0.755478\n",
       "49                instruct__llama-2-70b      ca       NaN\n",
       "\n",
       "[65 rows x 3 columns]"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "grouped_correlation = ner_evaluation_df.groupby(['type', 'dataset']).apply(lambda group: group['CoNES'].corr(group['F1_score'])).reset_index()\n",
    "\n",
    "grouped_correlation.sort_values(0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": ".venv",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.12.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}