04_sociocultural_context.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Socio-cultural context\n",
    "\n",
    "This section has the code which shows how CLOCR-C uses socio-cultural context"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "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 llm_comparison_toolkit import RateLimiter, get_response_openai,  create_config_dict_func, use_df_to_call_llm_api\n",
    "from evaluate import load\n",
    "from evaluation_funcs import evaluate_correction_performance, evaluate_correction_performance_folders, get_metric_error_reduction, evaluate_ocr_dataframe, calculate_metrics\n",
    "import seaborn as sns\n",
    "import matplotlib.pyplot as plt\n",
    "from helper_functions import files_to_df_func, repeat_prompt_experiment, files_to_df_core_func, process_jokes_context\n",
    "#from transformers import AutoTokenizer, AutoModelForTokenClassification\n",
    "#from transformers import pipeline\n",
    "import re\n",
    "from openai import OpenAI\n",
    "import itertools\n",
    "import tiktoken\n",
    "import time\n",
    "save_figs = os.getenv(\"save_figs\")\n",
    "\n",
    "wer = load(\"wer\")\n",
    "cer = load(\"cer\")\n",
    "client = OpenAI()\n",
    "\n",
    "\n",
    "dev_data_folder = 'data/dev_data'\n",
    "dev_transcripts = os.path.join(dev_data_folder, 'dev_data_transcript')\n",
    "dev_raw_ocr_folder =  os.path.join(dev_data_folder,'dev_raw_ocr' )\n",
    "dev_system_message_folder = os.path.join(dev_data_folder,'dev_system_message_variants' )\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, 'line_level', 'line_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",
    "\n",
    "\n",
    "# sociocultural test\n",
    "socio_cultural_folder = \"data/socio_cultural\"\n",
    "socio_cultural_results_folder = os.path.join(socio_cultural_folder, \"results\")\n",
    "socio_cultural_evals = os.path.join(socio_cultural_folder, \"evals\")\n",
    "\n",
    "#load the dev and test sets for prompt development and selection\n",
    "dev_data_df = pd.read_csv(os.path.join(dev_data_folder,'dev_data_raw.csv'))\n",
    "\n",
    "\n",
    "\n",
    "#for saving data to be used in the socio cultural\n",
    "if not os.path.exists(socio_cultural_results_folder):\n",
    "    os.makedirs(socio_cultural_results_folder)\n",
    "\n",
    "if not os.path.exists(socio_cultural_evals):\n",
    "    os.makedirs(socio_cultural_evals)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Demonstrating context leveraging\n",
    "\n",
    "The below texts can be used to demonstrate that LMs use context leveraging and that they can self-contextualise from the task itself. The words in the parenthesis are optional contxt\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'chicken_cross' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[6], line 3\u001b[0m\n\u001b[1;32m      1\u001b[0m prompt_combined_joke \u001b[38;5;241m=\u001b[39m\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\"\"\u001b[39m\u001b[38;5;124mPlease correct the below sentence containing OCR errors.\u001b[39m\n\u001b[1;32m      2\u001b[0m \u001b[38;5;124mSentence 1:\u001b[39m\n\u001b[0;32m----> 3\u001b[0m \u001b[38;5;132;01m{\u001b[39;00m\u001b[43mchicken_cross\u001b[49m\u001b[38;5;132;01m}\u001b[39;00m\n\u001b[1;32m      4\u001b[0m \u001b[38;5;124mSentence 2:\u001b[39m\n\u001b[1;32m      5\u001b[0m \u001b[38;5;132;01m{\u001b[39;00mchicken_cross2\u001b[38;5;132;01m}\u001b[39;00m\n\u001b[1;32m      6\u001b[0m \u001b[38;5;124m\"\"\"\u001b[39m\n",
      "\u001b[0;31mNameError\u001b[0m: name 'chicken_cross' is not defined"
     ]
    }
   ],
   "source": [
    "prompt_combined_joke =f\"\"\"Please correct the below sentence containing OCR errors.\n",
    "Sentence 1:\n",
    "{chicken_cross}\n",
    "Sentence 2:\n",
    "{chicken_cross2}\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'prompt_combined_joke' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[7], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mprompt_combined_joke\u001b[49m\n",
      "\u001b[0;31mNameError\u001b[0m: name 'prompt_combined_joke' is not defined"
     ]
    }
   ],
   "source": [
    "prompt_combined_joke"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Sentence 1:\\nMy dog has a wet nose.\\n\\nSentence 2:\\nHow does he smell?\\nTerrible!'"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "\n",
    "\n",
    "response = get_response_openai(prompt_combined_joke,\n",
    "\"\", RateLimiter(40000), \n",
    "engine=\"gpt-4-turbo-preview\", \n",
    "max_tokens = 500,\n",
    ")\n",
    "\n",
    "response\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "chicken_cross = \"\"\"why did the *** *** *** ***\"\"\"\n",
    "\n",
    "chicken_cross2 = \"\"\"*** *** *** *** other side\"\"\"\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "prompt_chicken =f\"\"\"Please correct the below sentence containing OCR errors\n",
    "\n",
    "{chicken_cross}\n",
    "\n",
    "\"\"\"\n",
    "\n",
    "prompt_chicken_joke =f\"\"\"Please correct the below sentence containing OCR errors, the sentence is part of a popular joke\n",
    "\n",
    "{chicken_cross}\n",
    "\n",
    "\"\"\"\n",
    "\n",
    "prompt_chicken_mislead =f\"\"\"Please correct the below sentence containing OCR errors, the sentence is part of an article on cookery\n",
    "\n",
    "{chicken_cross}\n",
    "\n",
    "\"\"\"\n",
    "\n",
    "check_prompt_chicken = \"\"\"The below text surrounded by triple colons is the response of a language model to a task, did it correctly identify the sentence 'why did the chicken cross the road', Answer 1 or 0\n",
    ":::\n",
    "{answer}\n",
    ":::\n",
    "\n",
    "\"\"\"\n",
    "\n",
    "prompt_chicken2 =f\"\"\"Please correct the below sentences containing OCR errors\n",
    "\n",
    "{chicken_cross2}\n",
    "\n",
    "\"\"\"\n",
    "\n",
    "prompt_chicken2_joke =f\"\"\"Please correct the below sentences containing OCR errors, the sentences are part of popular jokes\n",
    "\n",
    "{chicken_cross2}\n",
    "\n",
    "\"\"\"\n",
    "\n",
    "prompt_chicken2_mislead =f\"\"\"Please correct the below sentences containing OCR errors, the sentences are part of an article on cookery\n",
    "\n",
    "{chicken_cross2}\n",
    "\n",
    "\"\"\"\n",
    "\n",
    "#remove two\n",
    "prompt_full_chicken =f\"\"\"Please correct the below sentences containing OCR errors\n",
    "\n",
    "\n",
    "{chicken_cross}\n",
    "\n",
    "{chicken_cross2}\n",
    "\"\"\"\n",
    "\n",
    "prompt_full_chicken_joke =f\"\"\"Please correct the below sentences containing OCR errors, the sentences are part of popular jokes\n",
    "\n",
    "\n",
    "{chicken_cross}\n",
    "\n",
    "{chicken_cross2}\n",
    "\"\"\"\n",
    "\n",
    "prompt_full_chicken_mislead =f\"\"\"Please correct the below sentences containing OCR errors, the sentences are part of an article on cookery\n",
    "\n",
    "\n",
    "{chicken_cross}\n",
    "\n",
    "{chicken_cross2}\n",
    "\"\"\"\n",
    "\n",
    "check_combined = \"\"\"The below text surrounded by triple colons is the response of a language model to a task, did it correctly identify both the sentences 'my dog has no nose' and 'why did the chicken cross the road', Answer 1 if both identified or 0 otherwise\n",
    ":::\n",
    "{answer}\n",
    ":::\n",
    "\n",
    "\"\"\"\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'why did the cat cross the road'"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "messages = [\n",
    "    {\"role\": \"system\", \"content\": \"\"},\n",
    "    {\"role\": \"user\", \"content\": prompt_chicken}\n",
    "]\n",
    "\n",
    "response = client.chat.completions.create(\n",
    "    model = \"gpt-4-turbo-preview\",\n",
    "    messages = messages,\n",
    "    max_tokens = 500, \n",
    "    temperature = 0.2,\n",
    "    logprobs=True#,\n",
    "    # top_p = 0.9,\n",
    ")\n",
    "#get the log probability for each token\n",
    "logprobs = [token.logprob for token in response.choices[0].logprobs.content]\n",
    "\n",
    "answer = response.choices[0].message.content\n",
    "\n",
    "answer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "setup_basic.csv already exists, skipping\n",
      "setup_true.csv already exists, skipping\n",
      "setup_mislead.csv already exists, skipping\n",
      "punchline_basic.csv already exists, skipping\n",
      "punchline_true.csv already exists, skipping\n",
      "punchline_mislead.csv already exists, skipping\n",
      "combined_basic.csv already exists, skipping\n",
      "combined_true.csv already exists, skipping\n",
      "combined_mislead.csv already exists, skipping\n"
     ]
    }
   ],
   "source": [
    "context_check = pd.DataFrame([\n",
    "             {'prompt': prompt_chicken, 'check':check_prompt_chicken, 'context':'basic', 'joke':'setup', 'sentence': chicken_cross },\n",
    "             {'prompt': prompt_chicken_joke, 'check':check_prompt_chicken, 'context':'true', 'joke':'setup' , 'sentence': chicken_cross},\n",
    "             {'prompt': prompt_chicken_mislead, 'check':check_prompt_chicken, 'context':'mislead', 'joke':'setup', 'sentence': chicken_cross },\n",
    "             {'prompt': prompt_chicken2, 'check':check_prompt_chicken, 'context':'basic', 'joke':'punchline', 'sentence': chicken_cross2 },\n",
    "             {'prompt': prompt_chicken2_joke, 'check':check_prompt_chicken, 'context':'true', 'joke':'punchline' , 'sentence': chicken_cross2},\n",
    "             {'prompt': prompt_chicken2_mislead, 'check':check_prompt_chicken, 'context':'mislead', 'joke':'punchline', 'sentence': chicken_cross2 },\n",
    "             {'prompt': prompt_full_chicken, 'check':check_combined, 'context':'basic', 'joke':'combined', 'sentence': chicken_cross + \"\\n\"+chicken_cross2 },\n",
    "             {'prompt': prompt_full_chicken_joke, 'check':check_combined, 'context':'true', 'joke':'combined', 'sentence': chicken_cross + \"\\n\"+chicken_cross2  },\n",
    "             {'prompt': prompt_full_chicken_mislead, 'check':check_combined, 'context':'mislead', 'joke':'combined', 'sentence': chicken_cross + \"\\n\"+chicken_cross2  }\n",
    "            ])\n",
    "\n",
    "process_jokes_context(context_check,os.path.join(\"data\", \"socio_cultural\",'chicken_80'), temperature=0.8 )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Spoofing and **T**ask **I**nduced **I**n **C**ontext **L**earning\n",
    "\n",
    "This section performs the test of how the amount of text and the prompt given interact."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def split_rows(df, x):\n",
    "    new_rows = []\n",
    "    \n",
    "    for _, row in df.iterrows():\n",
    "        content_lines = row['content'].split('\\n')\n",
    "        num_groups = len(content_lines) // x\n",
    "        \n",
    "        for i in range(num_groups):\n",
    "            start_row = i * x\n",
    "            end_row = (i + 1) * x\n",
    "            group_lines = content_lines[start_row:end_row]\n",
    "            \n",
    "            new_row = {\n",
    "                'file_name': row['file_name'],\n",
    "                'content': '\\n'.join(group_lines),\n",
    "                'start_row': start_row,\n",
    "                'end_row': end_row\n",
    "            }\n",
    "            new_rows.append(new_row)\n",
    "    \n",
    "    new_df = pd.DataFrame(new_rows)\n",
    "    new_df['content'] = new_df['content'].str.replace(\"-\\n\", \"\").str.replace(\"\\n\", \" \")\n",
    "    new_df['id2'] = new_df['file_name'].str.replace(\".txt\", \"\")\n",
    "    new_df['id'] = new_df['id2'] + \"_lines_\" + new_df['start_row'].astype(str) + \"_\" + new_df['end_row'].astype(str) \n",
    "    new_df['file_name'] = new_df['id'] + \".txt\" \n",
    "    return new_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "prompt_smh = \"{content}\"+f\"\"\" \\n \\n \"\"\" + f\"\"\"You are an expert in post-OCR correction of documents. Using the context available from the text please recover the most likely original text from the corrupted OCR. Do not add any text, commentary, or lead in sentences beyond the recovered text. Do not add a title, or any introductions.\"\"\"\n",
    "context_prompt_smh = \"{content}\"+f\"\"\" \\n \\n \"\"\" + f\"\"\"You are an expert in post-OCR correction of documents. Using the context available from the text please recover the most likely original text from the corrupted OCR. Do not add any text, commentary, or lead in sentences beyond the recovered text. Do not add a title, or any introductions. The text is from The Sydney Morning Herald 1842 -1950. \"\"\"\n",
    "spoof_prompt_smh = \"{content}\"+f\"\"\" \\n \\n \"\"\" + f\"\"\"You are an expert in post-OCR correction of documents. Using the context available from the text please recover the most likely original text from the corrupted OCR. Do not add any text, commentary, or lead in sentences beyond the recovered text. Do not add a title, or any introductions. The text is from The Hong Kong Restaurant Review 1989-1993. \"\"\"\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "enc = tiktoken.encoding_for_model(\"gpt-3.5-turbo\") "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "prompt_dict = {'prompt':[prompt_smh, context_prompt_smh, spoof_prompt_smh],\n",
    " 'response_name':['basic', 'context', 'spoof']\n",
    " }\n",
    "\n",
    "\n",
    "socio_list = [\n",
    "    create_config_dict_func(\n",
    "        get_response_func=get_response_openai,\n",
    "        rate_limiter=RateLimiter(160e3),\n",
    "        engine=\"gpt-4-turbo-preview\",#'gpt-3.5-turbo',\n",
    "        system_message_template=\"\",\n",
    "        prompt_template=prompt_dict['prompt'][num],\n",
    "        additional_args={\"response_name\": prompt_dict['response_name'][num]} ## will be added to in the loop\n",
    "    )\n",
    "    for num in  [0,1,2]\n",
    "]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "max_article_rows = 60\n",
    "\n",
    "raw_article_ocr_df= files_to_df_core_func(\"data/overproof/SMH/article_level/raw\")\n",
    "\n",
    "# Filter the DataFrame to keep rows with at least 50 line breaks\n",
    "raw_article_ocr_df = raw_article_ocr_df[raw_article_ocr_df['content'].str.count('\\n') >= max_article_rows]\n",
    "\n",
    "# Split the 'content' column into a list of lines and take the first 50 lines\n",
    "raw_article_ocr_df['content'] = raw_article_ocr_df['content'].apply(lambda x: '\\n'.join(x.split('\\n')[:max_article_rows]))\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "number_lines_list =[60, 30, 15, 10, 5, 2]  #[1, 2, 3, 4, 5, 6, 10, 12, 15, 20, 30, 60]\n",
    "\n",
    "for config, group_size in itertools.product(socio_list, number_lines_list ):\n",
    "\n",
    "    temporary_df = split_rows(raw_article_ocr_df, group_size)\n",
    "\n",
    "    response_name = config['response_name'] + \"_\" + str(group_size)\n",
    "\n",
    "    use_df_to_call_llm_api(config, temporary_df, response_name , folder_path= os.path.join(socio_cultural_results_folder ))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "#load transcribed data\n",
    "\n",
    "transcr_article_ocr_df= files_to_df_core_func(smh_articles_transcribed)\n",
    "\n",
    "# Filter the DataFrame to keep rows with at least 50 line breaks\n",
    "transcr_article_ocr_df = transcr_article_ocr_df[transcr_article_ocr_df['content'].str.count('\\n') >= max_article_rows]\n",
    "\n",
    "# Split the 'content' column into a list of lines and take the first 50 lines\n",
    "transcr_article_ocr_df['content'] = transcr_article_ocr_df['content'].apply(lambda x: '\\n'.join(x.split('\\n')[:max_article_rows]))\n",
    "\n",
    "transcr_article_ocr_df['content']  = transcr_article_ocr_df['content'].str.replace(\"-\\n\", \"\").str.replace(\"\\n\", \" \")\n",
    "\n",
    "transcr_article_ocr_df['id'] = transcr_article_ocr_df['file_name'].str.replace(\".txt\", \"\")\n",
    "\n",
    "transcr_article_ocr_df.drop(columns='file_name', inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'data/socio_cultural/results'"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "socio_cultural_results_folder"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'data/socio_cultural/results'"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "socio_cultural_results_folder"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "folder:context_10_gpt-4-turbo-preview, lines agg:10\n",
      "folder:basic_15_gpt-4-turbo-preview, lines agg:15\n",
      "folder:basic_2_gpt-4-turbo-preview, lines agg:2\n",
      "folder:spoof_10_gpt-4-turbo-preview, lines agg:10\n",
      "folder:basic_10_gpt-4-turbo-preview, lines agg:10\n",
      "folder:spoof_2_gpt-4-turbo-preview, lines agg:2\n",
      "folder:context_5_gpt-4-turbo-preview, lines agg:5\n",
      "folder:context_2_gpt-4-turbo-preview, lines agg:2\n",
      "folder:context_60_gpt-4-turbo-preview, lines agg:60\n",
      "folder:spoof_60_gpt-4-turbo-preview, lines agg:60\n",
      "folder:context_30_gpt-4-turbo-preview, lines agg:30\n",
      "folder:spoof_5_gpt-4-turbo-preview, lines agg:5\n",
      "folder:spoof_15_gpt-4-turbo-preview, lines agg:15\n",
      "folder:basic_5_gpt-4-turbo-preview, lines agg:5\n",
      "folder:basic_30_gpt-4-turbo-preview, lines agg:30\n",
      "folder:basic_60_gpt-4-turbo-preview, lines agg:60\n",
      "folder:context_15_gpt-4-turbo-preview, lines agg:15\n",
      "folder:spoof_30_gpt-4-turbo-preview, lines agg:30\n"
     ]
    }
   ],
   "source": [
    "# go through all the folders and get the performance\n",
    "\n",
    "performance_vs_lines = []\n",
    "\n",
    "over_folder = socio_cultural_results_folder#+\"_v2\"\n",
    "\n",
    "\n",
    "for folder in os.listdir(over_folder):\n",
    "    agg_num =  int(re.search(r'_(\\d+)_', folder).group(1))\n",
    "    print(f\"folder:{folder}, lines agg:{agg_num}\")\n",
    "\n",
    "\n",
    "    lm_corrected_temp = files_to_df_core_func(os.path.join(over_folder, folder))\n",
    "\n",
    "    lm_corrected_temp['id'] = lm_corrected_temp['file_name'].str.extract(r'(.+)_lines_')[0]\n",
    "    lm_corrected_temp['order'] = lm_corrected_temp['file_name'].str.extract(r'_lines_(\\d+)')[0].astype(int)\n",
    "\n",
    "    # Group by the grouping key and aggregate the content based on the order\n",
    "    lm_corrected_temp = lm_corrected_temp.groupby('id')[['order', 'content']].apply(lambda x: ' '.join(x.sort_values('order')['content']))\n",
    "\n",
    "    # Reset the index to get the grouping key as a regular column\n",
    "    lm_corrected_temp = lm_corrected_temp.reset_index(name='content').reset_index(drop = True).rename(columns={0:'content'})\n",
    "\n",
    "    #merge together\n",
    "    current_article_set = transcr_article_ocr_df.merge(lm_corrected_temp, left_on='id', right_on = 'id', suffixes=['_transcr', '_lm'])\n",
    "\n",
    "    metric_df = pd.concat([calculate_metrics(row['id'], row['content_lm'].lower(), row['content_transcr'].lower(), wer, cer) for _, row in current_article_set.iterrows()]).drop(columns='File Name')\n",
    "\n",
    "    current_article_set.loc[:, ['WER', 'CER', 'lev_dist']] = metric_df[['WER', 'CER', 'lev_dist']].reset_index()\n",
    "\n",
    "    result_df = metric_df.agg(['mean', 'median'])\n",
    "\n",
    "    result_df['average'] = ['mean', 'median']\n",
    "\n",
    "    result_df['lines'] = agg_num\n",
    "    result_df['type'] = folder\n",
    "\n",
    "    current_article_set['lines'] = agg_num\n",
    "    current_article_set['type'] = folder\n",
    "\n",
    "    current_article_set.to_csv(os.path.join(socio_cultural_evals, folder+\".csv\"))\n",
    "\n",
    "    performance_vs_lines.append(result_df)\n",
    "\n",
    "performance_vs_lines = pd.concat(performance_vs_lines, ignore_index=True)\n",
    "\n",
    "performance_vs_lines['type'] =  performance_vs_lines['type'].str.split(\"_\").str.get(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "temp_plot = performance_vs_lines.loc[(performance_vs_lines['average']=='median')].copy()\n",
    "temp_plot['type'] = temp_plot['type'].str.replace(\"spoof\", 'untrue')\n",
    "temp_plot['lines'] = temp_plot['lines'].astype(int)\n",
    "\n",
    "temp_plot['type'] = np.where(temp_plot['type']==\"untrue\", \"mislead\", temp_plot['type'])\n",
    "#temp_plot = temp_plot.loc[temp_plot['type']!='mislead']\n",
    "\n",
    "sns.barplot(data =temp_plot, x = 'lines', y = 'CER', hue = 'type', hue_order = ['mislead', 'basic', 'context'])\n",
    "plt.title('Exploring the impact of task length and context')\n",
    "plt.xlabel('Number of text lines per task')\n",
    "plt.ylabel('Median CER')\n",
    "plt.savefig(os.path.join(save_figs,\"performance_vs_lines.pdf\"))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "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>type</th>\n",
       "      <th>lines</th>\n",
       "      <th>basic</th>\n",
       "      <th>context</th>\n",
       "      <th>mislead</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>2</td>\n",
       "      <td>0.087060</td>\n",
       "      <td>0.109500</td>\n",
       "      <td>0.228682</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>5</td>\n",
       "      <td>0.032452</td>\n",
       "      <td>0.029429</td>\n",
       "      <td>0.174020</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>10</td>\n",
       "      <td>0.018755</td>\n",
       "      <td>0.021732</td>\n",
       "      <td>0.256010</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>15</td>\n",
       "      <td>0.025161</td>\n",
       "      <td>0.017356</td>\n",
       "      <td>0.365783</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>30</td>\n",
       "      <td>0.017063</td>\n",
       "      <td>0.012823</td>\n",
       "      <td>0.751781</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>60</td>\n",
       "      <td>0.014635</td>\n",
       "      <td>0.013288</td>\n",
       "      <td>0.827913</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "type  lines     basic   context   mislead\n",
       "0         2  0.087060  0.109500  0.228682\n",
       "1         5  0.032452  0.029429  0.174020\n",
       "2        10  0.018755  0.021732  0.256010\n",
       "3        15  0.025161  0.017356  0.365783\n",
       "4        30  0.017063  0.012823  0.751781\n",
       "5        60  0.014635  0.013288  0.827913"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "latex_table"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\\begin{table}\n",
      "\\caption{Performance Metrics by Type and Lines}\n",
      "\\label{tab:performance_metrics}\n",
      "\\begin{tabular}{rrrr}\n",
      "\\toprule\n",
      "lines & basic & context & mislead \\\\\n",
      "\\midrule\n",
      "2 & 0.09 & 0.11 & 0.23 \\\\\n",
      "5 & 0.03 & 0.03 & 0.17 \\\\\n",
      "10 & 0.02 & 0.02 & 0.26 \\\\\n",
      "15 & 0.03 & 0.02 & 0.37 \\\\\n",
      "30 & 0.02 & 0.01 & 0.75 \\\\\n",
      "60 & 0.01 & 0.01 & 0.83 \\\\\n",
      "\\bottomrule\n",
      "\\end{tabular}\n",
      "\\end{table}\n",
      "\n"
     ]
    }
   ],
   "source": [
    "latex_table = temp_plot.pivot_table(index='lines', columns='type', values='CER', aggfunc='median').reset_index()\n",
    "\n",
    "# Save LaTeX table to a .tex file (optional)\n",
    "latex_code = latex_table.to_latex(index=False, caption='Performance Metrics by Type and Lines', label='tab:performance_metrics', float_format=\"%.2f\")\n",
    "\n",
    "# Print LaTeX code (for manual copy-pasting)\n",
    "print(latex_code)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "temp_plot = performance_vs_lines.loc[(performance_vs_lines['average']=='median')].copy()\n",
    "temp_plot['type'] = temp_plot['type'].str.replace(\"spoof\", 'untrue')\n",
    "temp_plot['lines'] = temp_plot['lines'].astype(int)\n",
    "\n",
    "temp_plot['type'] = np.where(temp_plot['type']==\"untrue\", \"mislead\", temp_plot['type'])\n",
    "temp_plot = temp_plot.loc[temp_plot['type']!='mislead']\n",
    "\n",
    "sns.barplot(data =temp_plot, x = 'lines', y = 'CER', hue = 'type', hue_order = ['mislead', 'basic', 'context'])\n",
    "plt.title('Exploring the impact of task length and context')\n",
    "plt.xlabel('Number of text lines per task')\n",
    "plt.ylabel('Median CER')\n",
    "#plt.savefig(os.path.join(save_figs,\"performance_vs_lines.pdf\"))\n",
    "plt.show()"
   ]
  },
  {
   "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
}