diff --git "a/src/notebook.ipynb" "b/src/notebook.ipynb" new file mode 100644--- /dev/null +++ "b/src/notebook.ipynb" @@ -0,0 +1,856 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import pandas as pd\n", + "from transformers import pipeline\n", + "from transformers import AutoModelForCausalLM, AutoTokenizer, TextGenerationPipeline\n", + "import matplotlib.pyplot as plt\n", + "from dotenv import load_dotenv \n", + "import os\n", + "import re\n", + "from tqdm import tqdm\n", + " \n", + "import io\n", + "import sys\n", + "load_dotenv()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "device = \"cuda\"" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "deepseek_model = {\n", + " \"tokenizer\": AutoTokenizer.from_pretrained(\"deepseek-ai/deepseek-coder-7b-instruct-v1.5\"),\n", + " \"model\" : AutoModelForCausalLM.from_pretrained(\"deepseek-ai/deepseek-coder-7b-instruct-v1.5\")\n", + "}\n", + "\n", + "mistral_model = {\n", + " \"tokenizer\": AutoTokenizer.from_pretrained(\"mistralai/Mistral-7B-Instruct-v0.2\"),\n", + " \"model\" : AutoModelForCausalLM.from_pretrained(\"mistralai/Mistral-7B-Instruct-v0.2\")\n", + "}\n", + "\n", + "codellama_model = {\n", + " \"tokenizer\": AutoTokenizer.from_pretrained(\"codellama/CodeLlama-7b-Instruct-hf\"),\n", + " \"model\" : AutoModelForCausalLM.from_pretrained(\"codellama/CodeLlama-7b-Instruct-hf\")\n", + "}\n" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "libraries = \"\"\"\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "import numpy as np\n", + "import seaborn as sns\n", + "from scipy import stats\n", + "\"\"\"" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "prompt_template = \"\"\"df is a dataframe that {description}. df has these columns: {columns}. Without explaining, write in a python code block the answer to this question: Print {question}\n", + "\"\"\"\n", + "prompt_template = \"\"\"df is a dataframe that {description}. df has these columns: {columns}. Write in a python code block the answer to this question: Print {question}. Just code, no explanation should be given.\n", + "\"\"\"\n", + "\n", + "prompt_template = \"\"\"df is a dataframe that {description}. df has these columns: {columns}. Write in a python code block the answer to this question: {question}. Just write code and print results, no explanation should be given.\n", + "\"\"\"" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "def extract_code(text):\n", + " try:\n", + " matches = []\n", + " # pattern = r\"```(.*?)```\"\n", + " pattern = r\"```python(.*?)```\"\n", + " if text:\n", + " matches = re.findall(pattern, text, re.DOTALL)\n", + " if matches:\n", + " return matches[0]\n", + " else:\n", + " raise Exception(\"Error extracting code: No match\")\n", + " except Exception as e:\n", + " raise Exception(\"Error extracting code: \",e) from e\n", + "\n", + "def generate_response(prompt,model_name):\n", + " try:\n", + " coder_model_prompt = [\n", + " {\"role\": \"user\", \"content\": prompt}\n", + " ]\n", + " encodeds = model_name[\"tokenizer\"].apply_chat_template(coder_model_prompt, return_tensors=\"pt\")\n", + "\n", + " model_inputs = encodeds.to(device)\n", + " model_name['model'].to(device)\n", + "\n", + " generated_ids = model_name['model'].generate(model_inputs, max_new_tokens=500, do_sample=False,temperature=0.1,repetition_penalty=1)\n", + " decoded = model_name[\"tokenizer\"].batch_decode(generated_ids)\n", + " return decoded[0].split('[/INST]')[-1].split('')[0]\n", + " except Exception as e:\n", + " raise Exception(\"Error generating: \",e) from e\n", + "\n", + "def execute(code,namespace):\n", + " try:\n", + " buffer = io.StringIO()\n", + " sys.stdout = buffer\n", + " exec(libraries+code,namespace)\n", + "\n", + " sys.stdout = sys.__stdout__\n", + "\n", + " return buffer.getvalue()\n", + "\n", + " except Exception as e:\n", + " raise Exception(\"Error executing: \",e) from e" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "filename = \"titanic.csv\"\n", + "df = pd.read_csv(f'./testing/datasets/{filename}')\n", + "answer1 = df[df['Name'] == \"Mr. Owen Harris Braund\"]['Fare'].iloc[0]\n", + "answer2 = df[df['Sex'] == \"female\"].shape[0]\n", + "answer3 = df['Age'].mean()\n", + "answer4 = df[df['Survived'] == 1].shape[0]\n", + "answer5 = df.loc[df['Fare'].idxmax(), 'Name']\n", + "answer6 = df['Fare'].sum()\n", + "answer7 = df.loc[df['Siblings/Spouses Aboard'].idxmax(), 'Name']\n", + "answer8 = df[df['Name'] == \"Miss. Laina Heikkinen\"]['Age'].iloc[0]\n", + "answer9 = df[df['Pclass'] == 1].shape[0]\n", + "answer10 = df['Fare'].mean()\n", + "answer11 = df[df['Siblings/Spouses Aboard'] == 0].shape[0]\n", + "answer12 = df.loc[df['Age'].idxmax(), 'Name']\n", + "answer13 = df[df['Survived'] == 0].shape[0]\n", + "answer14 = df['Fare'].min()\n", + "\n", + "TC1_questions = [\n", + " {'question': 'What is the fare for Mr. Owen Harris Braund?', 'answer': answer1},\n", + " {'question': 'How many females are in the dataset?', 'answer': answer2},\n", + " {'question': 'What is the average age of the passengers?', 'answer': answer3},\n", + " {'question': 'How many passengers survived?', 'answer': answer4},\n", + " {'question': 'Who paid the highest fare?', 'answer': answer5},\n", + " {'question': 'What is the total amount of fare paid?', 'answer': answer6},\n", + " {'question': 'Who is the passanger that has the highest number of siblings abroad ?', 'answer': answer7},\n", + " {\"question\": \"What is the age of Miss. Laina Heikkinen?\", \"answer\": answer8},\n", + " {\"question\": \"How many passengers are in the 1st class?\", \"answer\": answer9},\n", + " {\"question\": \"What is the average fare paid by passengers?\", \"answer\": answer10},\n", + " {\"question\": \"How many passengers have 0 siblings/spouses aboard?\", \"answer\": answer11},\n", + " {\"question\": \"Who is the oldest passenger in the dataset?\", \"answer\": answer12},\n", + " {\"question\": \"How many passengers did not survive?\", \"answer\": answer13},\n", + " {\"question\": \"What is the lowest fare paid in the dataset?\", \"answer\": answer14}\n", + "]\n", + "\n", + "TC1_description = 'contains the list of people that were on the titanic ship and some details such as age, sex, name and whether they survived or not'\n", + "TC1_columns = \"['Survived', 'Pclass', 'Name', 'Sex', 'Age', 'Siblings/Spouses Aboard', 'Parents/Children Aboard', 'Fare']\"\n", + "\n", + "TC1 = {\n", + " \"dataset\":filename,\n", + " \"description\":TC1_description,\n", + " \"columns\":TC1_columns,\n", + " \"questions\": TC1_questions,\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "filename = \"onlinefoods.csv\"\n", + "df = pd.read_csv(f'./testing/datasets/{filename}')\n", + "answer1 = df.loc[df['Gender'] == \"Female\", 'Monthly Income'].iloc[0]\n", + "answer2 = (df['Occupation'] == \"Student\").sum()\n", + "answer3 = df['Age'].mean()\n", + "answer4 = (df['Feedback'] == \"Positive\").sum()\n", + "answer5= df[df['Gender'] == 'Male']['Educational Qualifications'].unique()\n", + "answer6 = (df['Marital Status'] == \"Single\").sum()\n", + "answer7 = df['Marital Status'].mode()[0]\n", + "answer8 = \"Yes\" if any(df['Family size'] > 3) else \"No\"\n", + "answer9 = df.loc[df['latitude'].idxmax(), 'Pin code']\n", + "answer10 = \"Yes\" if any((df['Feedback'] == \"Negative\") & (df['Monthly Income'] == \"Below Rs.10000\")) else \"No\"\n", + "\n", + "TC2_questions=[\n", + " {\"question\": \"What is the monthly income of the first female in the dataset?\", \"answer\": answer1},\n", + " {\"question\": \"How many students are there in the dataset?\", \"answer\": answer2},\n", + " {\"question\": \"What is the average age of participants?\", \"answer\": answer3},\n", + " {\"question\": \"How many participants provided positive feedback?\", \"answer\": answer4},\n", + " {\"question\": \"What is the educational qualification of the male participant?\", \"answer\": answer5},\n", + " {\"question\": \"How many participants are single?\", \"answer\": answer6},\n", + " {\"question\": \"What is the most common marital status in the dataset?\", \"answer\": answer7},\n", + " {\"question\": \"Are there any participants with a family size greater than 3?\", \"answer\": answer8},\n", + " {\"question\": \"What is the pin code for the location with the highest latitude?\", \"answer\": answer9},\n", + " {\"question\": \"Did any participant with negative feedback have a monthly income below Rs.10000?\", \"answer\": answer10}\n", + "]\n", + "\n", + "TC2_description = 'The dataset contains information collected from an online food ordering platform over a period of time.'\n", + "TC2_columns = \"['Age', 'Gender', 'Marital Status', 'Occupation', 'Monthly Income', 'Educational Qualifications', 'Family size', 'latitude', 'longitude', 'Pin code', 'Output', 'Feedback', 'Unnamed: 12']\"\n", + "\n", + "TC2 = {\n", + " \"dataset\":filename,\n", + " \"description\":TC2_description,\n", + " \"columns\":TC2_columns,\n", + " \"questions\": TC2_questions,\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "filename = \"hw_200.csv\"\n", + "df = pd.read_csv(f'./testing/datasets/{filename}')\n", + "answer1 = df.loc[1, 'Weight(Pounds)']\n", + "answer2 = df[df['Height(Inches)'] > 70].shape[0]\n", + "answer3 = df['Height(Inches)'].mean()\n", + "answer4 = df[df['Weight(Pounds)'] < 120].shape[0]\n", + "answer5 = df.loc[df['Weight(Pounds)'].idxmax(), 'Index']\n", + "answer6 = df['Weight(Pounds)'].sum()\n", + "answer7 = df.loc[df['Height(Inches)'].idxmin(), 'Index']\n", + "answer8 = df.loc[3, 'Height(Inches)']\n", + "answer9 = df[df['Height(Inches)'] >= 65].shape[0]\n", + "answer10 = df['Weight(Pounds)'].mean()\n", + "answer11 = df[df['Weight(Pounds)'] == 100].shape[0]\n", + "answer12 = df.loc[df['Height(Inches)'].idxmax(), 'Index']\n", + "answer13 = df[df['Weight(Pounds)'] > 150].shape[0]\n", + "answer14 = df['Height(Inches)'].min()\n", + "\n", + "\n", + "TC3_description =\"height and weight for 200 individuals\"\n", + "TC3_columns = \"['Index', 'Height(Inches)', 'Weight(Pounds)']\"\n", + "\n", + "TC3_questions = [\n", + " {'question': 'What is the weight of the person at index 1?', 'answer': answer1},\n", + " {'question': 'How many people are taller than 70 inches?', 'answer': answer2},\n", + " {'question': 'What is the average height of the people?', 'answer': answer3},\n", + " {'question': 'How many people weigh less than 120 pounds?', 'answer': answer4},\n", + " {'question': 'Who has the highest weight?', 'answer': answer5},\n", + " {'question': 'What is the total weight of all people?', 'answer': answer6},\n", + " {'question': 'Who is the shortest person?', 'answer': answer7},\n", + " {\"question\": \"What is the height of the person at index 3?\", \"answer\": answer8},\n", + " {\"question\": \"How many people are at least 65 inches tall?\", \"answer\": answer9},\n", + " {\"question\": \"What is the average weight of the people?\", \"answer\": answer10},\n", + " {\"question\": \"How many people weigh exactly 100 pounds?\", \"answer\": answer11},\n", + " {\"question\": \"Who is the tallest person?\", \"answer\": answer12},\n", + " {\"question\": \"How many people weigh more than 150 pounds?\", \"answer\": answer13},\n", + " {\"question\": \"What is the lowest height recorded in the dataset?\", \"answer\": answer14}\n", + "]\n", + "\n", + "TC3 = {\n", + " \"dataset\":filename,\n", + " \"description\":TC3_description,\n", + " \"columns\":TC3_columns,\n", + " \"questions\": TC3_questions,\n", + "}\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "filename = \"Monthly_Counts_of_Deaths_by_Select_Causes__2014-2019.csv\"\n", + "df = pd.read_csv(f'./testing/datasets/{filename}')\n", + "answer1 = df[(df['Jurisdiction of Occurrence'] == \"United States\") & (df['Year'] == 2014)]['Malignant Neoplasms'].sum()\n", + "answer2 = df[df['Year'] == 2015]['Natural Cause'].sum()\n", + "answer3 = df['Diabetes Mellitus'].mean()\n", + "answer4 = df[(df['Year'] == 2015) & (df['Month'] == 1)]['Intentional Self-Harm (Suicide)'].sum()\n", + "answer5 = df[(df['Year'] == 2014)]['Accidents (Unintentional Injuries)'].idxmax()\n", + "answer6 = df['All Cause'].sum()\n", + "answer7 = df.groupby('Year')['Diseases of Heart'].sum().idxmin()\n", + "answer8 = df[df['Month'] == 1]['Drug Overdose'].sum()\n", + "answer9 = df[df['Chronic Lower Respiratory Diseases'] > 10000].shape[0]\n", + "answer10 = df.groupby('Year')['Cerebrovascular Diseases'].mean()\n", + "answer11 = df[df['Year'] == 2014]['Motor Vehicle Accidents'].sum()\n", + "answer12 = df.groupby('Jurisdiction of Occurrence')['Alzheimer Disease'].sum().idxmax()\n", + "answer13 = df[df['Year'] == 2015]['Assault (Homicide)'].sum()\n", + "answer14 = df['Influenza and Pneumonia'].min()\n", + "answers = [answer1, answer2, answer3, answer4, answer5, answer6, answer7, answer8, answer9, answer10, answer11, answer12, answer13, answer14]\n", + "\n", + "TC4_description =\"Monthly counts of death by select causes.\"\n", + "TC4_columns = \"['Jurisdiction of Occurrence', 'Year', 'Month', 'All Cause', 'Natural Cause', 'Septicemia', 'Malignant Neoplasms', 'Diabetes Mellitus', 'Alzheimer Disease', 'Influenza and Pneumonia', 'Chronic Lower Respiratory Diseases', 'Other Diseases of Respiratory System', 'Nephritis, Nephrotic Syndrome, and Nephrosis', 'Symptoms, Signs, and Abnormal Clinical and Laboratory Findings, Not Elsewhere Classified', 'Diseases of Heart', 'Cerebrovascular Diseases', 'Accidents (Unintentional Injuries)', 'Motor Vehicle Accidents', 'Intentional Self-Harm (Suicide)', 'Assault (Homicide)', 'Drug Overdose']\"\n", + "\n", + "TC4_questions = [\n", + " {'question': 'How many deaths were caused by \"Malignant Neoplasms\" in the United States in 2014?', 'answer': answer1},\n", + " {'question': 'What is the total number of \"Natural Cause\" deaths recorded in 2015?', 'answer': answer2},\n", + " {'question': 'What is the average number of deaths by \"Diabetes Mellitus\" across all years and months?', 'answer': answer3},\n", + " {'question': 'How many deaths were reported as \"Intentional Self-Harm (Suicide)\" in January 2015?', 'answer': answer4},\n", + " {'question': 'Which month in 2014 had the highest number of \"Accidents (Unintentional Injuries)\"?', 'answer': answer5},\n", + " {'question': 'What is the total number of all recorded deaths in the dataset?', 'answer': answer6},\n", + " {'question': 'Which year had the lowest \"Diseases of Heart\" deaths?', 'answer': answer7},\n", + " {\"question\": \"What were the total \\\"Drug Overdose\\\" deaths in January across all years?\", \"answer\": answer8},\n", + " {\"question\": \"How many months have recorded more than 10,000 deaths from \\\"Chronic Lower Respiratory Diseases\\\"?\", \"answer\": answer9},\n", + " {\"question\": \"What is the average number of deaths due to \\\"Cerebrovascular Diseases\\\" each year?\", \"answer\": answer10},\n", + " {\"question\": \"How many \\\"Motor Vehicle Accidents\\\" deaths were there in 2014?\", \"answer\": answer11},\n", + " {\"question\": \"Which jurisdiction recorded the highest \\\"Alzheimer Disease\\\" deaths in the dataset?\", \"answer\": answer12},\n", + " {\"question\": \"How many \\\"Assault (Homicide)\\\" deaths were reported in 2015?\", \"answer\": answer13},\n", + " {\"question\": \"What is the minimum number of \\\"Influenza and Pneumonia\\\" deaths recorded in any month?\", \"answer\": answer14}\n", + "]\n", + "\n", + "TC4 = {\n", + " \"dataset\":filename,\n", + " \"description\":TC4_description,\n", + " \"columns\":TC4_columns,\n", + " \"questions\": TC4_questions,\n", + "}\n" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "def test(qa,description,columns,dataset):\n", + " data = []\n", + " df = pd.read_csv(f'./testing/datasets/{dataset}')\n", + " namespace = {'df': df}\n", + " try: \n", + " full_response= None\n", + " extracted_code= None\n", + " execution= None\n", + " error = None\n", + " question = qa['question']\n", + " answer = qa['answer']\n", + " prompt = prompt_template.format(description=description,columns=columns,question=question)\n", + " try:\n", + " full_response = generate_response(prompt,mistral_model)\n", + " extracted_code = extract_code(full_response)\n", + " execution = execute(extracted_code,namespace)\n", + " \n", + " except Exception as e:\n", + " error = e\n", + "\n", + " data.append({ \n", + " 'question': question,\n", + " 'prompt':prompt,\n", + " 'full_response': full_response,\n", + " 'extracted_code': extracted_code,\n", + " 'execution': execution,\n", + " 'answer':answer,\n", + " 'error': error\n", + " })\n", + " \n", + " return data\n", + " \n", + " except Exception as e:\n", + " print(e)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/zidane/anaconda3/envs/proj_env/lib/python3.11/site-packages/transformers/generation/configuration_utils.py:492: UserWarning: `do_sample` is set to `False`. However, `temperature` is set to `0.1` -- this flag is only used in sample-based generation modes. You should set `do_sample=True` or unset `temperature`.\n", + " warnings.warn(\n", + "The attention mask and the pad token id were not set. As a consequence, you may observe unexpected behavior. Please pass your input's `attention_mask` to obtain reliable results.\n", + "Setting `pad_token_id` to `eos_token_id`:2 for open-end generation.\n" + ] + } + ], + "source": [ + "data = test(TC1[\"questions\"][3],TC1[\"description\"],TC1[\"columns\"],TC1[\"dataset\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[{'question': 'What is the average age of the passengers?',\n", + " 'prompt': \"df is a dataframe that contains the list of people that were on the titanic ship and some details such as age, sex, name and whether they survived or not. df has these columns: ['Survived', 'Pclass', 'Name', 'Sex', 'Age', 'Siblings/Spouses Aboard', 'Parents/Children Aboard', 'Fare']. Without explaining, write in a python code block the answer to this question: Print What is the average age of the passengers?\\n\",\n", + " 'full_response': ' ```python\\n# Assuming \\'df\\' is your DataFrame object\\naverage_age = df[\\'Age\\'].mean()\\nprint(\"The average age of the passengers is:\", average_age)\\n```',\n", + " 'extracted_code': '\\n# Assuming \\'df\\' is your DataFrame object\\naverage_age = df[\\'Age\\'].mean()\\nprint(\"The average age of the passengers is:\", average_age)\\n',\n", + " 'execution': 'The average age of the passengers is: 29.471443066516347\\n',\n", + " 'answer': 29.471443066516347,\n", + " 'error': None}]" + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import time\n", + "data = [] \n", + "\n", + "for TC in [TC1,TC2,TC3,TC4]:\n", + " filename = TC[\"dataset\"]\n", + " df = pd.read_csv(f'./testing/datasets/{filename}')\n", + " namespace = {'df': df}\n", + " for qa in tqdm(TC['questions']):\n", + " try: \n", + " full_response= None\n", + " extracted_code= None\n", + " execution= None\n", + " error = None\n", + " inference_time = 0\n", + " question = qa['question']\n", + " answer = qa['answer']\n", + " prompt = prompt_template.format(description=TC['description'],columns=TC['columns'],question=question)\n", + " try:\n", + " start_time = time.time() \n", + " full_response = generate_response(prompt,deepseek_model)\n", + " end_time = time.time()\n", + " extracted_code = extract_code(full_response)\n", + " execution = execute(extracted_code,namespace)\n", + " inference_time = end_time - start_time\n", + " except Exception as e:\n", + " error = e\n", + "\n", + " data.append({\n", + " 'dataset':filename,\n", + " 'question': question,\n", + " 'prompt':prompt,\n", + " 'full_response': full_response,\n", + " 'extracted_code': extracted_code,\n", + " 'error': error,\n", + " 'inference time':inference_time,\n", + " 'answer':answer,\n", + " 'execution': execution,\n", + " \n", + " })\n", + " \n", + " except Exception as e:\n", + " print(e)\n", + " continue\n", + "\n", + "testdf = pd.DataFrame(data)\n", + "testdf.to_excel('results.xlsx')" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "testdf = pd.DataFrame(data)\n", + "testdf.to_excel('results.xlsx')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "prompt1 = \"\"\"df is a dataframe that {description}. df has these columns: {columns}. Without explaining, write in a python code block the answer to this question: Print {question}\n", + "\"\"\"\n", + "prompt2 = \"\"\"df is a dataframe that {description}. df has these columns: {columns}. Write in a python code block the answer to this question: Print {question}. Just code, no explanation should be given.\n", + "\"\"\"\n", + "\n", + "prompt3 = \"\"\"df is a dataframe that {description}. df has these columns: {columns}. Write in a python code block the answer to this question: {question}. Just write code and print results, no explanation should be given.\n", + "\"\"\" " + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "\n", + "# Load each DataFrame from Excel files\n", + "results_codellama_prompt3 = pd.read_excel('./testing/results_codellama.xlsx')\n", + "results_deepseek_prompt1 = pd.read_excel('./testing/results_deepseek_prompt1.xlsx')\n", + "results_deepseek_prompt2 = pd.read_excel('./testing/results_deepseek_prompt2.xlsx')\n", + "results_deepseek_prompt3 = pd.read_excel('./testing/results_deepseek_prompt3.xlsx')\n", + "results_mistral_prompt3 = pd.read_excel('./testing/results_mistral_prompt3.xlsx')\n", + "results_mistral_prompt1 = pd.read_excel('./testing/results_mistral_prompt1.xlsx')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Evaluation\n", + "True 34\n", + "False 18\n", + "Name: count, dtype: int64" + ] + }, + "execution_count": 33, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "results_mistral_prompt1['Evaluation'].value_counts()" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "results_codellama= pd.read_excel('./testing/results_codellama_prompt3.xlsx')\n", + "results_deepseek = pd.read_excel('./testing/results_deepseek_prompt3.xlsx')\n", + "results_mistral = pd.read_excel('./testing/results_mistral_prompt1.xlsx')" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# Normalize 'evaluation' column in each DataFrame\n", + "dataframes = {\n", + " 'Codellama': results_codellama,\n", + " 'Deepseek': results_deepseek,\n", + " 'Mistral': results_mistral,\n", + "}\n", + "\n", + "# Create a DataFrame to store the counts\n", + "evaluation_counts = pd.DataFrame()\n", + "\n", + "for name, df in dataframes.items():\n", + " count = df['Evaluation'].value_counts().rename_axis('Evaluation').reset_index(name=name)\n", + " if evaluation_counts.empty:\n", + " evaluation_counts = count\n", + " else:\n", + " evaluation_counts = pd.merge(evaluation_counts, count, on='Evaluation', how='outer')\n", + "\n", + "# Set index for plotting\n", + "evaluation_counts.set_index('Evaluation', inplace=True)\n", + "\n", + "# Plotting\n", + "evaluation_counts.plot(kind='bar', figsize=(10, 6),color=['#1f77b4', '#ff7f0e', '#2ca02c'])\n", + "plt.title('Comparison of Evaluation Counts Across Datasets')\n", + "plt.xlabel('Evaluation')\n", + "plt.ylabel('Counts')\n", + "plt.xticks(rotation=0)\n", + "plt.grid(True)\n", + "plt.legend(title='Dataset')\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
CodellamaDeepseekMistral
Evaluation
False30818
True224434
\n", + "
" + ], + "text/plain": [ + " Codellama Deepseek Mistral\n", + "Evaluation \n", + "False 30 8 18\n", + "True 22 44 34" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "evaluation_counts" + ] + }, + { + "cell_type": "code", + "execution_count": 60, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def calculate_true_ratio(df, column_name):\n", + " if column_name in df.columns:\n", + " value_counts = df[column_name].value_counts(normalize=True)\n", + " return value_counts.get(True, 0) # Returns 0 if True is not found\n", + " return None\n", + "\n", + "# Calculate ratios\n", + "true_ratios = {\n", + " 'Codellama': calculate_true_ratio(results_codellama, 'Evaluation'),\n", + " 'Deepseek': calculate_true_ratio(results_deepseek, 'Evaluation'),\n", + " 'Mistral': calculate_true_ratio(results_mistral, 'Evaluation'),\n", + "}\n", + "\n", + "# Prepare the plot\n", + "fig, ax = plt.subplots()\n", + "ax.bar(true_ratios.keys(), true_ratios.values(), color=['#1f77b4', '#ff7f0e', '#2ca02c'])\n", + "ax.set_ylabel('True/Total Ratio')\n", + "ax.set_title('True/Total Ratio of Evaluation Across DataFrames')\n", + "ax.set_ylim([0, 1]) # Ensure the y-axis starts at 0 and ends at 1\n", + "plt.xticks(rotation=45)\n", + "plt.tight_layout()\n", + "\n", + "# Show the plot\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "average_inference_time = {\n", + " 'Codellama':results_codellama['inference time'][results_codellama['inference time'] != 0].mean(),\n", + " 'Deepseek':results_deepseek['inference time'][results_deepseek['inference time'] != 0].mean(),\n", + " 'Mistral':results_mistral['inference time'][results_mistral['inference time'] != 0].mean()\n", + "}\n", + "fig, ax = plt.subplots()\n", + "ax.bar(average_inference_time.keys(), average_inference_time.values(), color=['#1f77b4', '#ff7f0e', '#2ca02c'])\n", + "ax.set_ylabel('Average Inference Time (excluding zeros)')\n", + "ax.set_title('Comparison of Average Inference Times')\n", + "plt.xticks(rotation=45)\n", + "plt.tight_layout() # Adjust layout to make room for rotated x-labels\n", + "\n", + "# Show the plot\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'Codellama ': 0.4230769230769231,\n", + " 'Deepseek': 0.8461538461538461,\n", + " 'Mistral': 0.6538461538461539}" + ] + }, + "execution_count": 54, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "true_ratios" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'Codellama': 2.2758194498113684,\n", + " 'Deepseek': 3.4430570507049563,\n", + " 'Mistral': 3.781105268833249}" + ] + }, + "execution_count": 49, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "average_inference_time" + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "metadata": {}, + "outputs": [], + "source": [ + "ratio_division = {key: true_ratios[key] / average_inference_time[key] for key in true_ratios if key in average_inference_time}\n" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'Codellama': 0.18590091718918644,\n", + " 'Deepseek': 0.2457565569471463,\n", + " 'Mistral': 0.17292460996408962}" + ] + }, + "execution_count": 57, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ratio_division" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.8" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +}