diff --git a/examples/evaluation/How_to_evaluate_LLMs_for_SQL_generation.ipynb b/examples/evaluation/How_to_evaluate_LLMs_for_SQL_generation.ipynb index de568db..9acfc05 100644 --- a/examples/evaluation/How_to_evaluate_LLMs_for_SQL_generation.ipynb +++ b/examples/evaluation/How_to_evaluate_LLMs_for_SQL_generation.ipynb @@ -33,8 +33,8 @@ "\n", "1. **[Setup](#Setup):** Install required libraries, download data consisting of SQL queries and corresponding natural language translations.\n", "2. **[Test Development](#Test-development):** Create unit tests and define evaluation metrics for the SQL generation process.\n", - "4. **[Evaluation](#Evaluation):** Conduct tests using different prompts to assess the impact on performance.\n", - "5. **[Reporting](#Report):** Compile a report that succinctly presents the performance differences observed across various tests." + "3. **[Evaluation](#Evaluation):** Conduct tests using different prompts to assess the impact on performance.\n", + "4. **[Reporting](#Report):** Compile a report that succinctly presents the performance differences observed across various tests." ] }, { @@ -259,7 +259,7 @@ "id": "19fadf67-8b2f-4e17-95df-030a36aad90b", "metadata": {}, "source": [ - "#### Prompt\n", + "#### Prompting the LLM\n", "\n", "For this demonstration purposes, we use a fairly simple prompt requesting GPT to generate a `(context, answer)` pair. `context` is the `CREATE` SQL statement, and `answer` is the `SELECT` SQL statement. We supply the natural language question as part of the prompt. We request the response to be in JSON format, so that it can be parsed easily." ] @@ -274,66 +274,37 @@ "name": "stdout", "output_type": "stream", "text": [ - "('Translate this natural language request into a JSON object containing two '\n", - " 'SQL queries. \\n'\n", - " 'The first query should be a CREATE statement for a table answering the '\n", - " \"user's request, while the second should be a SELECT query answering their \"\n", - " 'question.')\n" + "Question: How many heads of the departments are older than 56 ?\n", + "Answer: {\"create\":\"CREATE TABLE DepartmentHeads (\\n id INT PRIMARY KEY,\\n name VARCHAR(100),\\n age INT,\\n department VARCHAR(100)\\n);\",\"select\":\"SELECT COUNT(*) AS NumberOfHeadsOlderThan56 \\nFROM DepartmentHeads \\nWHERE age > 56;\"}\n" ] } ], "source": [ - "system_prompt = '''Translate this natural language request into a JSON object containing two SQL queries. \n", - "The first query should be a CREATE statement for a table answering the user's request, while the second should be a SELECT query answering their question.'''\n", - "\n", - "pprint(system_prompt)" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "3a20d712", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[{'content': 'Translate this natural language request into a JSON object '\n", - " 'containing two SQL queries. \\n'\n", - " 'The first query should be a CREATE statement for a table '\n", - " \"answering the user's request, while the second should be a \"\n", - " 'SELECT query answering their question.',\n", - " 'role': 'system'},\n", - " {'content': 'How many heads of the departments are older than 56 ?',\n", - " 'role': 'user'}]\n" - ] - } - ], - "source": [ - "# Compiling the system prompt and user question into message array\n", - "\n", - "messages = []\n", - "messages.append({\"role\": \"system\", \"content\": system_prompt})\n", - "messages.append({\"role\":\"user\", \"content\": sql_df.iloc[0]['question']})\n", - "pprint(messages)" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "38b704b3-6f0e-4708-bc70-96723d69da6f", - "metadata": {}, - "outputs": [], - "source": [ - "# Sending the message array to GPT, requesting a response (ensure that you have API key loaded to Env for this step)\n", + "system_prompt = \"\"\"Translate this natural language request into a JSON\n", + "object containing two SQL queries. The first query should be a CREATE \n", + "tatement for a table answering the user's request, while the second\n", + "should be a SELECT query answering their question.\"\"\"\n", "\n", + "# Sending the message array to GPT, requesting a response (ensure that you\n", + "# have API key loaded to Env for this step)\n", "client = OpenAI()\n", - "completion = client.beta.chat.completions.parse(\n", - " model=GPT_MODEL,\n", - " messages=messages,\n", - " response_format=LLMResponse,\n", - ")" + "\n", + "def get_response(system_prompt, user_message, model=GPT_MODEL):\n", + " messages = []\n", + " messages.append({\"role\": \"system\", \"content\": system_prompt})\n", + " messages.append({\"role\": \"user\", \"content\": user_message})\n", + "\n", + " response = client.beta.chat.completions.parse(\n", + " model=GPT_MODEL,\n", + " messages=messages,\n", + " response_format=LLMResponse,\n", + " )\n", + " return response.choices[0].message.content\n", + "\n", + "question = sql_df.iloc[0]['question']\n", + "content = get_response(system_prompt, question)\n", + "print(\"Question:\", question)\n", + "print(\"Answer:\", content)" ] }, { @@ -345,43 +316,14 @@ "\n", "Our first simple unit test checks that the LLM response is parseable into the `LLMResponse` Pydantic class that we've defined.\n", "\n", - "We'll test that our first response passes, then create a failing example to check that the check fails. This logic will be wrapped in a simple function `test_valid_schema`." - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "2b057391-4f83-4b5a-8843-a9ee74bee871", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{\"create\":\"CREATE TABLE department_heads (\\n id INT PRIMARY KEY,\\n name VARCHAR(100),\\n age INT\\n);\",\"select\":\"SELECT COUNT(*) FROM department_heads WHERE age > 56;\"}\n" - ] - } - ], - "source": [ - "# Viewing the output from GPT\n", - "\n", - "content = completion.choices[0].message.content\n", - "print(content)" - ] - }, - { - "cell_type": "markdown", - "id": "4b98bbb4-dd17-49bc-828c-e561abf5b481", - "metadata": {}, - "source": [ - "#### Validating the output schema\n", + "We'll test that our first response passes, then create a failing example to check that the check fails. This logic will be wrapped in a simple function `test_valid_schema`.\n", "\n", "We expect GPT to respond with a valid SQL, we can validate this using LLMResponse base model. `test_valid_schema` is designed to help us validate this." ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 6, "id": "4c7133f1-74d6-43f1-9443-09a3f8308c35", "metadata": {}, "outputs": [], @@ -399,7 +341,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 7, "id": "6a9a9128", "metadata": {}, "outputs": [ @@ -409,7 +351,7 @@ "True" ] }, - "execution_count": 10, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" } @@ -430,7 +372,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 8, "id": "a0a26690", "metadata": {}, "outputs": [ @@ -449,7 +391,7 @@ "False" ] }, - "execution_count": 11, + "execution_count": 8, "metadata": {}, "output_type": "execute_result" } @@ -486,7 +428,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 9, "id": "9cc95481", "metadata": {}, "outputs": [], @@ -529,7 +471,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 10, "id": "c6d2573d", "metadata": {}, "outputs": [], @@ -598,7 +540,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 11, "id": "a9266753-4646-4901-bc14-632d3bf47aaa", "metadata": {}, "outputs": [ @@ -606,12 +548,15 @@ "name": "stdout", "output_type": "stream", "text": [ - "CREATE SQL is: CREATE TABLE department_heads (\n", + "CREATE SQL is: CREATE TABLE DepartmentHeads (\n", " id INT PRIMARY KEY,\n", " name VARCHAR(100),\n", - " age INT\n", + " age INT,\n", + " department VARCHAR(100)\n", ");\n", - "SELECT SQL is: SELECT COUNT(*) FROM department_heads WHERE age > 56;\n" + "SELECT SQL is: SELECT COUNT(*) AS NumberOfHeadsOlderThan56 \n", + "FROM DepartmentHeads \n", + "WHERE age > 56;\n" ] } ], @@ -625,7 +570,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 12, "id": "83bc1f1b", "metadata": {}, "outputs": [ @@ -633,12 +578,15 @@ "name": "stdout", "output_type": "stream", "text": [ - "Testing create query: CREATE TABLE department_heads (\n", + "Testing create query: CREATE TABLE DepartmentHeads (\n", " id INT PRIMARY KEY,\n", " name VARCHAR(100),\n", - " age INT\n", + " age INT,\n", + " department VARCHAR(100)\n", ");\n", - "Testing select query: SELECT COUNT(*) FROM department_heads WHERE age > 56;\n", + "Testing select query: SELECT COUNT(*) AS NumberOfHeadsOlderThan56 \n", + "FROM DepartmentHeads \n", + "WHERE age > 56;\n", "Result of query: [(0,)]\n" ] }, @@ -648,7 +596,7 @@ "True" ] }, - "execution_count": 15, + "execution_count": 12, "metadata": {}, "output_type": "execute_result" } @@ -661,7 +609,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 13, "id": "589c7cc7", "metadata": {}, "outputs": [ @@ -680,7 +628,7 @@ "False" ] }, - "execution_count": 16, + "execution_count": 13, "metadata": {}, "output_type": "execute_result" } @@ -698,16 +646,16 @@ "id": "8148f820", "metadata": {}, "source": [ - "### Evaluation\n", + "### Using an LLM to evaluate relevancy\n", "\n", - "The last component is to **evaluate** whether the generated SQL actually answers the user's question. This test will be performed by `gpt-4o-mini`, and will assess how **relevant** the produced SQL query is when compared to the initial user request.\n", + "Next, we **evaluate** whether the generated SQL actually answers the user's question. This test will be performed by `gpt-4o-mini`, and will assess how **relevant** the produced SQL query is when compared to the initial user request.\n", "\n", "This is a simple example which adapts an approach outlined in the [G-Eval paper](https://arxiv.org/abs/2303.16634), and tested in one of our other [cookbooks](https://github.com/openai/openai-cookbook/blob/main/examples/evaluation/How_to_eval_abstractive_summarization.ipynb)." ] }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 14, "id": "029c8426", "metadata": {}, "outputs": [], @@ -760,7 +708,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 15, "id": "85cfb78d", "metadata": {}, "outputs": [], @@ -791,7 +739,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 16, "id": "607ee304", "metadata": {}, "outputs": [], @@ -812,7 +760,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 17, "id": "bd1002c2", "metadata": {}, "outputs": [ @@ -849,20 +797,12 @@ }, { "cell_type": "markdown", - "id": "afe98f7a-3e88-437f-a5cd-d105969d3020", + "id": "61b68e2a", "metadata": {}, "source": [ - "## " - ] - }, - { - "cell_type": "markdown", - "id": "fe04c6c7", - "metadata": {}, - "source": [ - "## Putting it all together\n", + "## Evaluation\n", "\n", - "We'll now test these functions in combination including our unit test and evaluations to test out two system prompts.\n", + "We will test these functions in combination including our unit test and evaluations to test out two system prompts.\n", "\n", "Each iteration of input/output and scores should be stored as a **run**. Optionally you can add GPT-4 annotation within your evaluations or as a separate step to review an entire run and highlight the reasons for errors.\n", "\n", @@ -871,72 +811,23 @@ }, { "cell_type": "markdown", - "id": "61b68e2a", + "id": "3b578b00-1b27-49de-8fd1-15c00ec99729", "metadata": {}, "source": [ - "### First run - System Prompt 1\n", + "### Building the test framework\n", "\n", - "The system under test is the first system prompt as shown below. This `run` will generate responses for this system prompt and evaluate the responses using the functions we've created so far." + "We want to build a function, `test_system_prompt`, which will run our unit tests and evaluation against a given system prompt." ] }, { "cell_type": "code", - "execution_count": 21, - "id": "85c44a17", - "metadata": {}, - "outputs": [], - "source": [ - "# Set first system prompt\n", - "system_prompt = \"\"\"Translate this natural language request into a JSON object containing two SQL queries.\n", - "\n", - "The first query should be a CREATE statement for a table answering the user's request, while the second\n", - "should be a SELECT query answering their question. \n", - "\"\"\"" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "id": "1244c44e", - "metadata": {}, - "outputs": [], - "source": [ - "def get_response(system_prompt,user_message,model=GPT_MODEL):\n", - " messages = []\n", - " messages.append({\"role\": \"system\", \"content\": system_prompt})\n", - " messages.append({\"role\": \"user\", \"content\": user_message})\n", - "\n", - " response = client.beta.chat.completions.parse(\n", - " model=GPT_MODEL,\n", - " messages=messages,\n", - " response_format=LLMResponse,\n", - " )\n", - " # response = client.chat.completions.create(model=GPT_MODEL,messages=messages,temperature=0,response_format=LLMResponse)\n", - " \n", - " return response.choices[0].message.content" - ] - }, - { - "cell_type": "markdown", - "id": "76c2723b-3060-400f-b6fe-c3c3c9d6907e", - "metadata": {}, - "source": [ - "#### Run the tests and evaluations\n", - "\n", - "The functions below, run unit test and evaluate responses" - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "id": "a98afa30", + "execution_count": 18, + "id": "40be5fae-4eb3-40ce-8645-613c24d5e0b4", "metadata": {}, "outputs": [], "source": [ "def execute_unit_tests(input_df, output_list, system_prompt):\n", - " \"\"\"Unit testing function that takes in a dataframe and appends test results to an output_list.\n", - "\n", - " This allows us to test multiple system prompts.\"\"\"\n", + " \"\"\"Unit testing function that takes in a dataframe and appends test results to an output_list.\"\"\"\n", "\n", " for x, y in tqdm(input_df.iterrows(), total=len(input_df)):\n", " model_response = get_response(system_prompt, y['question'])\n", @@ -961,30 +852,59 @@ " elif row['sql'] is False:\n", " return 'SQL incorrect'\n", " else:\n", - " return 'SQL correct'" + " return 'SQL correct'\n", + "\n", + "def test_system_prompt(test_df, system_prompt):\n", + " # Execute unit tests and capture results\n", + " results = []\n", + " execute_unit_tests(\n", + " input_df=test_df,\n", + " output_list=results,\n", + " system_prompt=system_prompt\n", + " )\n", + " \n", + " results_df = pd.DataFrame(results)\n", + " results_df.columns = ['question','response','format','sql']\n", + " \n", + " # Use `apply` to calculate the geval score and unit test evaluation\n", + " # for each generated response\n", + " results_df['evaluation_score'] = results_df.apply(\n", + " lambda x: get_geval_score(\n", + " RELEVANCY_SCORE_CRITERIA,\n", + " RELEVANCY_SCORE_STEPS,\n", + " x['question'],\n", + " x['response'],\n", + " 'relevancy'\n", + " ),\n", + " axis=1\n", + " )\n", + " results_df['unit_test_evaluation'] = results_df.apply(\n", + " lambda x: evaluate_row(x),\n", + " axis=1\n", + " )\n", + " return results_df" ] }, { - "cell_type": "code", - "execution_count": 24, - "id": "898e5069", + "cell_type": "markdown", + "id": "6abc2c22-d7c6-4f15-b519-60cc58ff7774", "metadata": {}, - "outputs": [], "source": [ - "# Select 50 unseen queries to test this one\n", - "test_df = sql_df.tail(50)" + "### System Prompt 1\n", + "\n", + "The system under test is the first system prompt as shown below. This `run` will generate responses for this system prompt and evaluate the responses using the functions we've created so far." ] }, { "cell_type": "code", - "execution_count": 25, - "id": "2baec278", + "execution_count": 19, + "id": "85c44a17", "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "5a1c63bbf32c412b8f649d06c1a28ef4", + "model_id": "4d39ec72385f4b74bed652bfa54427f8", "version_major": 2, "version_minor": 0 }, @@ -997,44 +917,17 @@ } ], "source": [ - "# Execute unit tests and capture results\n", - "results = []\n", + "system_prompt = \"\"\"Translate this natural language request into a JSON object\n", + "containing two SQL queries.\n", "\n", - "execute_unit_tests(input_df=test_df, output_list=results, system_prompt=system_prompt)" - ] - }, - { - "cell_type": "markdown", - "id": "a070a4bf-7435-4059-bf74-eb6129cbab2b", - "metadata": {}, - "source": [ - "#### Run Evaluation\n", + "The first query should be a CREATE statement for a table answering the user's\n", + "request, while the second should be a SELECT query answering their question. \n", + "\"\"\"\n", "\n", - "Now that we have generated the SQL based on system prompt 1 (run 1), we can run evaluation against the results. We use pandas `apply` function to \"apply\" evaluation to each resulting generation" - ] - }, - { - "cell_type": "code", - "execution_count": 26, - "id": "8fe18367", - "metadata": {}, - "outputs": [], - "source": [ - "results_df = pd.DataFrame(results)\n", - "results_df.columns = ['question','response','format','sql']\n", + "# Select 50 unseen queries to test this one\n", + "test_df = sql_df.tail(50)\n", "\n", - "# Execute evaluation\n", - "results_df['evaluation_score'] = results_df.apply(\n", - " lambda x: get_geval_score(\n", - " RELEVANCY_SCORE_CRITERIA,\n", - " RELEVANCY_SCORE_STEPS,\n", - " x['question'],\n", - " x['response'],\n", - " 'relevancy'\n", - " ),\n", - " axis=1\n", - ")\n", - "results_df['unit_test_evaluation'] = results_df.apply(lambda x: evaluate_row(x),axis=1)" + "results_df = test_system_prompt(test_df, system_prompt)" ] }, { @@ -1042,14 +935,14 @@ "id": "c3dd9b04-44e2-476c-86fd-c0a261b1cbdd", "metadata": {}, "source": [ - "## Viewing unit test results and evaluations - Run 1\n", - "\n", - "We can now group the outcomes of the unit test (which test the structure of response) and evaluation (which checks if the SQL is syntatically correct)." + "We can now group the outcomes of:\n", + "* the **unit tests**, which test the structure of response; and\n", + "* the **evaluation**, which checks if the SQL is syntatically correct." ] }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 20, "id": "15bf55ca-63e0-42a0-9846-703549710d4d", "metadata": {}, "outputs": [ @@ -1057,12 +950,12 @@ "data": { "text/plain": [ "unit_test_evaluation\n", - "SQL correct 41\n", - "SQL incorrect 9\n", + "SQL correct 46\n", + "SQL incorrect 4\n", "Name: count, dtype: int64" ] }, - "execution_count": 27, + "execution_count": 20, "metadata": {}, "output_type": "execute_result" } @@ -1073,7 +966,7 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 21, "id": "b3f98f81", "metadata": { "scrolled": true @@ -1083,13 +976,13 @@ "data": { "text/plain": [ "evaluation_score\n", - "5 36\n", - "4 13\n", + "5 33\n", + "4 16\n", "3 1\n", "Name: count, dtype: int64" ] }, - "execution_count": 28, + "execution_count": 21, "metadata": {}, "output_type": "execute_result" } @@ -1103,47 +996,21 @@ "id": "019f3a1d", "metadata": {}, "source": [ - "### Second run\n", + "### System Prompt 2\n", "\n", - "We now use a new system prompt to run same unit test and evaluation. Please note that we are using the same functions for unit testing and evaluations; the only change is the system prompt (which is under the test)." + "We now use a new system prompt to run same unit test and evaluation." ] }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 22, "id": "513a2da1", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Translate this natural language request into a JSON object containing two SQL queries. \n", - "The first query should be a CREATE statement for a table answering the user's request, while the second\n", - "should be a SELECT query answering their question.\n", - "Ensure the SQL is always generated on one line, never use \\n to separate rows.\n" - ] - } - ], - "source": [ - "system_prompt_2 = \"\"\"Translate this natural language request into a JSON object containing two SQL queries. \n", - "The first query should be a CREATE statement for a table answering the user's request, while the second\n", - "should be a SELECT query answering their question.\n", - "Ensure the SQL is always generated on one line, never use \\\\n to separate rows.\"\"\"\n", - "\n", - "print(system_prompt_2)" - ] - }, - { - "cell_type": "code", - "execution_count": 30, - "id": "70bd3e32", - "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "e64c52a42f1c4202a0c820f160c1504e", + "model_id": "032f5bc915c44d88a5a0aeb52e2c1bb4", "version_major": 2, "version_minor": 0 }, @@ -1156,25 +1023,16 @@ } ], "source": [ - "# Execute unit tests\n", - "results_2 = []\n", + "system_prompt_2 = \"\"\"Translate this natural language request into a JSON\n", + "object containing two SQL queries.\n", "\n", - "execute_unit_tests(input_df=test_df,output_list=results_2,system_prompt=system_prompt_2)" - ] - }, - { - "cell_type": "code", - "execution_count": 31, - "id": "04532d59", - "metadata": {}, - "outputs": [], - "source": [ - "results_2_df = pd.DataFrame(results_2)\n", - "results_2_df.columns = ['question','response','format','sql']\n", + "The first query should be a CREATE statement for a table answering the user's\n", + "request, while the second should be a SELECT query answering their question.\n", "\n", - "# Execute evaluation\n", - "results_2_df['evaluation_score'] = results_2_df.apply(lambda x: get_geval_score(RELEVANCY_SCORE_CRITERIA,RELEVANCY_SCORE_STEPS,x['question'],x['response'],'relevancy'),axis=1)\n", - "results_2_df['unit_test_evaluation'] = results_2_df.apply(lambda x: evaluate_row(x),axis=1)" + "Ensure the SQL is always generated on one line, never use \\\\n to separate rows.\"\"\"\n", + "\n", + "\n", + "results_2_df = test_system_prompt(test_df, system_prompt)" ] }, { @@ -1182,14 +1040,12 @@ "id": "cd95c3f9-f90d-451d-a32b-aeb066906779", "metadata": {}, "source": [ - "## Viewing unit test results and evaluations - Run 2\n", - "\n", - "We can now group the outcomes of the unit test (which test the structure of response) and evaluation (which checks if the SQL is syntatically correct)." + "As above, we can group the unit test and evaluation results." ] }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 23, "id": "cbaa4bdf", "metadata": {}, "outputs": [ @@ -1197,12 +1053,12 @@ "data": { "text/plain": [ "unit_test_evaluation\n", - "SQL correct 49\n", - "SQL incorrect 1\n", + "SQL correct 44\n", + "SQL incorrect 6\n", "Name: count, dtype: int64" ] }, - "execution_count": 32, + "execution_count": 23, "metadata": {}, "output_type": "execute_result" } @@ -1213,7 +1069,7 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 24, "id": "1ada474e", "metadata": { "scrolled": true @@ -1223,13 +1079,13 @@ "data": { "text/plain": [ "evaluation_score\n", - "5 36\n", - "4 13\n", + "5 34\n", + "4 15\n", "3 1\n", "Name: count, dtype: int64" ] }, - "execution_count": 33, + "execution_count": 24, "metadata": {}, "output_type": "execute_result" } @@ -1243,40 +1099,16 @@ "id": "1908c933", "metadata": {}, "source": [ - "## Report\n", + "## Reporting\n", "\n", "We'll make a simple dataframe to store and display the run performance - this is where you can use tools like Weights & Biases Prompts or Gantry to store the results for analytics on your different iterations." ] }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 25, "id": "d277222d", "metadata": {}, - "outputs": [], - "source": [ - "results_df['run'] = 1\n", - "results_df['Evaluating Model'] = 'gpt-4'\n", - "\n", - "results_2_df['run'] = 2\n", - "results_2_df['Evaluating Model'] = 'gpt-4'" - ] - }, - { - "cell_type": "code", - "execution_count": 35, - "id": "6da35c99", - "metadata": {}, - "outputs": [], - "source": [ - "run_df = pd.concat([results_df,results_2_df])" - ] - }, - { - "cell_type": "code", - "execution_count": 36, - "id": "4116cb37", - "metadata": {}, "outputs": [ { "data": { @@ -1324,7 +1156,7 @@ " \n", " 1\n", " What venue did the partnership of herschelle g...\n", - " {\"create\":\"CREATE TABLE cricket_partnerships (...\n", + " {\"create\":\"CREATE TABLE CricketPartnerships (\\...\n", " True\n", " True\n", " 5\n", @@ -1335,18 +1167,18 @@ " \n", " 2\n", " What is the number Played that has 310 Points ...\n", - " {\"create\":\"CREATE TABLE Scores (\\n id INT P...\n", + " {\"create\":\"CREATE TABLE game_stats (\\n numb...\n", + " True\n", " True\n", - " False\n", " 5\n", - " SQL incorrect\n", + " SQL correct\n", " 1\n", " gpt-4\n", " \n", " \n", " 3\n", " What Losing bonus has a Points against of 588?\n", - " {\"create\":\"CREATE TABLE FootballTeams (\\n T...\n", + " {\"create\":\"CREATE TABLE BonusInfo (\\n id IN...\n", " True\n", " True\n", " 5\n", @@ -1357,10 +1189,10 @@ " \n", " 4\n", " What Tries against has a Losing bonus of 7?\n", - " {\"create\":\"CREATE TABLE RugbyScores (\\n tea...\n", + " {\"create\":\"CREATE TABLE matches (\\n id SERI...\n", " True\n", " True\n", - " 4\n", + " 5\n", " SQL correct\n", " 1\n", " gpt-4\n", @@ -1377,33 +1209,50 @@ "3 What Losing bonus has a Points against of 588? \n", "4 What Tries against has a Losing bonus of 7? \n", "\n", - " response format sql \\\n", - "0 {\"create\":\"CREATE TABLE cricket_partnerships (... True True \n", - "1 {\"create\":\"CREATE TABLE cricket_partnerships (... True True \n", - "2 {\"create\":\"CREATE TABLE Scores (\\n id INT P... True False \n", - "3 {\"create\":\"CREATE TABLE FootballTeams (\\n T... True True \n", - "4 {\"create\":\"CREATE TABLE RugbyScores (\\n tea... True True \n", + " response format sql \\\n", + "0 {\"create\":\"CREATE TABLE cricket_partnerships (... True True \n", + "1 {\"create\":\"CREATE TABLE CricketPartnerships (\\... True True \n", + "2 {\"create\":\"CREATE TABLE game_stats (\\n numb... True True \n", + "3 {\"create\":\"CREATE TABLE BonusInfo (\\n id IN... True True \n", + "4 {\"create\":\"CREATE TABLE matches (\\n id SERI... True True \n", "\n", " evaluation_score unit_test_evaluation run Evaluating Model \n", "0 5 SQL correct 1 gpt-4 \n", "1 5 SQL correct 1 gpt-4 \n", - "2 5 SQL incorrect 1 gpt-4 \n", + "2 5 SQL correct 1 gpt-4 \n", "3 5 SQL correct 1 gpt-4 \n", - "4 4 SQL correct 1 gpt-4 " + "4 5 SQL correct 1 gpt-4 " ] }, - "execution_count": 36, + "execution_count": 25, "metadata": {}, "output_type": "execute_result" } ], "source": [ + "results_df['run'] = 1\n", + "results_df['Evaluating Model'] = 'gpt-4'\n", + "\n", + "results_2_df['run'] = 2\n", + "results_2_df['Evaluating Model'] = 'gpt-4'\n", + "\n", + "run_df = pd.concat([results_df,results_2_df])\n", "run_df.head()" ] }, + { + "cell_type": "markdown", + "id": "0162a009-fc43-484c-90f6-d59a8e52f365", + "metadata": {}, + "source": [ + "#### Plotting unit test results\n", + "\n", + "We can create a simple bar chart to visualise the results of unit tests for both runs." + ] + }, { "cell_type": "code", - "execution_count": 37, + "execution_count": 26, "id": "ed800f0c", "metadata": {}, "outputs": [ @@ -1441,20 +1290,20 @@ " \n", " 1\n", " SQL correct\n", - " 41\n", + " 46\n", " \n", " \n", " SQL incorrect\n", - " 9\n", + " 4\n", " \n", " \n", " 2\n", " SQL correct\n", - " 49\n", + " 44\n", " \n", " \n", " SQL incorrect\n", - " 1\n", + " 6\n", " \n", " \n", "\n", @@ -1463,44 +1312,37 @@ "text/plain": [ " Number of records\n", "run unit_test_evaluation \n", - "1 SQL correct 41\n", - " SQL incorrect 9\n", - "2 SQL correct 49\n", - " SQL incorrect 1" + "1 SQL correct 46\n", + " SQL incorrect 4\n", + "2 SQL correct 44\n", + " SQL incorrect 6" ] }, - "execution_count": 37, + "execution_count": 26, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "# Unit test results\n", - "unittest_df_pivot = pd.pivot_table(run_df, values='format',index=['run','unit_test_evaluation'], #columns='position',\n", - " aggfunc='count')\n", + "unittest_df_pivot = pd.pivot_table(\n", + " run_df,\n", + " values='format',\n", + " index=['run','unit_test_evaluation'],\n", + " aggfunc='count'\n", + ")\n", "unittest_df_pivot.columns = ['Number of records']\n", "unittest_df_pivot" ] }, - { - "cell_type": "markdown", - "id": "0162a009-fc43-484c-90f6-d59a8e52f365", - "metadata": {}, - "source": [ - "#### Plotting the results\n", - "\n", - "We can create a simple bar chart to visualise the results of unit tests for both runs." - ] - }, { "cell_type": "code", - "execution_count": 38, + "execution_count": 27, "id": "e2b4aa03-42f5-4c30-a610-e553937bf160", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1547,9 +1389,19 @@ "plt.show()" ] }, + { + "cell_type": "markdown", + "id": "786515fa-6841-4820-98f9-aa29ae76cf76", + "metadata": {}, + "source": [ + "#### Plotting evaluation results\n", + "\n", + "We can similarly plot the results of the evaluation." + ] + }, { "cell_type": "code", - "execution_count": 39, + "execution_count": 28, "id": "7228eac7-e0a9-473d-9432-e558bbc91841", "metadata": {}, "outputs": [ @@ -1591,11 +1443,11 @@ " \n", " \n", " 4\n", - " 13\n", + " 16\n", " \n", " \n", " 5\n", - " 36\n", + " 33\n", " \n", " \n", " 2\n", @@ -1604,11 +1456,11 @@ " \n", " \n", " 4\n", - " 13\n", + " 15\n", " \n", " \n", " 5\n", - " 36\n", + " 34\n", " \n", " \n", "\n", @@ -1618,45 +1470,38 @@ " Number of records\n", "run evaluation_score \n", "1 3 1\n", - " 4 13\n", - " 5 36\n", + " 4 16\n", + " 5 33\n", "2 3 1\n", - " 4 13\n", - " 5 36" + " 4 15\n", + " 5 34" ] }, - "execution_count": 39, + "execution_count": 28, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "# Unit test results\n", - "evaluation_df_pivot = pd.pivot_table(run_df, values='format',index=['run','evaluation_score'], #columns='position',\n", - " aggfunc='count')\n", + "evaluation_df_pivot = pd.pivot_table(\n", + " run_df,\n", + " values='format',\n", + " index=['run','evaluation_score'],\n", + " aggfunc='count'\n", + ")\n", "evaluation_df_pivot.columns = ['Number of records']\n", "evaluation_df_pivot" ] }, - { - "cell_type": "markdown", - "id": "786515fa-6841-4820-98f9-aa29ae76cf76", - "metadata": {}, - "source": [ - "#### Plotting the results\n", - "\n", - "We can create a simple bar chart to visualise the results of unit tests for both runs." - ] - }, { "cell_type": "code", - "execution_count": 40, + "execution_count": 29, "id": "b2a18a78-55ec-43f6-9d62-929707a94364", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1724,6 +1569,14 @@ "\n", "We hope you find this useful, and please supply any feedback." ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8368c786-38eb-4ca3-b5f4-cad63fec87bd", + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": {