From ee1ec0317a88e88f9c2f8ee3710f0c34b756c254 Mon Sep 17 00:00:00 2001 From: NirantK Date: Mon, 4 Sep 2023 19:37:24 +0530 Subject: [PATCH 01/38] * feat(fine-tuned-RAG): add .gitignore file for ignoring *.parquet files * feat(fine-tuned-RAG): add DatasetPrep.ipynb file for dataset preparation * feat(DatasetPrep.ipynb): add code for downloading validation.json file --- examples/fine-tuned-RAG/.gitignore | 1 + examples/fine-tuned-RAG/DatasetPrep.ipynb | 213 ++++++++++++++++++++++ 2 files changed, 214 insertions(+) create mode 100644 examples/fine-tuned-RAG/.gitignore create mode 100644 examples/fine-tuned-RAG/DatasetPrep.ipynb diff --git a/examples/fine-tuned-RAG/.gitignore b/examples/fine-tuned-RAG/.gitignore new file mode 100644 index 0000000000..bccc1450f2 --- /dev/null +++ b/examples/fine-tuned-RAG/.gitignore @@ -0,0 +1 @@ +*.parquet \ No newline at end of file diff --git a/examples/fine-tuned-RAG/DatasetPrep.ipynb b/examples/fine-tuned-RAG/DatasetPrep.ipynb new file mode 100644 index 0000000000..d24a14f572 --- /dev/null +++ b/examples/fine-tuned-RAG/DatasetPrep.ipynb @@ -0,0 +1,213 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Validation" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--2023-09-04 16:34:26-- https://rajpurkar.github.io/SQuAD-explorer/dataset/dev-v2.0.json\n", + "Resolving rajpurkar.github.io (rajpurkar.github.io)... 185.199.108.153, 185.199.109.153, 185.199.110.153, ...\n", + "Connecting to rajpurkar.github.io (rajpurkar.github.io)|185.199.108.153|:443... connected.\n", + "HTTP request sent, awaiting response... 200 OK\n", + "Length: 4370528 (4.2M) [application/json]\n", + "Saving to: ‘validation.json’\n", + "\n", + "validation.json 100%[===================>] 4.17M 5.66MB/s in 0.7s \n", + "\n", + "2023-09-04 16:34:28 (5.66 MB/s) - ‘validation.json’ saved [4370528/4370528]\n", + "\n" + ] + } + ], + "source": [ + "!wget https://rajpurkar.github.io/SQuAD-explorer/dataset/dev-v2.0.json -O validation.json" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# !pip install pandas qdrant-client openai --quiet" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "import json\n", + "\n", + "def json_to_dataframe_with_titles(json_data):\n", + " qas = []\n", + " context = []\n", + " is_impossible = []\n", + " answers = []\n", + " titles = []\n", + "\n", + " for article in json_data['data']:\n", + " title = article['title']\n", + " for paragraph in article['paragraphs']:\n", + " for qa in paragraph['qas']:\n", + " qas.append(qa['question'].strip())\n", + " context.append(paragraph['context'])\n", + " is_impossible.append(qa['is_impossible'])\n", + " \n", + " ans_list = []\n", + " for ans in qa['answers']:\n", + " ans_list.append(ans['text'])\n", + " answers.append(ans_list)\n", + " titles.append(title)\n", + "\n", + " df = pd.DataFrame({'title': titles, 'question': qas, 'context': context, 'is_impossible': is_impossible, 'answers': answers})\n", + " return df\n", + "\n", + "def get_diverse_sample(df, sample_size=100, random_state=42):\n", + " sample_df = df.groupby(['title', 'is_impossible']).apply(lambda x: x.sample(min(len(x), max(1, sample_size // 50)), random_state=random_state)).reset_index(drop=True)\n", + " \n", + " if len(sample_df) < sample_size:\n", + " remaining_sample_size = sample_size - len(sample_df)\n", + " remaining_df = df.drop(sample_df.index).sample(remaining_sample_size, random_state=random_state)\n", + " sample_df = pd.concat([sample_df, remaining_df]).sample(frac=1, random_state=random_state).reset_index(drop=True)\n", + "\n", + " return sample_df.sample(min(sample_size, len(sample_df)), random_state=random_state).reset_index(drop=True)\n", + "\n", + "validation = json.load(open('validation.json', 'r'))\n", + "validation_df = json_to_dataframe_with_titles(validation)\n", + "df = get_diverse_sample(validation_df, sample_size=1000, random_state=37)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "is_impossible\n", + "False 53\n", + "True 47\n", + "Name: count, dtype: int64" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.value_counts('is_impossible')" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "title\n", + "Southern_California 33\n", + "Geology 33\n", + "Jacksonville,_Florida 32\n", + "University_of_Chicago 32\n", + "Imperialism 31\n", + "1973_oil_crisis 31\n", + "Fresno,_California 31\n", + "Harvard_University 31\n", + "Scottish_Parliament 31\n", + "Sky_(United_Kingdom) 31\n", + "Normans 30\n", + "Packet_switching 30\n", + "Ctenophora 30\n", + "Rhine 30\n", + "Pharmacy 30\n", + "Intergovernmental_Panel_on_Climate_Change 30\n", + "Warsaw 29\n", + "Steam_engine 29\n", + "Victoria_(Australia) 29\n", + "Computational_complexity_theory 29\n", + "Amazon_rainforest 29\n", + "Civil_disobedience 29\n", + "European_Union_law 29\n", + "Huguenot 28\n", + "Construction 28\n", + "Private_school 28\n", + "Black_Death 26\n", + "Yuan_dynasty 26\n", + "Islamism 25\n", + "Oxygen 24\n", + "Prime_number 24\n", + "Immune_system 24\n", + "Force 23\n", + "Economic_inequality 23\n", + "French_and_Indian_War 22\n", + "Name: count, dtype: int64" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.title.value_counts()" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "# write to csv\n", + "df.to_json('v2_1K_Seed=37_sample.json', orient='records', lines=True)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "fst", + "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.9.17" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} From 18f5031f5a4a0b1c6cd1b10b6b03c4b4f15bbc76 Mon Sep 17 00:00:00 2001 From: NirantK Date: Mon, 4 Sep 2023 20:45:56 +0530 Subject: [PATCH 02/38] Add model finetune nbs --- examples/fine-tuned-RAG/ModelFinetune.ipynb | 840 ++++++++++++++++++++ 1 file changed, 840 insertions(+) create mode 100644 examples/fine-tuned-RAG/ModelFinetune.ipynb diff --git a/examples/fine-tuned-RAG/ModelFinetune.ipynb b/examples/fine-tuned-RAG/ModelFinetune.ipynb new file mode 100644 index 0000000000..eb8af4d1e0 --- /dev/null +++ b/examples/fine-tuned-RAG/ModelFinetune.ipynb @@ -0,0 +1,840 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "# !pip install pandas openai tqdm tenacity pandarallel scikit-learn tiktoken" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "import openai\n", + "import os\n", + "import time\n", + "from tenacity import retry, stop_after_attempt, wait_exponential\n", + "from sklearn.metrics import confusion_matrix\n", + "from tqdm import tqdm\n", + "tqdm.pandas()\n", + "openai.api_key = os.getenv(\"OPENAI_API_KEY\")" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "df = pd.read_json(\"v2_1K_Seed=37_sample.json\", lines=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
titlequestioncontextis_impossibleanswers
0Southern_CaliforniaWhat is the United State's second-busiest comm...Southern California is also home to the Port o...True[]
1Jacksonville,_FloridaWho did Jacksonville support with supplies dur...During the American Civil War, Jacksonville wa...True[]
2Imperialismcolonial rule would not be considered what typ...Imperialism is defined as \"A policy of extendi...True[]
3Intergovernmental_Panel_on_Climate_ChangeWhere are dissenting opinions published?Michael Oppenheimer, a long-time participant i...True[]
4Southern_CaliforniaHow many people does the Greater Los Angeles A...Southern California includes the heavily built...False[17.5 million, over 17.5 million, 17.5 million]
\n", + "
" + ], + "text/plain": [ + " title \\\n", + "0 Southern_California \n", + "1 Jacksonville,_Florida \n", + "2 Imperialism \n", + "3 Intergovernmental_Panel_on_Climate_Change \n", + "4 Southern_California \n", + "\n", + " question \\\n", + "0 What is the United State's second-busiest comm... \n", + "1 Who did Jacksonville support with supplies dur... \n", + "2 colonial rule would not be considered what typ... \n", + "3 Where are dissenting opinions published? \n", + "4 How many people does the Greater Los Angeles A... \n", + "\n", + " context is_impossible \\\n", + "0 Southern California is also home to the Port o... True \n", + "1 During the American Civil War, Jacksonville wa... True \n", + "2 Imperialism is defined as \"A policy of extendi... True \n", + "3 Michael Oppenheimer, a long-time participant i... True \n", + "4 Southern California includes the heavily built... False \n", + "\n", + " answers \n", + "0 [] \n", + "1 [] \n", + "2 [] \n", + "3 [] \n", + "4 [17.5 million, over 17.5 million, 17.5 million] " + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [], + "source": [ + "# Function to get prompt messages\n", + "def get_prompt(row):\n", + " return [\n", + " {'role': 'system', 'content': 'You are a helpful assistant.'},\n", + " {'role': 'user', 'content': f\"\"\"Answer the following Question based on the Context only. Only answer from the Context. If you don't know the answer, say 'I don't know'.\n", + " Question: {row.question}\\n\\n\n", + " Context: {row.context}\\n\\n\n", + " Answer:\\n\"\"\"},\n", + " ]\n", + "\n", + "# Function with tenacity for retries\n", + "@retry(wait=wait_exponential(multiplier=1, min=2, max=6))\n", + "def api_call(messages, model):\n", + " return openai.ChatCompletion.create(\n", + " model=model,\n", + " messages=messages,\n", + " stop=[\"\\n\\n\"],\n", + " max_tokens=100,\n", + " temperature=0.0,\n", + " )\n", + "\n", + "# Main function to answer question\n", + "def answer_question(row, model=\"gpt-3.5-turbo-0613\"):\n", + " messages = get_prompt(row)\n", + " response = api_call(messages, model)\n", + " return response['choices'][0]['message']['content']\n", + "\n", + "# Use progress_apply with tqdm for progress bar\n", + "df[\"generated_answer\"] = df.progress_apply(answer_question, axis=1)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "generated_answer\n", + "I don't know. 150\n", + "Oxygen 3\n", + "Arthur Woolf 2\n", + "For certain physical scenarios, forces are impossible to model as being due to the gradient of potentials because they arise from a macroscopic statistical average of microstates. 1\n", + "The derogatory term for the Christian academies that arose in the wake of school desegregation is \"segregation academies\". 1\n", + " ... \n", + "The Longwood Medical area is located in Boston. 1\n", + "On December 12, Washington and his men reached Fort Le Boeuf. 1\n", + "Non-governmental organizations are participants of the plenary sessions. 1\n", + "The Middle East was not a match for becoming another superpower confrontation with the USSR. 1\n", + "Temür Khan 1\n", + "Name: count, Length: 848, dtype: int64" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df[\"generated_answer\"].value_counts()" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "is_impossible\n", + "False 503\n", + "True 497\n", + "Name: count, dtype: int64" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.is_impossible.value_counts()" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "df.to_json(\"1K_with_generated_answers.json\", lines=True, orient=\"records\")" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Expected and Right 42.30%\n", + "Expected but IDK 0.00%\n", + "Expected but Wrong 8.00%\n", + "Hallucination 49.70%\n", + "Did not Expect and IDK 0.00%\n", + "Name: count, dtype: object" + ] + }, + "execution_count": 37, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Debugging and correcting the ConfusionMatrixEvaluator class to produce an accurate confusion matrix\n", + "class ConfusionMatrixEvaluator:\n", + " def __init__(self, df, answers_column=\"generated_answer\"):\n", + " self.df = df\n", + " self.y_pred = []\n", + " self.labels = [\n", + " 'Expected and Right', 'Expected but IDK', \n", + " 'Expected but Wrong', 'Hallucination', \n", + " 'Did not Expect and IDK'\n", + " ]\n", + " self.answers_column = answers_column\n", + " \n", + " def _evaluate_single_row(self, row):\n", + " is_impossible = row['is_impossible']\n", + " generated_answer = row[self.answers_column].lower()\n", + " actual_answers = [ans.lower() for ans in row['answers']]\n", + " \n", + " y_pred = (\n", + " 'Expected and Right' if not is_impossible and any(ans in generated_answer for ans in actual_answers) else\n", + " 'Expected but IDK' if not is_impossible and generated_answer == \"i don't know\" else\n", + " 'Expected but Wrong' if not is_impossible and generated_answer not in actual_answers else\n", + " 'Hallucination' if is_impossible and generated_answer != \"i don't know\" else\n", + " 'Did not Expect and IDK'\n", + " )\n", + " return y_pred\n", + " \n", + " def evaluate_answers(self):\n", + " self.y_pred = self.df.apply(self._evaluate_single_row, axis=1)\n", + " \n", + " def generate_matrices(self, use_percentages=False):\n", + " # Using value_counts to create a Series of frequencies, then reindexing to include missing labels with count 0\n", + " freq_series = self.y_pred.value_counts().reindex(self.labels, fill_value=0)\n", + " if use_percentages:\n", + " total = freq_series.sum()\n", + " freq_series = (freq_series / total * 100).apply(\"{0:.2f}%\".format)\n", + " return freq_series\n", + "\n", + "# Initialize the new evaluator\n", + "new_evaluator = ConfusionMatrixEvaluator(df, answers_column=\"generated_answer\")\n", + "\n", + "# Run the new evaluation\n", + "new_evaluator.evaluate_answers()\n", + "\n", + "# Generate the new confusion matrix\n", + "new_matrix = new_evaluator.generate_matrices(use_percentages=True)\n", + "\n", + "# Display the new matrix\n", + "new_matrix\n" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 1000/1000 [00:00<00:00, 59898.09it/s]\n" + ] + } + ], + "source": [ + "import json\n", + "def dataframe_to_jsonl_parallel(df):\n", + " def create_jsonl_entry(row):\n", + " answer = row['answers'][0] if row['answers'] else \"I don't know\"\n", + " messages = [\n", + " {'role': 'system', 'content': 'You are a helpful assistant.'},\n", + " {'role': 'user', 'content': f\"\"\"Answer the following Question based on the Context only. Only answer from the Context. If you don't know the answer, say 'I don't know'.\n", + " Question: {row.question}\\n\\n\n", + " Context: {row.context}\\n\\n\n", + " Answer:\\n\"\"\"},\n", + " {'role': 'assistant', 'content': answer}\n", + " ]\n", + " return json.dumps({'messages': messages})\n", + "\n", + " jsonl_output = df.progress_apply(create_jsonl_entry, axis=1)\n", + " return \"\\n\".join(jsonl_output)\n", + "\n", + "with open(\"squad-stratified-1000-ft-v2.json\", \"w\") as f:\n", + " f.write(dataframe_to_jsonl_parallel(df))" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "# # We start by importing the required packages\n", + "\n", + "# import json\n", + "# import os\n", + "# import tiktoken\n", + "# import numpy as np\n", + "# from collections import defaultdict\n", + "\n", + "# # Next, we specify the data path and open the JSONL file\n", + "\n", + "# data_path = \"squad-stratified-100-ft-v1.json\"\n", + "\n", + "# # Load dataset\n", + "# with open(data_path) as f:\n", + "# dataset = [json.loads(line) for line in f]\n", + "\n", + "# # We can inspect the data quickly by checking the number of examples and the first item\n", + "\n", + "# # Initial dataset stats\n", + "# print(\"Num examples:\", len(dataset))\n", + "# print(\"First example:\")\n", + "# for message in dataset[0][\"messages\"]:\n", + "# print(message)\n", + "\n", + "# # Now that we have a sense of the data, we need to go through all the different examples and check to make sure the formatting is correct and matches the Chat completions message structure\n", + "\n", + "# # Format error checks\n", + "# format_errors = defaultdict(int)\n", + "\n", + "# for ex in dataset:\n", + "# if not isinstance(ex, dict):\n", + "# format_errors[\"data_type\"] += 1\n", + "# continue\n", + "\n", + "# messages = ex.get(\"messages\", None)\n", + "# if not messages:\n", + "# format_errors[\"missing_messages_list\"] += 1\n", + "# continue\n", + "\n", + "# for message in messages:\n", + "# if \"role\" not in message or \"content\" not in message:\n", + "# format_errors[\"message_missing_key\"] += 1\n", + "\n", + "# if any(k not in (\"role\", \"content\", \"name\") for k in message):\n", + "# format_errors[\"message_unrecognized_key\"] += 1\n", + "\n", + "# if message.get(\"role\", None) not in (\"system\", \"user\", \"assistant\"):\n", + "# format_errors[\"unrecognized_role\"] += 1\n", + "\n", + "# content = message.get(\"content\", None)\n", + "# if not content or not isinstance(content, str):\n", + "# format_errors[\"missing_content\"] += 1\n", + "\n", + "# if not any(message.get(\"role\", None) == \"assistant\" for message in messages):\n", + "# format_errors[\"example_missing_assistant_message\"] += 1\n", + "\n", + "# if format_errors:\n", + "# print(\"Found errors:\")\n", + "# for k, v in format_errors.items():\n", + "# print(f\"{k}: {v}\")\n", + "# else:\n", + "# print(\"No errors found\")\n", + "\n", + "# # Beyond the structure of the message, we also need to ensure that the length does not exceed the 4096 token limit.\n", + "\n", + "# # Token counting functions\n", + "# encoding = tiktoken.get_encoding(\"cl100k_base\")\n", + "\n", + "# # not exact!\n", + "# # simplified from https://github.com/openai/openai-cookbook/blob/main/examples/How_to_count_tokens_with_tiktoken.ipynb\n", + "# def num_tokens_from_messages(messages, tokens_per_message=3, tokens_per_name=1):\n", + "# num_tokens = 0\n", + "# for message in messages:\n", + "# num_tokens += tokens_per_message\n", + "# for key, value in message.items():\n", + "# num_tokens += len(encoding.encode(value))\n", + "# if key == \"name\":\n", + "# num_tokens += tokens_per_name\n", + "# num_tokens += 3\n", + "# return num_tokens\n", + "\n", + "# def num_assistant_tokens_from_messages(messages):\n", + "# num_tokens = 0\n", + "# for message in messages:\n", + "# if message[\"role\"] == \"assistant\":\n", + "# num_tokens += len(encoding.encode(message[\"content\"]))\n", + "# return num_tokens\n", + "\n", + "# def print_distribution(values, name):\n", + "# print(f\"\\n#### Distribution of {name}:\")\n", + "# print(f\"min / max: {min(values)}, {max(values)}\")\n", + "# print(f\"mean / median: {np.mean(values)}, {np.median(values)}\")\n", + "# print(f\"p5 / p95: {np.quantile(values, 0.1)}, {np.quantile(values, 0.9)}\")\n", + "\n", + "# # Last, we can look at the results of the different formatting operations before proceeding with creating a fine-tuning job:\n", + "\n", + "# # Warnings and tokens counts\n", + "# n_missing_system = 0\n", + "# n_missing_user = 0\n", + "# n_messages = []\n", + "# convo_lens = []\n", + "# assistant_message_lens = []\n", + "\n", + "# for ex in dataset:\n", + "# messages = ex[\"messages\"]\n", + "# if not any(message[\"role\"] == \"system\" for message in messages):\n", + "# n_missing_system += 1\n", + "# if not any(message[\"role\"] == \"user\" for message in messages):\n", + "# n_missing_user += 1\n", + "# n_messages.append(len(messages))\n", + "# convo_lens.append(num_tokens_from_messages(messages))\n", + "# assistant_message_lens.append(num_assistant_tokens_from_messages(messages))\n", + "\n", + "# print(\"Num examples missing system message:\", n_missing_system)\n", + "# print(\"Num examples missing user message:\", n_missing_user)\n", + "# print_distribution(n_messages, \"num_messages_per_example\")\n", + "# print_distribution(convo_lens, \"num_total_tokens_per_example\")\n", + "# print_distribution(assistant_message_lens, \"num_assistant_tokens_per_example\")\n", + "# n_too_long = sum(l > 4096 for l in convo_lens)\n", + "# print(f\"\\n{n_too_long} examples may be over the 4096 token limit, they will be truncated during fine-tuning\")\n", + "\n", + "# # Pricing and default n_epochs estimate\n", + "# MAX_TOKENS_PER_EXAMPLE = 4096\n", + "\n", + "# MIN_TARGET_EXAMPLES = 100\n", + "# MAX_TARGET_EXAMPLES = 25000\n", + "# TARGET_EPOCHS = 3\n", + "# MIN_EPOCHS = 1\n", + "# MAX_EPOCHS = 25\n", + "\n", + "# n_epochs = TARGET_EPOCHS\n", + "# n_train_examples = len(dataset)\n", + "# if n_train_examples * TARGET_EPOCHS < MIN_TARGET_EXAMPLES:\n", + "# n_epochs = min(MAX_EPOCHS, MIN_TARGET_EXAMPLES // n_train_examples)\n", + "# elif n_train_examples * TARGET_EPOCHS > MAX_TARGET_EXAMPLES:\n", + "# n_epochs = max(MIN_EPOCHS, MAX_TARGET_EXAMPLES // n_train_examples)\n", + "\n", + "# n_billing_tokens_in_dataset = sum(min(MAX_TOKENS_PER_EXAMPLE, length) for length in convo_lens)\n", + "# print(f\"Dataset has ~{n_billing_tokens_in_dataset} tokens that will be charged for during training\")\n", + "# print(f\"By default, you'll train for {n_epochs} epochs on this dataset\")\n", + "# print(f\"By default, you'll be charged for ~{n_epochs * n_billing_tokens_in_dataset} tokens\")\n", + "# print(\"See pricing page to estimate total costs\")" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + " JSON: {\n", + " \"object\": \"file\",\n", + " \"id\": \"file-TjkDD0C39b4S1JZstMly98pv\",\n", + " \"purpose\": \"fine-tune\",\n", + " \"filename\": \"file\",\n", + " \"bytes\": 131291,\n", + " \"created_at\": 1693836561,\n", + " \"status\": \"uploaded\",\n", + " \"status_details\": null\n", + "}" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "\n", + "file_object = openai.File.create(\n", + " file=open(\"squad-stratified-100-ft-v1.json\", \"r\"),\n", + " purpose='fine-tune',\n", + "\n", + ")\n", + "file_object" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "while file_object['status'] != 'processed':\n", + " file_object = openai.File.retrieve(file_object['id'])\n", + " time.sleep(1)\n", + "\n", + "ft_job = openai.FineTuningJob.create(training_file=file_object['id'], model=\"gpt-3.5-turbo\", suffix=\"v1\")" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + " JSON: {\n", + " \"object\": \"list\",\n", + " \"data\": [\n", + " {\n", + " \"object\": \"fine_tuning.job\",\n", + " \"id\": \"ftjob-x29xZik7Ey48fp3P0y8W7s7j\",\n", + " \"model\": \"gpt-3.5-turbo-0613\",\n", + " \"created_at\": 1693836623,\n", + " \"finished_at\": null,\n", + " \"fine_tuned_model\": null,\n", + " \"organization_id\": \"org-eC1aoPhsmmzdbEKUb4A3nXwv\",\n", + " \"result_files\": [],\n", + " \"status\": \"running\",\n", + " \"validation_file\": null,\n", + " \"training_file\": \"file-TjkDD0C39b4S1JZstMly98pv\",\n", + " \"hyperparameters\": {\n", + " \"n_epochs\": 3\n", + " },\n", + " \"trained_tokens\": null\n", + " }\n", + " ],\n", + " \"has_more\": false\n", + "}" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "openai.FineTuningJob.list(limit=10)" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [], + "source": [ + "import time\n", + "while openai.FineTuningJob.retrieve(ft_job[\"id\"]).fine_tuned_model == None:\n", + " time.sleep(10)\n", + "ft_model = openai.FineTuningJob.retrieve(ft_job[\"id\"]).fine_tuned_model" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [], + "source": [ + "model_id = ft_model" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{\n", + " \"role\": \"assistant\",\n", + " \"content\": \"I don't know\"\n", + "}\n" + ] + } + ], + "source": [ + "completion = openai.ChatCompletion.create(\n", + " model=model_id,\n", + " messages=[\n", + " {\"role\": \"system\", \"content\": \"You are a helpful assistant.\"},\n", + " {\"role\": \"user\", \"content\": \"Hello!\"},\n", + " {\"role\": \"assistant\", \"content\": \"Hi, how can I help you today?\"},\n", + " {\"role\": \"user\", \"content\": \"Can you answer the following question based on the given context? If not, say, I don't know:\\n\\nQuestion: What is the capital of France?\\n\\nContext: The capital of Mars is Gaia. Answer:\"},\n", + " ]\n", + ")\n", + "\n", + "print(completion.choices[0].message)" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 1000/1000 [12:14<00:00, 1.36it/s] \n" + ] + } + ], + "source": [ + "df[\"ft_generated_answer\"] = df.progress_apply(answer_question, model=model_id, axis=1)" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "ft_generated_answer\n", + "I don't know 578\n", + "ITV Digital 2\n", + "They viewed the economic value of the Caribbean islands' sugar cane to be greater and easier to defend than the furs from the continent 2\n", + "Hoesung Lee 2\n", + "Bendigo 2\n", + " ... \n", + "15,000 1\n", + "Ibn Sina 1\n", + "Consolidated City of Jacksonville 1\n", + "Allston Science Complex 1\n", + "1850 1\n", + "Name: count, Length: 415, dtype: int64" + ] + }, + "execution_count": 33, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df[\"ft_generated_answer\"].value_counts()" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Expected and Right 30.10%\n", + "Expected but IDK 15.20%\n", + "Expected but Wrong 5.00%\n", + "Hallucination 7.10%\n", + "Did not Expect and IDK 42.60%\n", + "Name: count, dtype: object" + ] + }, + "execution_count": 38, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Initialize the new evaluator\n", + "new_evaluator = ConfusionMatrixEvaluator(df, answers_column=\"ft_generated_answer\")\n", + "\n", + "# Run the new evaluation\n", + "new_evaluator.evaluate_answers()\n", + "\n", + "# Generate the new confusion matrix\n", + "new_matrix = new_evaluator.generate_matrices(use_percentages=True)\n", + "\n", + "# Display the new matrix\n", + "new_matrix" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [], + "source": [ + "df.to_json(\"1K_with_ft_generated_answers.json\", lines=True, orient=\"records\")" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Importing required libraries for plotting\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "def evaluate_matrix(df, answers_column):\n", + " \"\"\"\n", + " Evaluate the confusion matrix for a given DataFrame and answer column.\n", + " \"\"\"\n", + " evaluator = ConfusionMatrixEvaluator(df, answers_column=answers_column)\n", + " evaluator.evaluate_answers()\n", + " matrix = evaluator.generate_matrices(use_percentages=True)\n", + " return matrix\n", + "\n", + "def plot_overall_error(matrix1, matrix2, label1, label2):\n", + " \"\"\"\n", + " Plot a bar chart showing only the overall error between two confusion matrices.\n", + " \"\"\"\n", + " # Calculate overall error\n", + " error_categories = ['Expected but Wrong', 'Hallucination']\n", + " matrix1_error = sum([float(matrix1.loc[cat].replace('%', '')) for cat in error_categories])\n", + " matrix2_error = sum([float(matrix2.loc[cat].replace('%', '')) for cat in error_categories])\n", + " \n", + " labels = ['Overall Error']\n", + " matrix1_values = [matrix1_error]\n", + " matrix2_values = [matrix2_error]\n", + " \n", + " x = np.arange(len(labels))\n", + " width = 0.35\n", + " \n", + " fig, ax = plt.subplots()\n", + " rects1 = ax.bar(x - width/2, matrix1_values, width, label=label1)\n", + " rects2 = ax.bar(x + width/2, matrix2_values, width, label=label2)\n", + " \n", + " ax.set_ylabel('Percentage (%)')\n", + " ax.set_title('Overall Error Comparison between {} and {}'.format(label1, label2))\n", + " ax.set_xticks(x)\n", + " ax.set_xticklabels(labels)\n", + " ax.legend()\n", + " \n", + " fig.tight_layout()\n", + " plt.show()\n", + "\n", + "# Plot only the overall error\n", + "plot_overall_error(matrix_plain, matrix_ft, \"gpt-3.5-turbo-0613\", \"FineTuned gpt-3.5-turbo-0613\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "fst", + "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.9.17" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} From 18aed3d23f9393833f90ec9df501567a965c2251 Mon Sep 17 00:00:00 2001 From: NirantK Date: Mon, 4 Sep 2023 21:19:47 +0530 Subject: [PATCH 03/38] Make it easier to follow! --- examples/fine-tuned-RAG/ModelFinetune.ipynb | 325 ++++++++++---------- 1 file changed, 159 insertions(+), 166 deletions(-) diff --git a/examples/fine-tuned-RAG/ModelFinetune.ipynb b/examples/fine-tuned-RAG/ModelFinetune.ipynb index eb8af4d1e0..44d7f4543c 100644 --- a/examples/fine-tuned-RAG/ModelFinetune.ipynb +++ b/examples/fine-tuned-RAG/ModelFinetune.ipynb @@ -1,5 +1,35 @@ { "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Finetuning for RAG\n", + "\n", + "Here, we'll take you through the process, complete with code examples, to help you fine-tune your OpenAI model for usage with RAG like a pro.\n", + "\n", + "To begin, we've selected a dataset where we've a guarantee that the retrieval is perfect. We've selected a subset of the [SQuAD](https://rajpurkar.github.io/SQuAD-explorer/) dataset, which is a collection of questions and answers about Wikipedia articles. We've also included samples where the answer is not present in the context, to demonstrate how RAG handles this case.\n", + "\n", + "## Table of Contents\n", + "1. Setting up the Environment\n", + "2. Data Preparation\n", + "3. Running the Model\n", + "4. Evaluation\n", + "5. Fine-Tuning\n", + "6. Comparison" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Setting Up\n", + "\n", + "### Install and Import Dependencies" + ] + }, { "cell_type": "code", "execution_count": 1, @@ -15,17 +45,33 @@ "metadata": {}, "outputs": [], "source": [ - "import pandas as pd\n", - "import openai\n", + "import json\n", "import os\n", "import time\n", - "from tenacity import retry, stop_after_attempt, wait_exponential\n", + "\n", + "import pandas as pd\n", + "import openai\n", "from sklearn.metrics import confusion_matrix\n", + "from tenacity import retry, stop_after_attempt, wait_exponential\n", "from tqdm import tqdm\n", + "import tiktoken\n", + "import numpy as np\n", + "from collections import defaultdict\n", + "\n", "tqdm.pandas()\n", "openai.api_key = os.getenv(\"OPENAI_API_KEY\")" ] }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Loading the Data\n", + "\n", + "Load your data and take a quick look at the first few rows. Notice that we've included a few samples where the answer is not present in the context." + ] + }, { "cell_type": "code", "execution_count": 3, @@ -152,6 +198,17 @@ "df.head()" ] }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Using the OpenAI Model for Question Answering\n", + "\n", + "### Prompt, API Call, and Answer\n", + "Create functions to get prompt messages and make API calls:" + ] + }, { "cell_type": "code", "execution_count": 30, @@ -183,65 +240,25 @@ "def answer_question(row, model=\"gpt-3.5-turbo-0613\"):\n", " messages = get_prompt(row)\n", " response = api_call(messages, model)\n", - " return response['choices'][0]['message']['content']\n", - "\n", - "# Use progress_apply with tqdm for progress bar\n", - "df[\"generated_answer\"] = df.progress_apply(answer_question, axis=1)" + " return response['choices'][0]['message']['content']\n" ] }, { - "cell_type": "code", - "execution_count": 6, + "attachments": {}, + "cell_type": "markdown", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "generated_answer\n", - "I don't know. 150\n", - "Oxygen 3\n", - "Arthur Woolf 2\n", - "For certain physical scenarios, forces are impossible to model as being due to the gradient of potentials because they arise from a macroscopic statistical average of microstates. 1\n", - "The derogatory term for the Christian academies that arose in the wake of school desegregation is \"segregation academies\". 1\n", - " ... \n", - "The Longwood Medical area is located in Boston. 1\n", - "On December 12, Washington and his men reached Fort Le Boeuf. 1\n", - "Non-governmental organizations are participants of the plenary sessions. 1\n", - "The Middle East was not a match for becoming another superpower confrontation with the USSR. 1\n", - "Temür Khan 1\n", - "Name: count, Length: 848, dtype: int64" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - } - ], "source": [ - "df[\"generated_answer\"].value_counts()" + "### Running the model" ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "is_impossible\n", - "False 503\n", - "True 497\n", - "Name: count, dtype: int64" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ - "df.is_impossible.value_counts()" + "# Use progress_apply with tqdm for progress bar\n", + "df[\"generated_answer\"] = df.progress_apply(answer_question, axis=1)" ] }, { @@ -250,12 +267,29 @@ "metadata": {}, "outputs": [], "source": [ - "df.to_json(\"1K_with_generated_answers.json\", lines=True, orient=\"records\")" + "# Optionally, save the results to a JSON file\n", + "# df.to_json(\"1K_with_generated_answers.json\", lines=True, orient=\"records\") # Save to JSON" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Evaluation\n", + "\n", + "To evaluate the model's performance, compare the predicted answer to the actual answers -- if any of the actual answers are present in the predicted answer, then it's a match. We've also created error categories to help you understand where the model is struggling.\n", + "\n", + "1. Expected and Right: The model responsded the correct answer. It may have also included other answers that were not in the context.\n", + "2. Expected but \"IDK\": The model responded with \"I don't know\" (IDK) while the answer was present in the context. **This is a LLM error.**\n", + "3. Expected but Wrong: The model responded with an incorrect answer.\n", + "4. Hallucination: The model responded with an answer, when none was expected. The expected response was \"I don't know\". **This is a LLM error.** \n", + "5. Did not expect and IDK: The model responded with \"I don't know\" (IDK) and the answer was not present in the context. *This is a LLM WIN.*" ] }, { "cell_type": "code", - "execution_count": 37, + "execution_count": null, "metadata": {}, "outputs": [ { @@ -275,7 +309,6 @@ } ], "source": [ - "# Debugging and correcting the ConfusionMatrixEvaluator class to produce an accurate confusion matrix\n", "class ConfusionMatrixEvaluator:\n", " def __init__(self, df, answers_column=\"generated_answer\"):\n", " self.df = df\n", @@ -312,17 +345,20 @@ " freq_series = (freq_series / total * 100).apply(\"{0:.2f}%\".format)\n", " return freq_series\n", "\n", - "# Initialize the new evaluator\n", - "new_evaluator = ConfusionMatrixEvaluator(df, answers_column=\"generated_answer\")\n", - "\n", - "# Run the new evaluation\n", - "new_evaluator.evaluate_answers()\n", - "\n", - "# Generate the new confusion matrix\n", - "new_matrix = new_evaluator.generate_matrices(use_percentages=True)\n", + "evaluator = ConfusionMatrixEvaluator(df, answers_column=\"generated_answer\")\n", + "evaluator.evaluate_answers()\n", + "error_categories = evaluator.generate_matrices(use_percentages=True)\n", + "error_categories" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Fine-Tuning\n", "\n", - "# Display the new matrix\n", - "new_matrix\n" + "### Prepare the Fine-Tuning Data" ] }, { @@ -339,8 +375,7 @@ } ], "source": [ - "import json\n", - "def dataframe_to_jsonl_parallel(df):\n", + "def dataframe_to_jsonl(df):\n", " def create_jsonl_entry(row):\n", " answer = row['answers'][0] if row['answers'] else \"I don't know\"\n", " messages = [\n", @@ -357,7 +392,17 @@ " return \"\\n\".join(jsonl_output)\n", "\n", "with open(\"squad-stratified-1000-ft-v2.json\", \"w\") as f:\n", - " f.write(dataframe_to_jsonl_parallel(df))" + " f.write(dataframe_to_jsonl(df))" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### [Optional] Verify the Fine-Tuning Data\n", + "\n", + "The script below will verify that the data is in the format that OpenAI expects." ] }, { @@ -370,9 +415,6 @@ "\n", "# import json\n", "# import os\n", - "# import tiktoken\n", - "# import numpy as np\n", - "# from collections import defaultdict\n", "\n", "# # Next, we specify the data path and open the JSONL file\n", "\n", @@ -510,6 +552,14 @@ "# print(\"See pricing page to estimate total costs\")" ] }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Push the Fine-Tuning data to OpenAI" + ] + }, { "cell_type": "code", "execution_count": 16, @@ -536,68 +586,34 @@ } ], "source": [ - "\n", "file_object = openai.File.create(\n", " file=open(\"squad-stratified-100-ft-v1.json\", \"r\"),\n", " purpose='fine-tune',\n", "\n", ")\n", - "file_object" + "\n", + "while file_object['status'] != 'processed':\n", + " file_object = openai.File.retrieve(file_object['id'])\n", + " time.sleep(5)" ] }, { - "cell_type": "code", - "execution_count": 19, + "attachments": {}, + "cell_type": "markdown", "metadata": {}, - "outputs": [], "source": [ - "while file_object['status'] != 'processed':\n", - " file_object = openai.File.retrieve(file_object['id'])\n", - " time.sleep(1)\n", - "\n", - "ft_job = openai.FineTuningJob.create(training_file=file_object['id'], model=\"gpt-3.5-turbo\", suffix=\"v1\")" + "### Create Fine Tuning Job" ] }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 19, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - " JSON: {\n", - " \"object\": \"list\",\n", - " \"data\": [\n", - " {\n", - " \"object\": \"fine_tuning.job\",\n", - " \"id\": \"ftjob-x29xZik7Ey48fp3P0y8W7s7j\",\n", - " \"model\": \"gpt-3.5-turbo-0613\",\n", - " \"created_at\": 1693836623,\n", - " \"finished_at\": null,\n", - " \"fine_tuned_model\": null,\n", - " \"organization_id\": \"org-eC1aoPhsmmzdbEKUb4A3nXwv\",\n", - " \"result_files\": [],\n", - " \"status\": \"running\",\n", - " \"validation_file\": null,\n", - " \"training_file\": \"file-TjkDD0C39b4S1JZstMly98pv\",\n", - " \"hyperparameters\": {\n", - " \"n_epochs\": 3\n", - " },\n", - " \"trained_tokens\": null\n", - " }\n", - " ],\n", - " \"has_more\": false\n", - "}" - ] - }, - "execution_count": 20, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ - "openai.FineTuningJob.list(limit=10)" + "ft_job = openai.FineTuningJob.create(training_file=file_object['id'], model=\"gpt-3.5-turbo\", suffix=\"v1\")\n", + "while openai.FineTuningJob.retrieve(ft_job[\"id\"]).fine_tuned_model == None:\n", + " time.sleep(10)" ] }, { @@ -606,19 +622,15 @@ "metadata": {}, "outputs": [], "source": [ - "import time\n", - "while openai.FineTuningJob.retrieve(ft_job[\"id\"]).fine_tuned_model == None:\n", - " time.sleep(10)\n", - "ft_model = openai.FineTuningJob.retrieve(ft_job[\"id\"]).fine_tuned_model" + "model_id = openai.FineTuningJob.retrieve(ft_job[\"id\"]).fine_tuned_model" ] }, { - "cell_type": "code", - "execution_count": 28, + "attachments": {}, + "cell_type": "markdown", "metadata": {}, - "outputs": [], "source": [ - "model_id = ft_model" + "### Try out the Fine-Tuned Model" ] }, { @@ -651,6 +663,16 @@ "print(completion.choices[0].message)" ] }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Comparison\n", + "\n", + "### Get Answers from the Fine-Tuned Model" + ] + }, { "cell_type": "code", "execution_count": 32, @@ -668,38 +690,6 @@ "df[\"ft_generated_answer\"] = df.progress_apply(answer_question, model=model_id, axis=1)" ] }, - { - "cell_type": "code", - "execution_count": 33, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "ft_generated_answer\n", - "I don't know 578\n", - "ITV Digital 2\n", - "They viewed the economic value of the Caribbean islands' sugar cane to be greater and easier to defend than the furs from the continent 2\n", - "Hoesung Lee 2\n", - "Bendigo 2\n", - " ... \n", - "15,000 1\n", - "Ibn Sina 1\n", - "Consolidated City of Jacksonville 1\n", - "Allston Science Complex 1\n", - "1850 1\n", - "Name: count, Length: 415, dtype: int64" - ] - }, - "execution_count": 33, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "df[\"ft_generated_answer\"].value_counts()" - ] - }, { "cell_type": "code", "execution_count": 38, @@ -722,17 +712,13 @@ } ], "source": [ - "# Initialize the new evaluator\n", - "new_evaluator = ConfusionMatrixEvaluator(df, answers_column=\"ft_generated_answer\")\n", - "\n", - "# Run the new evaluation\n", - "new_evaluator.evaluate_answers()\n", + "# Initialize the evaluator\n", + "finetuned_model_evaluator = ConfusionMatrixEvaluator(df, answers_column=\"ft_generated_answer\")\n", "\n", - "# Generate the new confusion matrix\n", - "new_matrix = new_evaluator.generate_matrices(use_percentages=True)\n", - "\n", - "# Display the new matrix\n", - "new_matrix" + "# Run the evaluation\n", + "finetuned_model_evaluator.evaluate_answers()\n", + "finetuned_model_error_categories = finetuned_model_evaluator.generate_matrices(use_percentages=True)\n", + "finetuned_model_error_categories" ] }, { @@ -744,6 +730,13 @@ "df.to_json(\"1K_with_ft_generated_answers.json\", lines=True, orient=\"records\")" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Plotting the Results" + ] + }, { "cell_type": "code", "execution_count": 46, From b95e5f00761041eeeef8ce91228be56f36fb2447 Mon Sep 17 00:00:00 2001 From: NirantK Date: Mon, 4 Sep 2023 21:24:32 +0530 Subject: [PATCH 04/38] * docs(ModelFinetune.ipynb): update error categories descriptions * docs(ModelFinetune.ipynb): add comments to code --- examples/fine-tuned-RAG/ModelFinetune.ipynb | 18 ++++++++++++------ 1 file changed, 12 insertions(+), 6 deletions(-) diff --git a/examples/fine-tuned-RAG/ModelFinetune.ipynb b/examples/fine-tuned-RAG/ModelFinetune.ipynb index 44d7f4543c..c8bf9855ab 100644 --- a/examples/fine-tuned-RAG/ModelFinetune.ipynb +++ b/examples/fine-tuned-RAG/ModelFinetune.ipynb @@ -5,10 +5,14 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Finetuning for RAG\n", + "# Finetuning for RAG\n", + "\n", + "\n", "\n", "Here, we'll take you through the process, complete with code examples, to help you fine-tune your OpenAI model for usage with RAG like a pro.\n", "\n", + "\n", + "\n", "To begin, we've selected a dataset where we've a guarantee that the retrieval is perfect. We've selected a subset of the [SQuAD](https://rajpurkar.github.io/SQuAD-explorer/) dataset, which is a collection of questions and answers about Wikipedia articles. We've also included samples where the answer is not present in the context, to demonstrate how RAG handles this case.\n", "\n", "## Table of Contents\n", @@ -281,10 +285,10 @@ "To evaluate the model's performance, compare the predicted answer to the actual answers -- if any of the actual answers are present in the predicted answer, then it's a match. We've also created error categories to help you understand where the model is struggling.\n", "\n", "1. Expected and Right: The model responsded the correct answer. It may have also included other answers that were not in the context.\n", - "2. Expected but \"IDK\": The model responded with \"I don't know\" (IDK) while the answer was present in the context. **This is a LLM error.**\n", - "3. Expected but Wrong: The model responded with an incorrect answer.\n", - "4. Hallucination: The model responded with an answer, when none was expected. The expected response was \"I don't know\". **This is a LLM error.** \n", - "5. Did not expect and IDK: The model responded with \"I don't know\" (IDK) and the answer was not present in the context. *This is a LLM WIN.*" + "2. Expected but \"IDK\": The model responded with \"I don't know\" (IDK) while the answer was present in the context. *This is a model error* and better than giving the wrong answer. We exclude this from the overall error rate.\n", + "3. Expected but Wrong: The model responded with an incorrect answer. *This is a model ERROR.*\n", + "4. Hallucination: The model responded with an answer, when \"I don't know\" was expected. **This is a model error.** \n", + "5. Did not expect and IDK: The model responded with \"I don't know\" (IDK) and the answer was not present in the context. *This is a model WIN.*" ] }, { @@ -727,10 +731,12 @@ "metadata": {}, "outputs": [], "source": [ - "df.to_json(\"1K_with_ft_generated_answers.json\", lines=True, orient=\"records\")" + "# Optionally, save the results to a JSON file\n", + "# df.to_json(\"1K_with_ft_generated_answers.json\", lines=True, orient=\"records\") " ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ From 3088e4dbe76d2670c5ccd812c9f67471475bc266 Mon Sep 17 00:00:00 2001 From: NirantK Date: Mon, 4 Sep 2023 21:29:16 +0530 Subject: [PATCH 05/38] * docs(fine-tuned-RAG): add documentation for few-shot learning with Qdrant to improve RAG model * feat(fine-tuned-RAG): use Qdrant for finetuning and inference changes --- examples/fine-tuned-RAG/ModelFinetune.ipynb | 15 +++++++++++---- 1 file changed, 11 insertions(+), 4 deletions(-) diff --git a/examples/fine-tuned-RAG/ModelFinetune.ipynb b/examples/fine-tuned-RAG/ModelFinetune.ipynb index c8bf9855ab..7b551e9712 100644 --- a/examples/fine-tuned-RAG/ModelFinetune.ipynb +++ b/examples/fine-tuned-RAG/ModelFinetune.ipynb @@ -807,11 +807,18 @@ ] }, { - "cell_type": "code", - "execution_count": null, + "cell_type": "markdown", "metadata": {}, - "outputs": [], - "source": [] + "source": [ + "# Few Shot Learning with Qdrant to Improve RAG\n", + "\n", + "So far, we've been using the OpenAI model to answer questions where the answer is present in the context. But what if we want to answer questions where the answer is not present in the context? This is where few-shot learning comes in. Few-shot learning is a type of transfer learning that allows us to answer questions where the answer is not present in the context. We can do this by providing a few examples of the answer we're looking for, and the model will learn to answer questions where the answer is not present in the context.\n", + "\n", + "## Finetuning and Inference Changes\n", + "We will use the same dataset as before, but this time we will only provide a few examples of the answer we're looking for. We will also provide a few examples of the answer we're not looking for. This will allow the model to learn to handle questions where the answer is not present in the context. \n", + "\n", + "We assumed perfect retrieval in the previous section, but we will not assume perfect retrieval here. Instead, we will use a vector search engine to find similar questions and answers, and then use those to finetuning the model. We will use [Qdrant](https://qdrant.tech/), an open-source vector search engine. We will use Qdrant to find similar questions and answers, and then use those to finetuning the model." + ] } ], "metadata": { From d058e3e3eb342c1ab3fdc6eee9bd71afd8d94138 Mon Sep 17 00:00:00 2001 From: NirantK Date: Mon, 4 Sep 2023 21:37:27 +0530 Subject: [PATCH 06/38] Better labels --- examples/fine-tuned-RAG/ModelFinetune.ipynb | 34 ++++++--------------- 1 file changed, 10 insertions(+), 24 deletions(-) diff --git a/examples/fine-tuned-RAG/ModelFinetune.ipynb b/examples/fine-tuned-RAG/ModelFinetune.ipynb index 7b551e9712..455e6b2c9e 100644 --- a/examples/fine-tuned-RAG/ModelFinetune.ipynb +++ b/examples/fine-tuned-RAG/ModelFinetune.ipynb @@ -293,25 +293,9 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Expected and Right 42.30%\n", - "Expected but IDK 0.00%\n", - "Expected but Wrong 8.00%\n", - "Hallucination 49.70%\n", - "Did not Expect and IDK 0.00%\n", - "Name: count, dtype: object" - ] - }, - "execution_count": 37, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "class ConfusionMatrixEvaluator:\n", " def __init__(self, df, answers_column=\"generated_answer\"):\n", @@ -727,7 +711,7 @@ }, { "cell_type": "code", - "execution_count": 36, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -745,12 +729,12 @@ }, { "cell_type": "code", - "execution_count": 46, + "execution_count": 8, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -793,8 +777,8 @@ " rects1 = ax.bar(x - width/2, matrix1_values, width, label=label1)\n", " rects2 = ax.bar(x + width/2, matrix2_values, width, label=label2)\n", " \n", - " ax.set_ylabel('Percentage (%)')\n", - " ax.set_title('Overall Error Comparison between {} and {}'.format(label1, label2))\n", + " ax.set_ylabel('Error (%) - Lower is Better')\n", + " ax.set_title('Comparison between {} and {}'.format(label1, label2))\n", " ax.set_xticks(x)\n", " ax.set_xticklabels(labels)\n", " ax.legend()\n", @@ -802,8 +786,10 @@ " fig.tight_layout()\n", " plt.show()\n", "\n", + "matrix_plain = evaluate_matrix(df, \"generated_answer\")\n", + "matrix_ft = evaluate_matrix(df, \"ft_generated_answer\")\n", "# Plot only the overall error\n", - "plot_overall_error(matrix_plain, matrix_ft, \"gpt-3.5-turbo-0613\", \"FineTuned gpt-3.5-turbo-0613\")" + "plot_overall_error(matrix_plain, matrix_ft, \"gpt-3.5-turbo-0613\", \"Fine Tuned\")" ] }, { From 645e56c896a53bc055d8f44d61d2904f56d7b260 Mon Sep 17 00:00:00 2001 From: NirantK Date: Tue, 5 Sep 2023 18:59:08 +0530 Subject: [PATCH 07/38] Add Few Shot prompt creation --- examples/fine-tuned-RAG/ModelFinetune.ipynb | 646 ++++++++++++++++++-- 1 file changed, 587 insertions(+), 59 deletions(-) diff --git a/examples/fine-tuned-RAG/ModelFinetune.ipynb b/examples/fine-tuned-RAG/ModelFinetune.ipynb index 455e6b2c9e..be7032f1fa 100644 --- a/examples/fine-tuned-RAG/ModelFinetune.ipynb +++ b/examples/fine-tuned-RAG/ModelFinetune.ipynb @@ -55,12 +55,9 @@ "\n", "import pandas as pd\n", "import openai\n", - "from sklearn.metrics import confusion_matrix\n", - "from tenacity import retry, stop_after_attempt, wait_exponential\n", + "from tenacity import retry, wait_exponential\n", "from tqdm import tqdm\n", - "import tiktoken\n", "import numpy as np\n", - "from collections import defaultdict\n", "\n", "tqdm.pandas()\n", "openai.api_key = os.getenv(\"OPENAI_API_KEY\")" @@ -222,13 +219,17 @@ "# Function to get prompt messages\n", "def get_prompt(row):\n", " return [\n", - " {'role': 'system', 'content': 'You are a helpful assistant.'},\n", - " {'role': 'user', 'content': f\"\"\"Answer the following Question based on the Context only. Only answer from the Context. If you don't know the answer, say 'I don't know'.\n", + " {\"role\": \"system\", \"content\": \"You are a helpful assistant.\"},\n", + " {\n", + " \"role\": \"user\",\n", + " \"content\": f\"\"\"Answer the following Question based on the Context only. Only answer from the Context. If you don't know the answer, say 'I don't know'.\n", " Question: {row.question}\\n\\n\n", " Context: {row.context}\\n\\n\n", - " Answer:\\n\"\"\"},\n", + " Answer:\\n\"\"\",\n", + " },\n", " ]\n", "\n", + "\n", "# Function with tenacity for retries\n", "@retry(wait=wait_exponential(multiplier=1, min=2, max=6))\n", "def api_call(messages, model):\n", @@ -240,11 +241,12 @@ " temperature=0.0,\n", " )\n", "\n", + "\n", "# Main function to answer question\n", "def answer_question(row, model=\"gpt-3.5-turbo-0613\"):\n", " messages = get_prompt(row)\n", " response = api_call(messages, model)\n", - " return response['choices'][0]['message']['content']\n" + " return response[\"choices\"][0][\"message\"][\"content\"]" ] }, { @@ -302,29 +304,36 @@ " self.df = df\n", " self.y_pred = []\n", " self.labels = [\n", - " 'Expected and Right', 'Expected but IDK', \n", - " 'Expected but Wrong', 'Hallucination', \n", - " 'Did not Expect and IDK'\n", + " \"Expected and Right\",\n", + " \"Expected but IDK\",\n", + " \"Expected but Wrong\",\n", + " \"Hallucination\",\n", + " \"Did not Expect and IDK\",\n", " ]\n", " self.answers_column = answers_column\n", - " \n", + "\n", " def _evaluate_single_row(self, row):\n", - " is_impossible = row['is_impossible']\n", + " is_impossible = row[\"is_impossible\"]\n", " generated_answer = row[self.answers_column].lower()\n", - " actual_answers = [ans.lower() for ans in row['answers']]\n", - " \n", + " actual_answers = [ans.lower() for ans in row[\"answers\"]]\n", + "\n", " y_pred = (\n", - " 'Expected and Right' if not is_impossible and any(ans in generated_answer for ans in actual_answers) else\n", - " 'Expected but IDK' if not is_impossible and generated_answer == \"i don't know\" else\n", - " 'Expected but Wrong' if not is_impossible and generated_answer not in actual_answers else\n", - " 'Hallucination' if is_impossible and generated_answer != \"i don't know\" else\n", - " 'Did not Expect and IDK'\n", + " \"Expected and Right\"\n", + " if not is_impossible\n", + " and any(ans in generated_answer for ans in actual_answers)\n", + " else \"Expected but IDK\"\n", + " if not is_impossible and generated_answer == \"i don't know\"\n", + " else \"Expected but Wrong\"\n", + " if not is_impossible and generated_answer not in actual_answers\n", + " else \"Hallucination\"\n", + " if is_impossible and generated_answer != \"i don't know\"\n", + " else \"Did not Expect and IDK\"\n", " )\n", " return y_pred\n", - " \n", + "\n", " def evaluate_answers(self):\n", " self.y_pred = self.df.apply(self._evaluate_single_row, axis=1)\n", - " \n", + "\n", " def generate_matrices(self, use_percentages=False):\n", " # Using value_counts to create a Series of frequencies, then reindexing to include missing labels with count 0\n", " freq_series = self.y_pred.value_counts().reindex(self.labels, fill_value=0)\n", @@ -333,6 +342,7 @@ " freq_series = (freq_series / total * 100).apply(\"{0:.2f}%\".format)\n", " return freq_series\n", "\n", + "\n", "evaluator = ConfusionMatrixEvaluator(df, answers_column=\"generated_answer\")\n", "evaluator.evaluate_answers()\n", "error_categories = evaluator.generate_matrices(use_percentages=True)\n", @@ -365,20 +375,24 @@ "source": [ "def dataframe_to_jsonl(df):\n", " def create_jsonl_entry(row):\n", - " answer = row['answers'][0] if row['answers'] else \"I don't know\"\n", + " answer = row[\"answers\"][0] if row[\"answers\"] else \"I don't know\"\n", " messages = [\n", - " {'role': 'system', 'content': 'You are a helpful assistant.'},\n", - " {'role': 'user', 'content': f\"\"\"Answer the following Question based on the Context only. Only answer from the Context. If you don't know the answer, say 'I don't know'.\n", + " {\"role\": \"system\", \"content\": \"You are a helpful assistant.\"},\n", + " {\n", + " \"role\": \"user\",\n", + " \"content\": f\"\"\"Answer the following Question based on the Context only. Only answer from the Context. If you don't know the answer, say 'I don't know'.\n", " Question: {row.question}\\n\\n\n", " Context: {row.context}\\n\\n\n", - " Answer:\\n\"\"\"},\n", - " {'role': 'assistant', 'content': answer}\n", + " Answer:\\n\"\"\",\n", + " },\n", + " {\"role\": \"assistant\", \"content\": answer},\n", " ]\n", - " return json.dumps({'messages': messages})\n", + " return json.dumps({\"messages\": messages})\n", "\n", " jsonl_output = df.progress_apply(create_jsonl_entry, axis=1)\n", " return \"\\n\".join(jsonl_output)\n", "\n", + "\n", "with open(\"squad-stratified-1000-ft-v2.json\", \"w\") as f:\n", " f.write(dataframe_to_jsonl(df))" ] @@ -575,13 +589,12 @@ ], "source": [ "file_object = openai.File.create(\n", - " file=open(\"squad-stratified-100-ft-v1.json\", \"r\"),\n", - " purpose='fine-tune',\n", - "\n", + " file=open(\"squad-stratified-100-ft-v1.json\", \"r\"),\n", + " purpose=\"fine-tune\",\n", ")\n", "\n", - "while file_object['status'] != 'processed':\n", - " file_object = openai.File.retrieve(file_object['id'])\n", + "while file_object[\"status\"] != \"processed\":\n", + " file_object = openai.File.retrieve(file_object[\"id\"])\n", " time.sleep(5)" ] }, @@ -599,8 +612,10 @@ "metadata": {}, "outputs": [], "source": [ - "ft_job = openai.FineTuningJob.create(training_file=file_object['id'], model=\"gpt-3.5-turbo\", suffix=\"v1\")\n", - "while openai.FineTuningJob.retrieve(ft_job[\"id\"]).fine_tuned_model == None:\n", + "ft_job = openai.FineTuningJob.create(\n", + " training_file=file_object[\"id\"], model=\"gpt-3.5-turbo\", suffix=\"v1\"\n", + ")\n", + "while openai.FineTuningJob.retrieve(ft_job[\"id\"]).fine_tuned_model is None:\n", " time.sleep(10)" ] }, @@ -639,13 +654,16 @@ ], "source": [ "completion = openai.ChatCompletion.create(\n", - " model=model_id,\n", - " messages=[\n", - " {\"role\": \"system\", \"content\": \"You are a helpful assistant.\"},\n", - " {\"role\": \"user\", \"content\": \"Hello!\"},\n", - " {\"role\": \"assistant\", \"content\": \"Hi, how can I help you today?\"},\n", - " {\"role\": \"user\", \"content\": \"Can you answer the following question based on the given context? If not, say, I don't know:\\n\\nQuestion: What is the capital of France?\\n\\nContext: The capital of Mars is Gaia. Answer:\"},\n", - " ]\n", + " model=model_id,\n", + " messages=[\n", + " {\"role\": \"system\", \"content\": \"You are a helpful assistant.\"},\n", + " {\"role\": \"user\", \"content\": \"Hello!\"},\n", + " {\"role\": \"assistant\", \"content\": \"Hi, how can I help you today?\"},\n", + " {\n", + " \"role\": \"user\",\n", + " \"content\": \"Can you answer the following question based on the given context? If not, say, I don't know:\\n\\nQuestion: What is the capital of France?\\n\\nContext: The capital of Mars is Gaia. Answer:\",\n", + " },\n", + " ],\n", ")\n", "\n", "print(completion.choices[0].message)" @@ -701,11 +719,15 @@ ], "source": [ "# Initialize the evaluator\n", - "finetuned_model_evaluator = ConfusionMatrixEvaluator(df, answers_column=\"ft_generated_answer\")\n", + "finetuned_model_evaluator = ConfusionMatrixEvaluator(\n", + " df, answers_column=\"ft_generated_answer\"\n", + ")\n", "\n", "# Run the evaluation\n", "finetuned_model_evaluator.evaluate_answers()\n", - "finetuned_model_error_categories = finetuned_model_evaluator.generate_matrices(use_percentages=True)\n", + "finetuned_model_error_categories = finetuned_model_evaluator.generate_matrices(\n", + " use_percentages=True\n", + ")\n", "finetuned_model_error_categories" ] }, @@ -716,7 +738,7 @@ "outputs": [], "source": [ "# Optionally, save the results to a JSON file\n", - "# df.to_json(\"1K_with_ft_generated_answers.json\", lines=True, orient=\"records\") " + "# df.to_json(\"1K_with_ft_generated_answers.json\", lines=True, orient=\"records\")" ] }, { @@ -748,6 +770,7 @@ "import matplotlib.pyplot as plt\n", "import numpy as np\n", "\n", + "\n", "def evaluate_matrix(df, answers_column):\n", " \"\"\"\n", " Evaluate the confusion matrix for a given DataFrame and answer column.\n", @@ -757,35 +780,41 @@ " matrix = evaluator.generate_matrices(use_percentages=True)\n", " return matrix\n", "\n", + "\n", "def plot_overall_error(matrix1, matrix2, label1, label2):\n", " \"\"\"\n", " Plot a bar chart showing only the overall error between two confusion matrices.\n", " \"\"\"\n", " # Calculate overall error\n", - " error_categories = ['Expected but Wrong', 'Hallucination']\n", - " matrix1_error = sum([float(matrix1.loc[cat].replace('%', '')) for cat in error_categories])\n", - " matrix2_error = sum([float(matrix2.loc[cat].replace('%', '')) for cat in error_categories])\n", - " \n", - " labels = ['Overall Error']\n", + " error_categories = [\"Expected but Wrong\", \"Hallucination\"]\n", + " matrix1_error = sum(\n", + " [float(matrix1.loc[cat].replace(\"%\", \"\")) for cat in error_categories]\n", + " )\n", + " matrix2_error = sum(\n", + " [float(matrix2.loc[cat].replace(\"%\", \"\")) for cat in error_categories]\n", + " )\n", + "\n", + " labels = [\"Overall Error\"]\n", " matrix1_values = [matrix1_error]\n", " matrix2_values = [matrix2_error]\n", - " \n", + "\n", " x = np.arange(len(labels))\n", " width = 0.35\n", - " \n", + "\n", " fig, ax = plt.subplots()\n", - " rects1 = ax.bar(x - width/2, matrix1_values, width, label=label1)\n", - " rects2 = ax.bar(x + width/2, matrix2_values, width, label=label2)\n", - " \n", - " ax.set_ylabel('Error (%) - Lower is Better')\n", - " ax.set_title('Comparison between {} and {}'.format(label1, label2))\n", + " ax.bar(x - width / 2, matrix1_values, width, label=label1)\n", + " ax.bar(x + width / 2, matrix2_values, width, label=label2)\n", + "\n", + " ax.set_ylabel(\"Error (%) - Lower is Better\")\n", + " ax.set_title(\"Comparison between {} and {}\".format(label1, label2))\n", " ax.set_xticks(x)\n", " ax.set_xticklabels(labels)\n", " ax.legend()\n", - " \n", + "\n", " fig.tight_layout()\n", " plt.show()\n", "\n", + "\n", "matrix_plain = evaluate_matrix(df, \"generated_answer\")\n", "matrix_ft = evaluate_matrix(df, \"ft_generated_answer\")\n", "# Plot only the overall error\n", @@ -793,12 +822,511 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "# Few Shot Learning with Qdrant to Improve RAG\n", "\n", - "So far, we've been using the OpenAI model to answer questions where the answer is present in the context. But what if we want to answer questions where the answer is not present in the context? This is where few-shot learning comes in. Few-shot learning is a type of transfer learning that allows us to answer questions where the answer is not present in the context. We can do this by providing a few examples of the answer we're looking for, and the model will learn to answer questions where the answer is not present in the context.\n", + "So far, we've been using the OpenAI model to answer questions where the answer is present in the context. But what if we want to answer questions where the answer is not present in the context? This is where few-shot learning comes in. Few-shot learning is a type of transfer learning that allows us to answer questions where the answer is not present in the context. We can do this by providing a few examples of the answer we're looking for, and the model will learn to answer questions where the answer is not present in the context." + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Few Shot Prompting\n", + "\n", + "We'll select a few examples from the dataset, including cases where the answer is not present in the context. We'll then use these examples to create a prompt that we can use to fine-tune the model.\n", + "\n", + "We'll measure the baseline on our previous 1K dataset, and then we'll fine-tune the model on the new dataset. We'll then measure the performance of the fine-tuned model on the same 1K dataset.\n", + "\n", + "### Get the Training Data" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "# !wget https://rajpurkar.github.io/SQuAD-explorer/dataset/train-v2.0.json -O train.json" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
titlequestioncontextis_impossibleanswers
0BeyoncéWhen did Beyonce start becoming popular?Beyoncé Giselle Knowles-Carter (/biːˈjɒnseɪ/ b...False[in the late 1990s]
1BeyoncéWhat areas did Beyonce compete in when she was...Beyoncé Giselle Knowles-Carter (/biːˈjɒnseɪ/ b...False[singing and dancing]
2BeyoncéWhen did Beyonce leave Destiny's Child and bec...Beyoncé Giselle Knowles-Carter (/biːˈjɒnseɪ/ b...False[2003]
3BeyoncéIn what city and state did Beyonce grow up?Beyoncé Giselle Knowles-Carter (/biːˈjɒnseɪ/ b...False[Houston, Texas]
4BeyoncéIn which decade did Beyonce become famous?Beyoncé Giselle Knowles-Carter (/biːˈjɒnseɪ/ b...False[late 1990s]
\n", + "
" + ], + "text/plain": [ + " title question \\\n", + "0 Beyoncé When did Beyonce start becoming popular? \n", + "1 Beyoncé What areas did Beyonce compete in when she was... \n", + "2 Beyoncé When did Beyonce leave Destiny's Child and bec... \n", + "3 Beyoncé In what city and state did Beyonce grow up? \n", + "4 Beyoncé In which decade did Beyonce become famous? \n", + "\n", + " context is_impossible \\\n", + "0 Beyoncé Giselle Knowles-Carter (/biːˈjɒnseɪ/ b... False \n", + "1 Beyoncé Giselle Knowles-Carter (/biːˈjɒnseɪ/ b... False \n", + "2 Beyoncé Giselle Knowles-Carter (/biːˈjɒnseɪ/ b... False \n", + "3 Beyoncé Giselle Knowles-Carter (/biːˈjɒnseɪ/ b... False \n", + "4 Beyoncé Giselle Knowles-Carter (/biːˈjɒnseɪ/ b... False \n", + "\n", + " answers \n", + "0 [in the late 1990s] \n", + "1 [singing and dancing] \n", + "2 [2003] \n", + "3 [Houston, Texas] \n", + "4 [late 1990s] " + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import pandas as pd\n", + "import json\n", + "\n", + "\n", + "def json_to_dataframe_with_titles(json_data):\n", + " qas = []\n", + " context = []\n", + " is_impossible = []\n", + " answers = []\n", + " titles = []\n", + "\n", + " for article in json_data[\"data\"]:\n", + " title = article[\"title\"]\n", + " for paragraph in article[\"paragraphs\"]:\n", + " for qa in paragraph[\"qas\"]:\n", + " qas.append(qa[\"question\"].strip())\n", + " context.append(paragraph[\"context\"])\n", + " is_impossible.append(qa[\"is_impossible\"])\n", + "\n", + " ans_list = []\n", + " for ans in qa[\"answers\"]:\n", + " ans_list.append(ans[\"text\"])\n", + " answers.append(ans_list)\n", + " titles.append(title)\n", + "\n", + " df = pd.DataFrame(\n", + " {\n", + " \"title\": titles,\n", + " \"question\": qas,\n", + " \"context\": context,\n", + " \"is_impossible\": is_impossible,\n", + " \"answers\": answers,\n", + " }\n", + " )\n", + " return df\n", + "\n", + "\n", + "train_df = json_to_dataframe_with_titles(json.load(open(\"train.json\", \"r\")))\n", + "train_df.head()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Embed the Training Data" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "from qdrant_client import QdrantClient\n", + "from qdrant_client.http import models\n", + "from qdrant_client.http.models import PointStruct\n", + "from qdrant_client.http.models import Distance, VectorParams" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "qdrant_client = QdrantClient(\n", + " url=os.getenv(\"QDRANT_URL\"), api_key=os.getenv(\"QDRANT_API_KEY\")\n", + ")\n", + "\n", + "collection_name = \"cookbook\" # An arbitrary name for the collection\n", + "\n", + "\n", + "# Create the collection\n", + "qdrant_client.recreate_collection(\n", + " collection_name=collection_name,\n", + " vectors_config=VectorParams(size=384, distance=Distance.COSINE),\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Requirement already satisfied: fastembed in /opt/homebrew/Caskroom/miniconda/base/envs/fst/lib/python3.9/site-packages (0.0.4)\n", + "Requirement already satisfied: onnxruntime<2.0.0,>=1.15.1 in /opt/homebrew/Caskroom/miniconda/base/envs/fst/lib/python3.9/site-packages (from fastembed) (1.15.1)\n", + "Requirement already satisfied: onnxruntime-silicon<2.0.0,>=1.15.0 in /opt/homebrew/Caskroom/miniconda/base/envs/fst/lib/python3.9/site-packages (from fastembed) (1.15.0)\n", + "Requirement already satisfied: requests<3.0.0,>=2.31.0 in /opt/homebrew/Caskroom/miniconda/base/envs/fst/lib/python3.9/site-packages (from fastembed) (2.31.0)\n", + "Requirement already satisfied: tokenizers<0.14.0,>=0.13.3 in /opt/homebrew/Caskroom/miniconda/base/envs/fst/lib/python3.9/site-packages (from fastembed) (0.13.3)\n", + "Requirement already satisfied: tqdm<5.0.0,>=4.65.0 in /opt/homebrew/Caskroom/miniconda/base/envs/fst/lib/python3.9/site-packages (from fastembed) (4.65.0)\n", + "Requirement already satisfied: coloredlogs in /opt/homebrew/Caskroom/miniconda/base/envs/fst/lib/python3.9/site-packages (from onnxruntime<2.0.0,>=1.15.1->fastembed) (15.0.1)\n", + "Requirement already satisfied: flatbuffers in /opt/homebrew/Caskroom/miniconda/base/envs/fst/lib/python3.9/site-packages (from onnxruntime<2.0.0,>=1.15.1->fastembed) (23.5.26)\n", + "Requirement already satisfied: numpy>=1.21.6 in /opt/homebrew/Caskroom/miniconda/base/envs/fst/lib/python3.9/site-packages (from onnxruntime<2.0.0,>=1.15.1->fastembed) (1.24.4)\n", + "Requirement already satisfied: packaging in /opt/homebrew/Caskroom/miniconda/base/envs/fst/lib/python3.9/site-packages (from onnxruntime<2.0.0,>=1.15.1->fastembed) (23.1)\n", + "Requirement already satisfied: protobuf in /opt/homebrew/Caskroom/miniconda/base/envs/fst/lib/python3.9/site-packages (from onnxruntime<2.0.0,>=1.15.1->fastembed) (4.23.4)\n", + "Requirement already satisfied: sympy in /opt/homebrew/Caskroom/miniconda/base/envs/fst/lib/python3.9/site-packages (from onnxruntime<2.0.0,>=1.15.1->fastembed) (1.12)\n", + "Requirement already satisfied: charset-normalizer<4,>=2 in /opt/homebrew/Caskroom/miniconda/base/envs/fst/lib/python3.9/site-packages (from requests<3.0.0,>=2.31.0->fastembed) (3.2.0)\n", + "Requirement already satisfied: idna<4,>=2.5 in /opt/homebrew/Caskroom/miniconda/base/envs/fst/lib/python3.9/site-packages (from requests<3.0.0,>=2.31.0->fastembed) (3.4)\n", + "Requirement already satisfied: urllib3<3,>=1.21.1 in /opt/homebrew/Caskroom/miniconda/base/envs/fst/lib/python3.9/site-packages (from requests<3.0.0,>=2.31.0->fastembed) (1.26.16)\n", + "Requirement already satisfied: certifi>=2017.4.17 in /opt/homebrew/Caskroom/miniconda/base/envs/fst/lib/python3.9/site-packages (from requests<3.0.0,>=2.31.0->fastembed) (2023.5.7)\n", + "Requirement already satisfied: humanfriendly>=9.1 in /opt/homebrew/Caskroom/miniconda/base/envs/fst/lib/python3.9/site-packages (from coloredlogs->onnxruntime<2.0.0,>=1.15.1->fastembed) (10.0)\n", + "Requirement already satisfied: mpmath>=0.19 in /opt/homebrew/Caskroom/miniconda/base/envs/fst/lib/python3.9/site-packages (from sympy->onnxruntime<2.0.0,>=1.15.1->fastembed) (1.3.0)\n" + ] + } + ], + "source": [ + "# !pip install fastembed" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "from fastembed.embedding import DefaultEmbedding\n", + "from typing import List\n", + "import numpy as np\n", + "import pandas as pd\n", + "from tqdm.notebook import tqdm\n", + "\n", + "tqdm.pandas()\n", + "\n", + "embedding_model = DefaultEmbedding()" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "b626be2da7bb4b659b37ab54f094d0f1", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Generating embeddings: 0%| | 0/1000 [00:00 List[PointStruct]:\n", + " questions = df[\"question\"].tolist()\n", + " pbar = tqdm(total=len(questions), desc=\"Generating embeddings\")\n", + "\n", + " # Generate embeddings for each question and update tqdm progress bar\n", + " embeddings = []\n", + " for question in questions:\n", + " embedding = list(embedding_model.embed([question]))[0]\n", + " embeddings.append(embedding)\n", + " pbar.update(1)\n", + " pbar.close()\n", + "\n", + " # Convert embeddings to list of lists\n", + " embeddings_list = [embedding.tolist() for embedding in embeddings]\n", + "\n", + " # Create a temporary DataFrame to hold the embeddings and existing DataFrame columns\n", + " temp_df = df.copy()\n", + " temp_df[\"embeddings\"] = embeddings_list\n", + " temp_df[\"id\"] = temp_df.index\n", + "\n", + " # Generate PointStruct objects using DataFrame apply method\n", + " points = temp_df.progress_apply(\n", + " lambda row: PointStruct(\n", + " id=row[\"id\"],\n", + " vector=row[\"embeddings\"],\n", + " payload={\n", + " \"question\": row[\"question\"],\n", + " \"title\": row[\"title\"],\n", + " \"context\": row[\"context\"],\n", + " \"is_impossible\": row[\"is_impossible\"],\n", + " \"answers\": row[\"answers\"],\n", + " },\n", + " ),\n", + " axis=1,\n", + " ).tolist()\n", + "\n", + " return points\n", + "\n", + "\n", + "small_df = train_df.sample(1000, random_state=37)\n", + "points = generate_points_from_dataframe(small_df)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "operation_id=0 status=\n" + ] + } + ], + "source": [ + "operation_info = qdrant_client.upsert(\n", + " collection_name=collection_name, wait=True, points=points\n", + ")\n", + "print(operation_info)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "df = pd.read_json(\"1K_with_ft_generated_answers.json\", lines=True, orient=\"records\")" + ] + }, + { + "cell_type": "code", + "execution_count": 71, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "70cad3cd68264543a5b90e0a4142f006", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/1000 [00:00 0 else \"I don't know\"\n", + " return [\n", + " {\n", + " \"role\": \"user\", \n", + " \"content\": f\"\"\"Question: {question}\\n\\nContext: {context}\\n\\nAnswer:\"\"\"\n", + " },\n", + " {\"role\": \"assistant\", \"content\": answer},\n", + " ]\n", + "\n", + " rag_prompt = []\n", + " if len(q1) >= 1:\n", + " rag_prompt += q_to_prompt(q1[0])\n", + " # If the next best question is not the same as the question, add it to the prompt\n", + " if len(q2) >= 1 and (q2[0].payload[\"question\"] != q1[0].payload[\"question\"]):\n", + " rag_prompt += q_to_prompt(q2[0])\n", + "\n", + " rag_prompt += [\n", + " {\n", + " \"role\": \"user\",\n", + " \"content\": f\"\"\"Question: {query}\\n\\nContext: {row_context}\\n\\nAnswer:\"\"\"\n", + " },\n", + " ]\n", + "\n", + " rag_prompt = [{\"role\": \"system\", \"content\": instruction}] + rag_prompt\n", + " return rag_prompt\n", + "\n", + "df[\"few_shot_prompt_1K\"] = df.progress_apply(get_few_shot_prompt, axis=1)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", "\n", "## Finetuning and Inference Changes\n", "We will use the same dataset as before, but this time we will only provide a few examples of the answer we're looking for. We will also provide a few examples of the answer we're not looking for. This will allow the model to learn to handle questions where the answer is not present in the context. \n", From 147d7700a7c47039a3e15a66425a2c709cd2b664 Mon Sep 17 00:00:00 2001 From: NirantK Date: Wed, 6 Sep 2023 21:18:20 +0530 Subject: [PATCH 08/38] * chore(DatasetPrep.ipynb): remove DatasetPrep.ipynb file --- examples/fine-tuned-RAG/DatasetPrep.ipynb | 213 ---------------------- 1 file changed, 213 deletions(-) delete mode 100644 examples/fine-tuned-RAG/DatasetPrep.ipynb diff --git a/examples/fine-tuned-RAG/DatasetPrep.ipynb b/examples/fine-tuned-RAG/DatasetPrep.ipynb deleted file mode 100644 index d24a14f572..0000000000 --- a/examples/fine-tuned-RAG/DatasetPrep.ipynb +++ /dev/null @@ -1,213 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Validation" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "--2023-09-04 16:34:26-- https://rajpurkar.github.io/SQuAD-explorer/dataset/dev-v2.0.json\n", - "Resolving rajpurkar.github.io (rajpurkar.github.io)... 185.199.108.153, 185.199.109.153, 185.199.110.153, ...\n", - "Connecting to rajpurkar.github.io (rajpurkar.github.io)|185.199.108.153|:443... connected.\n", - "HTTP request sent, awaiting response... 200 OK\n", - "Length: 4370528 (4.2M) [application/json]\n", - "Saving to: ‘validation.json’\n", - "\n", - "validation.json 100%[===================>] 4.17M 5.66MB/s in 0.7s \n", - "\n", - "2023-09-04 16:34:28 (5.66 MB/s) - ‘validation.json’ saved [4370528/4370528]\n", - "\n" - ] - } - ], - "source": [ - "!wget https://rajpurkar.github.io/SQuAD-explorer/dataset/dev-v2.0.json -O validation.json" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "# !pip install pandas qdrant-client openai --quiet" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "metadata": {}, - "outputs": [], - "source": [ - "import pandas as pd\n", - "import json\n", - "\n", - "def json_to_dataframe_with_titles(json_data):\n", - " qas = []\n", - " context = []\n", - " is_impossible = []\n", - " answers = []\n", - " titles = []\n", - "\n", - " for article in json_data['data']:\n", - " title = article['title']\n", - " for paragraph in article['paragraphs']:\n", - " for qa in paragraph['qas']:\n", - " qas.append(qa['question'].strip())\n", - " context.append(paragraph['context'])\n", - " is_impossible.append(qa['is_impossible'])\n", - " \n", - " ans_list = []\n", - " for ans in qa['answers']:\n", - " ans_list.append(ans['text'])\n", - " answers.append(ans_list)\n", - " titles.append(title)\n", - "\n", - " df = pd.DataFrame({'title': titles, 'question': qas, 'context': context, 'is_impossible': is_impossible, 'answers': answers})\n", - " return df\n", - "\n", - "def get_diverse_sample(df, sample_size=100, random_state=42):\n", - " sample_df = df.groupby(['title', 'is_impossible']).apply(lambda x: x.sample(min(len(x), max(1, sample_size // 50)), random_state=random_state)).reset_index(drop=True)\n", - " \n", - " if len(sample_df) < sample_size:\n", - " remaining_sample_size = sample_size - len(sample_df)\n", - " remaining_df = df.drop(sample_df.index).sample(remaining_sample_size, random_state=random_state)\n", - " sample_df = pd.concat([sample_df, remaining_df]).sample(frac=1, random_state=random_state).reset_index(drop=True)\n", - "\n", - " return sample_df.sample(min(sample_size, len(sample_df)), random_state=random_state).reset_index(drop=True)\n", - "\n", - "validation = json.load(open('validation.json', 'r'))\n", - "validation_df = json_to_dataframe_with_titles(validation)\n", - "df = get_diverse_sample(validation_df, sample_size=1000, random_state=37)" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "is_impossible\n", - "False 53\n", - "True 47\n", - "Name: count, dtype: int64" - ] - }, - "execution_count": 17, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "df.value_counts('is_impossible')" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "title\n", - "Southern_California 33\n", - "Geology 33\n", - "Jacksonville,_Florida 32\n", - "University_of_Chicago 32\n", - "Imperialism 31\n", - "1973_oil_crisis 31\n", - "Fresno,_California 31\n", - "Harvard_University 31\n", - "Scottish_Parliament 31\n", - "Sky_(United_Kingdom) 31\n", - "Normans 30\n", - "Packet_switching 30\n", - "Ctenophora 30\n", - "Rhine 30\n", - "Pharmacy 30\n", - "Intergovernmental_Panel_on_Climate_Change 30\n", - "Warsaw 29\n", - "Steam_engine 29\n", - "Victoria_(Australia) 29\n", - "Computational_complexity_theory 29\n", - "Amazon_rainforest 29\n", - "Civil_disobedience 29\n", - "European_Union_law 29\n", - "Huguenot 28\n", - "Construction 28\n", - "Private_school 28\n", - "Black_Death 26\n", - "Yuan_dynasty 26\n", - "Islamism 25\n", - "Oxygen 24\n", - "Prime_number 24\n", - "Immune_system 24\n", - "Force 23\n", - "Economic_inequality 23\n", - "French_and_Indian_War 22\n", - "Name: count, dtype: int64" - ] - }, - "execution_count": 22, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "df.title.value_counts()" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "metadata": {}, - "outputs": [], - "source": [ - "# write to csv\n", - "df.to_json('v2_1K_Seed=37_sample.json', orient='records', lines=True)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "fst", - "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.9.17" - }, - "orig_nbformat": 4 - }, - "nbformat": 4, - "nbformat_minor": 2 -} From 03d6c6a74a52f52198da5a7a83e7c3c6d8a4dd8d Mon Sep 17 00:00:00 2001 From: NirantK Date: Wed, 6 Sep 2023 21:28:53 +0530 Subject: [PATCH 09/38] Simplify datasets --- examples/fine-tuned-RAG/ModelFinetune.ipynb | 933 +++++++++++--------- 1 file changed, 500 insertions(+), 433 deletions(-) diff --git a/examples/fine-tuned-RAG/ModelFinetune.ipynb b/examples/fine-tuned-RAG/ModelFinetune.ipynb index be7032f1fa..b982bf3934 100644 --- a/examples/fine-tuned-RAG/ModelFinetune.ipynb +++ b/examples/fine-tuned-RAG/ModelFinetune.ipynb @@ -40,12 +40,12 @@ "metadata": {}, "outputs": [], "source": [ - "# !pip install pandas openai tqdm tenacity pandarallel scikit-learn tiktoken" + "# !pip install pandas openai tqdm tenacity pandarallel scikit-learn tiktoken python-dotenv" ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 17, "metadata": {}, "outputs": [], "source": [ @@ -55,148 +55,120 @@ "\n", "import pandas as pd\n", "import openai\n", + "import tiktoken\n", "from tenacity import retry, wait_exponential\n", "from tqdm import tqdm\n", + "from collections import defaultdict\n", "import numpy as np\n", "\n", - "tqdm.pandas()\n", - "openai.api_key = os.getenv(\"OPENAI_API_KEY\")" + "tqdm.pandas()" ] }, { - "attachments": {}, - "cell_type": "markdown", + "cell_type": "code", + "execution_count": 49, "metadata": {}, + "outputs": [], "source": [ - "## Loading the Data\n", - "\n", - "Load your data and take a quick look at the first few rows. Notice that we've included a few samples where the answer is not present in the context." + "openai.api_key = os.environ[\"OPENAI_API_KEY\"]" ] }, { - "cell_type": "code", - "execution_count": 3, + "attachments": {}, + "cell_type": "markdown", "metadata": {}, - "outputs": [], "source": [ - "df = pd.read_json(\"v2_1K_Seed=37_sample.json\", lines=True)" + "## Preparing the Data\n", + "\n", + "For the purpose of demonstration, we'll make small slices from the train and validation splits of the [SQuADv2](https://rajpurkar.github.io/SQuAD-explorer/) dataset. This dataset has questions and contexts where the answer is not present in the context, to help us evaluate how LLM handles this case.\n", + "\n", + "### Download the Data" ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 1, "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", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
titlequestioncontextis_impossibleanswers
0Southern_CaliforniaWhat is the United State's second-busiest comm...Southern California is also home to the Port o...True[]
1Jacksonville,_FloridaWho did Jacksonville support with supplies dur...During the American Civil War, Jacksonville wa...True[]
2Imperialismcolonial rule would not be considered what typ...Imperialism is defined as \"A policy of extendi...True[]
3Intergovernmental_Panel_on_Climate_ChangeWhere are dissenting opinions published?Michael Oppenheimer, a long-time participant i...True[]
4Southern_CaliforniaHow many people does the Greater Los Angeles A...Southern California includes the heavily built...False[17.5 million, over 17.5 million, 17.5 million]
\n", - "
" - ], - "text/plain": [ - " title \\\n", - "0 Southern_California \n", - "1 Jacksonville,_Florida \n", - "2 Imperialism \n", - "3 Intergovernmental_Panel_on_Climate_Change \n", - "4 Southern_California \n", - "\n", - " question \\\n", - "0 What is the United State's second-busiest comm... \n", - "1 Who did Jacksonville support with supplies dur... \n", - "2 colonial rule would not be considered what typ... \n", - "3 Where are dissenting opinions published? \n", - "4 How many people does the Greater Los Angeles A... \n", - "\n", - " context is_impossible \\\n", - "0 Southern California is also home to the Port o... True \n", - "1 During the American Civil War, Jacksonville wa... True \n", - "2 Imperialism is defined as \"A policy of extendi... True \n", - "3 Michael Oppenheimer, a long-time participant i... True \n", - "4 Southern California includes the heavily built... False \n", - "\n", - " answers \n", - "0 [] \n", - "1 [] \n", - "2 [] \n", - "3 [] \n", - "4 [17.5 million, over 17.5 million, 17.5 million] " - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" + "name": "stdout", + "output_type": "stream", + "text": [ + "--2023-09-06 19:39:59-- https://rajpurkar.github.io/SQuAD-explorer/dataset/train-v2.0.json\n", + "Resolving rajpurkar.github.io (rajpurkar.github.io)... 185.199.111.153, 185.199.108.153, 185.199.110.153, ...\n", + "Connecting to rajpurkar.github.io (rajpurkar.github.io)|185.199.111.153|:443... connected.\n", + "HTTP request sent, awaiting response... 200 OK\n", + "Length: 42123633 (40M) [application/json]\n", + "Saving to: ‘local_cache/train.json’\n", + "\n", + "local_cache/train.j 100%[===================>] 40.17M 35.9MB/s in 1.1s \n", + "\n", + "2023-09-06 19:40:03 (35.9 MB/s) - ‘local_cache/train.json’ saved [42123633/42123633]\n", + "\n", + "--2023-09-06 19:40:03-- https://rajpurkar.github.io/SQuAD-explorer/dataset/dev-v2.0.json\n", + "Resolving rajpurkar.github.io (rajpurkar.github.io)... 185.199.108.153, 185.199.111.153, 185.199.110.153, ...\n", + "Connecting to rajpurkar.github.io (rajpurkar.github.io)|185.199.108.153|:443... connected.\n", + "HTTP request sent, awaiting response... 200 OK\n", + "Length: 4370528 (4.2M) [application/json]\n", + "Saving to: ‘local_cache/dev.json’\n", + "\n", + "local_cache/dev.jso 100%[===================>] 4.17M 13.7MB/s in 0.3s \n", + "\n", + "2023-09-06 19:40:04 (13.7 MB/s) - ‘local_cache/dev.json’ saved [4370528/4370528]\n", + "\n" + ] } ], "source": [ - "df.head()" + "!mkdir -p local_cache\n", + "!wget https://rajpurkar.github.io/SQuAD-explorer/dataset/train-v2.0.json -O local_cache/train.json\n", + "!wget https://rajpurkar.github.io/SQuAD-explorer/dataset/dev-v2.0.json -O local_cache/dev.json" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "def json_to_dataframe_with_titles(json_data):\n", + " qas = []\n", + " context = []\n", + " is_impossible = []\n", + " answers = []\n", + " titles = []\n", + "\n", + " for article in json_data['data']:\n", + " title = article['title']\n", + " for paragraph in article['paragraphs']:\n", + " for qa in paragraph['qas']:\n", + " qas.append(qa['question'].strip())\n", + " context.append(paragraph['context'])\n", + " is_impossible.append(qa['is_impossible'])\n", + " \n", + " ans_list = []\n", + " for ans in qa['answers']:\n", + " ans_list.append(ans['text'])\n", + " answers.append(ans_list)\n", + " titles.append(title)\n", + "\n", + " df = pd.DataFrame({'title': titles, 'question': qas, 'context': context, 'is_impossible': is_impossible, 'answers': answers})\n", + " return df\n", + "\n", + "def get_diverse_sample(df, sample_size=100, random_state=42):\n", + " sample_df = df.groupby(['title', 'is_impossible']).apply(lambda x: x.sample(min(len(x), max(1, sample_size // 50)), random_state=random_state)).reset_index(drop=True)\n", + " \n", + " if len(sample_df) < sample_size:\n", + " remaining_sample_size = sample_size - len(sample_df)\n", + " remaining_df = df.drop(sample_df.index).sample(remaining_sample_size, random_state=random_state)\n", + " sample_df = pd.concat([sample_df, remaining_df]).sample(frac=1, random_state=random_state).reset_index(drop=True)\n", + "\n", + " return sample_df.sample(min(sample_size, len(sample_df)), random_state=random_state).reset_index(drop=True)\n", + "\n", + "train_df = json_to_dataframe_with_titles(json.load(open('local_cache/train.json')))\n", + "val_df = json_to_dataframe_with_titles(json.load(open('local_cache/dev.json')))\n", + "\n", + "df = get_diverse_sample(val_df, sample_size=100, random_state=42)" ] }, { @@ -212,7 +184,7 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ @@ -259,9 +231,17 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 100/100 [02:53<00:00, 1.73s/it]\n" + ] + } + ], "source": [ "# Use progress_apply with tqdm for progress bar\n", "df[\"generated_answer\"] = df.progress_apply(answer_question, axis=1)" @@ -269,12 +249,11 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 10, "metadata": {}, "outputs": [], "source": [ - "# Optionally, save the results to a JSON file\n", - "# df.to_json(\"1K_with_generated_answers.json\", lines=True, orient=\"records\") # Save to JSON" + "df.to_json(\"local_cache/100_val.json\", orient=\"records\", lines=True)" ] }, { @@ -295,9 +274,25 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 12, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "Expected and Right 43.00%\n", + "Expected but IDK 0.00%\n", + "Expected but Wrong 10.00%\n", + "Hallucination 47.00%\n", + "Did not Expect and IDK 0.00%\n", + "Name: count, dtype: object" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "class ConfusionMatrixEvaluator:\n", " def __init__(self, df, answers_column=\"generated_answer\"):\n", @@ -356,19 +351,21 @@ "source": [ "## Fine-Tuning\n", "\n", - "### Prepare the Fine-Tuning Data" + "### Prepare the Fine-Tuning Data\n", + "\n", + "We need to prepare the data for fine-tuning. We'll use a few samples from train split of same dataset as before, but we'll add the answer to the context. This will help the model learn to retrieve the answer from the context." ] }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 13, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 1000/1000 [00:00<00:00, 59898.09it/s]\n" + "100%|██████████| 100/100 [00:00<00:00, 65484.84it/s]\n" ] } ], @@ -392,9 +389,10 @@ " jsonl_output = df.progress_apply(create_jsonl_entry, axis=1)\n", " return \"\\n\".join(jsonl_output)\n", "\n", + "train_sample = get_diverse_sample(train_df, sample_size=100, random_state=42)\n", "\n", - "with open(\"squad-stratified-1000-ft-v2.json\", \"w\") as f:\n", - " f.write(dataframe_to_jsonl(df))" + "with open(\"local_cache/100_train.jsonl\", \"w\") as f:\n", + " f.write(dataframe_to_jsonl(train_sample))" ] }, { @@ -409,149 +407,180 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 18, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Num examples: 100\n", + "First example:\n", + "{'role': 'system', 'content': 'You are a helpful assistant.'}\n", + "{'role': 'user', 'content': \"Answer the following Question based on the Context only. Only answer from the Context. If you don't know the answer, say 'I don't know'.\\n Question: What is a cirque?\\n\\n\\n Context: Glaciers form where the accumulation of snow and ice exceeds ablation. The area in which a glacier forms is called a cirque (corrie or cwm) - a typically armchair-shaped geological feature (such as a depression between mountains enclosed by arêtes) - which collects and compresses through gravity the snow which falls into it. This snow collects and is compacted by the weight of the snow falling above it forming névé. Further crushing of the individual snowflakes and squeezing the air from the snow turns it into 'glacial ice'. This glacial ice will fill the cirque until it 'overflows' through a geological weakness or vacancy, such as the gap between two mountains. When the mass of snow and ice is sufficiently thick, it begins to move due to a combination of surface slope, gravity and pressure. On steeper slopes, this can occur with as little as 15 m (50 ft) of snow-ice.\\n\\n\\n Answer:\\n\"}\n", + "{'role': 'assistant', 'content': 'The area in which a glacier forms'}\n", + "No errors found\n", + "Num examples missing system message: 0\n", + "Num examples missing user message: 0\n", + "\n", + "#### Distribution of num_messages_per_example:\n", + "min / max: 3, 3\n", + "mean / median: 3.0, 3.0\n", + "p5 / p95: 3.0, 3.0\n", + "\n", + "#### Distribution of num_total_tokens_per_example:\n", + "min / max: 114, 689\n", + "mean / median: 236.88, 217.0\n", + "p5 / p95: 166.7, 321.3\n", + "\n", + "#### Distribution of num_assistant_tokens_per_example:\n", + "min / max: 1, 13\n", + "mean / median: 3.81, 4.0\n", + "p5 / p95: 1.0, 5.0\n", + "\n", + "0 examples may be over the 4096 token limit, they will be truncated during fine-tuning\n", + "Dataset has ~23688 tokens that will be charged for during training\n", + "By default, you'll train for 3 epochs on this dataset\n", + "By default, you'll be charged for ~71064 tokens\n", + "See pricing page to estimate total costs\n" + ] + } + ], "source": [ - "# # We start by importing the required packages\n", - "\n", - "# import json\n", - "# import os\n", - "\n", - "# # Next, we specify the data path and open the JSONL file\n", - "\n", - "# data_path = \"squad-stratified-100-ft-v1.json\"\n", - "\n", - "# # Load dataset\n", - "# with open(data_path) as f:\n", - "# dataset = [json.loads(line) for line in f]\n", - "\n", - "# # We can inspect the data quickly by checking the number of examples and the first item\n", - "\n", - "# # Initial dataset stats\n", - "# print(\"Num examples:\", len(dataset))\n", - "# print(\"First example:\")\n", - "# for message in dataset[0][\"messages\"]:\n", - "# print(message)\n", - "\n", - "# # Now that we have a sense of the data, we need to go through all the different examples and check to make sure the formatting is correct and matches the Chat completions message structure\n", - "\n", - "# # Format error checks\n", - "# format_errors = defaultdict(int)\n", - "\n", - "# for ex in dataset:\n", - "# if not isinstance(ex, dict):\n", - "# format_errors[\"data_type\"] += 1\n", - "# continue\n", - "\n", - "# messages = ex.get(\"messages\", None)\n", - "# if not messages:\n", - "# format_errors[\"missing_messages_list\"] += 1\n", - "# continue\n", - "\n", - "# for message in messages:\n", - "# if \"role\" not in message or \"content\" not in message:\n", - "# format_errors[\"message_missing_key\"] += 1\n", - "\n", - "# if any(k not in (\"role\", \"content\", \"name\") for k in message):\n", - "# format_errors[\"message_unrecognized_key\"] += 1\n", - "\n", - "# if message.get(\"role\", None) not in (\"system\", \"user\", \"assistant\"):\n", - "# format_errors[\"unrecognized_role\"] += 1\n", - "\n", - "# content = message.get(\"content\", None)\n", - "# if not content or not isinstance(content, str):\n", - "# format_errors[\"missing_content\"] += 1\n", - "\n", - "# if not any(message.get(\"role\", None) == \"assistant\" for message in messages):\n", - "# format_errors[\"example_missing_assistant_message\"] += 1\n", - "\n", - "# if format_errors:\n", - "# print(\"Found errors:\")\n", - "# for k, v in format_errors.items():\n", - "# print(f\"{k}: {v}\")\n", - "# else:\n", - "# print(\"No errors found\")\n", - "\n", - "# # Beyond the structure of the message, we also need to ensure that the length does not exceed the 4096 token limit.\n", - "\n", - "# # Token counting functions\n", - "# encoding = tiktoken.get_encoding(\"cl100k_base\")\n", - "\n", - "# # not exact!\n", - "# # simplified from https://github.com/openai/openai-cookbook/blob/main/examples/How_to_count_tokens_with_tiktoken.ipynb\n", - "# def num_tokens_from_messages(messages, tokens_per_message=3, tokens_per_name=1):\n", - "# num_tokens = 0\n", - "# for message in messages:\n", - "# num_tokens += tokens_per_message\n", - "# for key, value in message.items():\n", - "# num_tokens += len(encoding.encode(value))\n", - "# if key == \"name\":\n", - "# num_tokens += tokens_per_name\n", - "# num_tokens += 3\n", - "# return num_tokens\n", - "\n", - "# def num_assistant_tokens_from_messages(messages):\n", - "# num_tokens = 0\n", - "# for message in messages:\n", - "# if message[\"role\"] == \"assistant\":\n", - "# num_tokens += len(encoding.encode(message[\"content\"]))\n", - "# return num_tokens\n", - "\n", - "# def print_distribution(values, name):\n", - "# print(f\"\\n#### Distribution of {name}:\")\n", - "# print(f\"min / max: {min(values)}, {max(values)}\")\n", - "# print(f\"mean / median: {np.mean(values)}, {np.median(values)}\")\n", - "# print(f\"p5 / p95: {np.quantile(values, 0.1)}, {np.quantile(values, 0.9)}\")\n", - "\n", - "# # Last, we can look at the results of the different formatting operations before proceeding with creating a fine-tuning job:\n", - "\n", - "# # Warnings and tokens counts\n", - "# n_missing_system = 0\n", - "# n_missing_user = 0\n", - "# n_messages = []\n", - "# convo_lens = []\n", - "# assistant_message_lens = []\n", - "\n", - "# for ex in dataset:\n", - "# messages = ex[\"messages\"]\n", - "# if not any(message[\"role\"] == \"system\" for message in messages):\n", - "# n_missing_system += 1\n", - "# if not any(message[\"role\"] == \"user\" for message in messages):\n", - "# n_missing_user += 1\n", - "# n_messages.append(len(messages))\n", - "# convo_lens.append(num_tokens_from_messages(messages))\n", - "# assistant_message_lens.append(num_assistant_tokens_from_messages(messages))\n", - "\n", - "# print(\"Num examples missing system message:\", n_missing_system)\n", - "# print(\"Num examples missing user message:\", n_missing_user)\n", - "# print_distribution(n_messages, \"num_messages_per_example\")\n", - "# print_distribution(convo_lens, \"num_total_tokens_per_example\")\n", - "# print_distribution(assistant_message_lens, \"num_assistant_tokens_per_example\")\n", - "# n_too_long = sum(l > 4096 for l in convo_lens)\n", - "# print(f\"\\n{n_too_long} examples may be over the 4096 token limit, they will be truncated during fine-tuning\")\n", - "\n", - "# # Pricing and default n_epochs estimate\n", - "# MAX_TOKENS_PER_EXAMPLE = 4096\n", - "\n", - "# MIN_TARGET_EXAMPLES = 100\n", - "# MAX_TARGET_EXAMPLES = 25000\n", - "# TARGET_EPOCHS = 3\n", - "# MIN_EPOCHS = 1\n", - "# MAX_EPOCHS = 25\n", - "\n", - "# n_epochs = TARGET_EPOCHS\n", - "# n_train_examples = len(dataset)\n", - "# if n_train_examples * TARGET_EPOCHS < MIN_TARGET_EXAMPLES:\n", - "# n_epochs = min(MAX_EPOCHS, MIN_TARGET_EXAMPLES // n_train_examples)\n", - "# elif n_train_examples * TARGET_EPOCHS > MAX_TARGET_EXAMPLES:\n", - "# n_epochs = max(MIN_EPOCHS, MAX_TARGET_EXAMPLES // n_train_examples)\n", - "\n", - "# n_billing_tokens_in_dataset = sum(min(MAX_TOKENS_PER_EXAMPLE, length) for length in convo_lens)\n", - "# print(f\"Dataset has ~{n_billing_tokens_in_dataset} tokens that will be charged for during training\")\n", - "# print(f\"By default, you'll train for {n_epochs} epochs on this dataset\")\n", - "# print(f\"By default, you'll be charged for ~{n_epochs * n_billing_tokens_in_dataset} tokens\")\n", - "# print(\"See pricing page to estimate total costs\")" + "# Specify the data path and open the JSONL file\n", + "\n", + "data_path = \"local_cache/100_train.jsonl\"\n", + "\n", + "# Load dataset\n", + "with open(data_path) as f:\n", + " dataset = [json.loads(line) for line in f]\n", + "\n", + "# We can inspect the data quickly by checking the number of examples and the first item\n", + "\n", + "# Initial dataset stats\n", + "print(\"Num examples:\", len(dataset))\n", + "print(\"First example:\")\n", + "for message in dataset[0][\"messages\"]:\n", + " print(message)\n", + "\n", + "# Now that we have a sense of the data, we need to go through all the different examples and check to make sure the formatting is correct and matches the Chat completions message structure\n", + "\n", + "# Format error checks\n", + "format_errors = defaultdict(int)\n", + "\n", + "for ex in dataset:\n", + " if not isinstance(ex, dict):\n", + " format_errors[\"data_type\"] += 1\n", + " continue\n", + "\n", + " messages = ex.get(\"messages\", None)\n", + " if not messages:\n", + " format_errors[\"missing_messages_list\"] += 1\n", + " continue\n", + "\n", + " for message in messages:\n", + " if \"role\" not in message or \"content\" not in message:\n", + " format_errors[\"message_missing_key\"] += 1\n", + "\n", + " if any(k not in (\"role\", \"content\", \"name\") for k in message):\n", + " format_errors[\"message_unrecognized_key\"] += 1\n", + "\n", + " if message.get(\"role\", None) not in (\"system\", \"user\", \"assistant\"):\n", + " format_errors[\"unrecognized_role\"] += 1\n", + "\n", + " content = message.get(\"content\", None)\n", + " if not content or not isinstance(content, str):\n", + " format_errors[\"missing_content\"] += 1\n", + "\n", + " if not any(message.get(\"role\", None) == \"assistant\" for message in messages):\n", + " format_errors[\"example_missing_assistant_message\"] += 1\n", + "\n", + "if format_errors:\n", + " print(\"Found errors:\")\n", + " for k, v in format_errors.items():\n", + " print(f\"{k}: {v}\")\n", + "else:\n", + " print(\"No errors found\")\n", + "\n", + "# Beyond the structure of the message, we also need to ensure that the length does not exceed the 4096 token limit.\n", + "\n", + "# Token counting functions\n", + "encoding = tiktoken.get_encoding(\"cl100k_base\")\n", + "\n", + "# not exact!\n", + "# simplified from https://github.com/openai/openai-cookbook/blob/main/examples/How_to_count_tokens_with_tiktoken.ipynb\n", + "def num_tokens_from_messages(messages, tokens_per_message=3, tokens_per_name=1):\n", + " num_tokens = 0\n", + " for message in messages:\n", + " num_tokens += tokens_per_message\n", + " for key, value in message.items():\n", + " num_tokens += len(encoding.encode(value))\n", + " if key == \"name\":\n", + " num_tokens += tokens_per_name\n", + " num_tokens += 3\n", + " return num_tokens\n", + "\n", + "def num_assistant_tokens_from_messages(messages):\n", + " num_tokens = 0\n", + " for message in messages:\n", + " if message[\"role\"] == \"assistant\":\n", + " num_tokens += len(encoding.encode(message[\"content\"]))\n", + " return num_tokens\n", + "\n", + "def print_distribution(values, name):\n", + " print(f\"\\n#### Distribution of {name}:\")\n", + " print(f\"min / max: {min(values)}, {max(values)}\")\n", + " print(f\"mean / median: {np.mean(values)}, {np.median(values)}\")\n", + " print(f\"p5 / p95: {np.quantile(values, 0.1)}, {np.quantile(values, 0.9)}\")\n", + "\n", + "# Last, we can look at the results of the different formatting operations before proceeding with creating a fine-tuning job:\n", + "\n", + "# Warnings and tokens counts\n", + "n_missing_system = 0\n", + "n_missing_user = 0\n", + "n_messages = []\n", + "convo_lens = []\n", + "assistant_message_lens = []\n", + "\n", + "for ex in dataset:\n", + " messages = ex[\"messages\"]\n", + " if not any(message[\"role\"] == \"system\" for message in messages):\n", + " n_missing_system += 1\n", + " if not any(message[\"role\"] == \"user\" for message in messages):\n", + " n_missing_user += 1\n", + " n_messages.append(len(messages))\n", + " convo_lens.append(num_tokens_from_messages(messages))\n", + " assistant_message_lens.append(num_assistant_tokens_from_messages(messages))\n", + "\n", + "print(\"Num examples missing system message:\", n_missing_system)\n", + "print(\"Num examples missing user message:\", n_missing_user)\n", + "print_distribution(n_messages, \"num_messages_per_example\")\n", + "print_distribution(convo_lens, \"num_total_tokens_per_example\")\n", + "print_distribution(assistant_message_lens, \"num_assistant_tokens_per_example\")\n", + "n_too_long = sum(l > 4096 for l in convo_lens)\n", + "print(f\"\\n{n_too_long} examples may be over the 4096 token limit, they will be truncated during fine-tuning\")\n", + "\n", + "# Pricing and default n_epochs estimate\n", + "MAX_TOKENS_PER_EXAMPLE = 4096\n", + "\n", + "MIN_TARGET_EXAMPLES = 100\n", + "MAX_TARGET_EXAMPLES = 25000\n", + "TARGET_EPOCHS = 3\n", + "MIN_EPOCHS = 1\n", + "MAX_EPOCHS = 25\n", + "\n", + "n_epochs = TARGET_EPOCHS\n", + "n_train_examples = len(dataset)\n", + "if n_train_examples * TARGET_EPOCHS < MIN_TARGET_EXAMPLES:\n", + " n_epochs = min(MAX_EPOCHS, MIN_TARGET_EXAMPLES // n_train_examples)\n", + "elif n_train_examples * TARGET_EPOCHS > MAX_TARGET_EXAMPLES:\n", + " n_epochs = max(MIN_EPOCHS, MAX_TARGET_EXAMPLES // n_train_examples)\n", + "\n", + "n_billing_tokens_in_dataset = sum(min(MAX_TOKENS_PER_EXAMPLE, length) for length in convo_lens)\n", + "print(f\"Dataset has ~{n_billing_tokens_in_dataset} tokens that will be charged for during training\")\n", + "print(f\"By default, you'll train for {n_epochs} epochs on this dataset\")\n", + "print(f\"By default, you'll be charged for ~{n_epochs * n_billing_tokens_in_dataset} tokens\")\n", + "print(\"See pricing page to estimate total costs\")" ] }, { @@ -564,38 +593,46 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 50, + "metadata": {}, + "outputs": [], + "source": [ + "file_object = openai.File.create(\n", + " file=open(\"local_cache/100_train.jsonl\", \"r\"),\n", + " purpose=\"fine-tune\",\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 51, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - " JSON: {\n", + " JSON: {\n", " \"object\": \"file\",\n", - " \"id\": \"file-TjkDD0C39b4S1JZstMly98pv\",\n", + " \"id\": \"file-iuSjUY6kK84A1cOB9QffTxfD\",\n", " \"purpose\": \"fine-tune\",\n", " \"filename\": \"file\",\n", - " \"bytes\": 131291,\n", - " \"created_at\": 1693836561,\n", - " \"status\": \"uploaded\",\n", + " \"bytes\": 120415,\n", + " \"created_at\": 1694012894,\n", + " \"status\": \"processed\",\n", " \"status_details\": null\n", "}" ] }, - "execution_count": 16, + "execution_count": 51, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "file_object = openai.File.create(\n", - " file=open(\"squad-stratified-100-ft-v1.json\", \"r\"),\n", - " purpose=\"fine-tune\",\n", - ")\n", - "\n", - "while file_object[\"status\"] != \"processed\":\n", - " file_object = openai.File.retrieve(file_object[\"id\"])\n", - " time.sleep(5)" + "while file_object.status!='processed':\n", + " time.sleep(5)\n", + " file_object.refresh()\n", + "file_object" ] }, { @@ -608,24 +645,105 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 52, "metadata": {}, "outputs": [], "source": [ "ft_job = openai.FineTuningJob.create(\n", - " training_file=file_object[\"id\"], model=\"gpt-3.5-turbo\", suffix=\"v1\"\n", - ")\n", - "while openai.FineTuningJob.retrieve(ft_job[\"id\"]).fine_tuned_model is None:\n", - " time.sleep(10)" + " training_file=file_object[\"id\"], model=\"gpt-3.5-turbo\", suffix=\"100train20230906\"\n", + ")" ] }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 58, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Status: running\n", + "Status: running\n", + "Status: running\n", + "Status: running\n", + "Status: running\n", + "Status: running\n", + "Status: running\n", + "Status: running\n", + "Status: running\n", + "Status: running\n", + "Status: running\n", + "Status: running\n", + "Status: running\n", + "Status: running\n", + "Status: running\n", + "Status: running\n", + "Status: running\n", + "Status: running\n", + "Status: running\n", + "Status: running\n", + "Status: running\n", + "Status: running\n", + "Status: running\n", + "Status: running\n", + "Status: running\n", + "Status: running\n", + "Status: running\n", + "Status: running\n", + "Status: running\n", + "Status: running\n", + "Status: running\n", + "Status: running\n", + "Status: running\n", + "Status: running\n", + "Status: running\n", + "Status: running\n", + "Status: running\n", + "Status: running\n", + "Status: running\n", + "Status: running\n", + "Status: running\n", + "Status: running\n", + "Status: running\n", + "Status: running\n", + "Status: running\n", + "Status: running\n", + "Status: running\n", + "Status: running\n", + "Status: running\n", + "Status: running\n", + "Status: running\n", + "Status: succeeded\n" + ] + } + ], "source": [ - "model_id = openai.FineTuningJob.retrieve(ft_job[\"id\"]).fine_tuned_model" + "while ft_job.status!='succeeded':\n", + " time.sleep(15)\n", + " ft_job.refresh()\n", + " print(\"Status: \", ft_job.status)" + ] + }, + { + "cell_type": "code", + "execution_count": 63, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'ft:gpt-3.5-turbo-0613:qdrant:100train20230906:7vp2AzMY'" + ] + }, + "execution_count": 63, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model_id = openai.FineTuningJob.retrieve(ft_job[\"id\"]).fine_tuned_model\n", + "model_id" ] }, { @@ -638,7 +756,7 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 60, "metadata": {}, "outputs": [ { @@ -681,14 +799,14 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 61, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 1000/1000 [12:14<00:00, 1.36it/s] \n" + "100%|██████████| 100/100 [05:16<00:00, 3.17s/it]\n" ] } ], @@ -698,21 +816,21 @@ }, { "cell_type": "code", - "execution_count": 38, + "execution_count": 62, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "Expected and Right 30.10%\n", - "Expected but IDK 15.20%\n", - "Expected but Wrong 5.00%\n", - "Hallucination 7.10%\n", - "Did not Expect and IDK 42.60%\n", + "Expected and Right 30.00%\n", + "Expected but IDK 21.00%\n", + "Expected but Wrong 2.00%\n", + "Hallucination 5.00%\n", + "Did not Expect and IDK 42.00%\n", "Name: count, dtype: object" ] }, - "execution_count": 38, + "execution_count": 62, "metadata": {}, "output_type": "execute_result" } @@ -733,12 +851,12 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 64, "metadata": {}, "outputs": [], "source": [ "# Optionally, save the results to a JSON file\n", - "# df.to_json(\"1K_with_ft_generated_answers.json\", lines=True, orient=\"records\")" + "df.to_json(\"local_cache/100_val_ft.json\", orient=\"records\", lines=True)" ] }, { @@ -751,12 +869,12 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 65, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -840,23 +958,12 @@ "\n", "We'll select a few examples from the dataset, including cases where the answer is not present in the context. We'll then use these examples to create a prompt that we can use to fine-tune the model.\n", "\n", - "We'll measure the baseline on our previous 1K dataset, and then we'll fine-tune the model on the new dataset. We'll then measure the performance of the fine-tuned model on the same 1K dataset.\n", - "\n", - "### Get the Training Data" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "# !wget https://rajpurkar.github.io/SQuAD-explorer/dataset/train-v2.0.json -O train.json" + "We'll measure the baseline on our previous 1K dataset, and then we'll fine-tune the model on the new dataset. We'll then measure the performance of the fine-tuned model on the same 1K dataset." ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 66, "metadata": {}, "outputs": [ { @@ -955,50 +1062,12 @@ "4 [late 1990s] " ] }, - "execution_count": 2, + "execution_count": 66, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "import pandas as pd\n", - "import json\n", - "\n", - "\n", - "def json_to_dataframe_with_titles(json_data):\n", - " qas = []\n", - " context = []\n", - " is_impossible = []\n", - " answers = []\n", - " titles = []\n", - "\n", - " for article in json_data[\"data\"]:\n", - " title = article[\"title\"]\n", - " for paragraph in article[\"paragraphs\"]:\n", - " for qa in paragraph[\"qas\"]:\n", - " qas.append(qa[\"question\"].strip())\n", - " context.append(paragraph[\"context\"])\n", - " is_impossible.append(qa[\"is_impossible\"])\n", - "\n", - " ans_list = []\n", - " for ans in qa[\"answers\"]:\n", - " ans_list.append(ans[\"text\"])\n", - " answers.append(ans_list)\n", - " titles.append(title)\n", - "\n", - " df = pd.DataFrame(\n", - " {\n", - " \"title\": titles,\n", - " \"question\": qas,\n", - " \"context\": context,\n", - " \"is_impossible\": is_impossible,\n", - " \"answers\": answers,\n", - " }\n", - " )\n", - " return df\n", - "\n", - "\n", - "train_df = json_to_dataframe_with_titles(json.load(open(\"train.json\", \"r\")))\n", "train_df.head()" ] }, @@ -1012,7 +1081,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 67, "metadata": {}, "outputs": [], "source": [ @@ -1025,7 +1094,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 68, "metadata": {}, "outputs": [ { @@ -1034,7 +1103,7 @@ "True" ] }, - "execution_count": 6, + "execution_count": 68, "metadata": {}, "output_type": "execute_result" } @@ -1056,41 +1125,16 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 69, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Requirement already satisfied: fastembed in /opt/homebrew/Caskroom/miniconda/base/envs/fst/lib/python3.9/site-packages (0.0.4)\n", - "Requirement already satisfied: onnxruntime<2.0.0,>=1.15.1 in /opt/homebrew/Caskroom/miniconda/base/envs/fst/lib/python3.9/site-packages (from fastembed) (1.15.1)\n", - "Requirement already satisfied: onnxruntime-silicon<2.0.0,>=1.15.0 in /opt/homebrew/Caskroom/miniconda/base/envs/fst/lib/python3.9/site-packages (from fastembed) (1.15.0)\n", - "Requirement already satisfied: requests<3.0.0,>=2.31.0 in /opt/homebrew/Caskroom/miniconda/base/envs/fst/lib/python3.9/site-packages (from fastembed) (2.31.0)\n", - "Requirement already satisfied: tokenizers<0.14.0,>=0.13.3 in /opt/homebrew/Caskroom/miniconda/base/envs/fst/lib/python3.9/site-packages (from fastembed) (0.13.3)\n", - "Requirement already satisfied: tqdm<5.0.0,>=4.65.0 in /opt/homebrew/Caskroom/miniconda/base/envs/fst/lib/python3.9/site-packages (from fastembed) (4.65.0)\n", - "Requirement already satisfied: coloredlogs in /opt/homebrew/Caskroom/miniconda/base/envs/fst/lib/python3.9/site-packages (from onnxruntime<2.0.0,>=1.15.1->fastembed) (15.0.1)\n", - "Requirement already satisfied: flatbuffers in /opt/homebrew/Caskroom/miniconda/base/envs/fst/lib/python3.9/site-packages (from onnxruntime<2.0.0,>=1.15.1->fastembed) (23.5.26)\n", - "Requirement already satisfied: numpy>=1.21.6 in /opt/homebrew/Caskroom/miniconda/base/envs/fst/lib/python3.9/site-packages (from onnxruntime<2.0.0,>=1.15.1->fastembed) (1.24.4)\n", - "Requirement already satisfied: packaging in /opt/homebrew/Caskroom/miniconda/base/envs/fst/lib/python3.9/site-packages (from onnxruntime<2.0.0,>=1.15.1->fastembed) (23.1)\n", - "Requirement already satisfied: protobuf in /opt/homebrew/Caskroom/miniconda/base/envs/fst/lib/python3.9/site-packages (from onnxruntime<2.0.0,>=1.15.1->fastembed) (4.23.4)\n", - "Requirement already satisfied: sympy in /opt/homebrew/Caskroom/miniconda/base/envs/fst/lib/python3.9/site-packages (from onnxruntime<2.0.0,>=1.15.1->fastembed) (1.12)\n", - "Requirement already satisfied: charset-normalizer<4,>=2 in /opt/homebrew/Caskroom/miniconda/base/envs/fst/lib/python3.9/site-packages (from requests<3.0.0,>=2.31.0->fastembed) (3.2.0)\n", - "Requirement already satisfied: idna<4,>=2.5 in /opt/homebrew/Caskroom/miniconda/base/envs/fst/lib/python3.9/site-packages (from requests<3.0.0,>=2.31.0->fastembed) (3.4)\n", - "Requirement already satisfied: urllib3<3,>=1.21.1 in /opt/homebrew/Caskroom/miniconda/base/envs/fst/lib/python3.9/site-packages (from requests<3.0.0,>=2.31.0->fastembed) (1.26.16)\n", - "Requirement already satisfied: certifi>=2017.4.17 in /opt/homebrew/Caskroom/miniconda/base/envs/fst/lib/python3.9/site-packages (from requests<3.0.0,>=2.31.0->fastembed) (2023.5.7)\n", - "Requirement already satisfied: humanfriendly>=9.1 in /opt/homebrew/Caskroom/miniconda/base/envs/fst/lib/python3.9/site-packages (from coloredlogs->onnxruntime<2.0.0,>=1.15.1->fastembed) (10.0)\n", - "Requirement already satisfied: mpmath>=0.19 in /opt/homebrew/Caskroom/miniconda/base/envs/fst/lib/python3.9/site-packages (from sympy->onnxruntime<2.0.0,>=1.15.1->fastembed) (1.3.0)\n" - ] - } - ], + "outputs": [], "source": [ "# !pip install fastembed" ] }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 70, "metadata": {}, "outputs": [], "source": [ @@ -1107,40 +1151,18 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 72, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "b626be2da7bb4b659b37ab54f094d0f1", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Generating embeddings: 0%| | 0/1000 [00:00 Date: Wed, 6 Sep 2023 21:29:05 +0530 Subject: [PATCH 10/38] * chore(.gitignore): add examples/fine-tuned-RAG/local_cache/ to the gitignore file --- .gitignore | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/.gitignore b/.gitignore index fdb9d24eca..e4a66a7b25 100644 --- a/.gitignore +++ b/.gitignore @@ -132,4 +132,5 @@ dmypy.json *transactions*.jsonl /examples/data/transactions* *.DS_Store -tmp_* \ No newline at end of file +tmp_* +examples/fine-tuned-RAG/local_cache/* From 3c233d6c30b880dbba6518d58e73e890cb8a78be Mon Sep 17 00:00:00 2001 From: NirantK Date: Wed, 6 Sep 2023 21:55:56 +0530 Subject: [PATCH 11/38] Clean dataset prep for 1 shot, embed the few shot dataset --- examples/fine-tuned-RAG/ModelFinetune.ipynb | 114 ++++++++------------ 1 file changed, 44 insertions(+), 70 deletions(-) diff --git a/examples/fine-tuned-RAG/ModelFinetune.ipynb b/examples/fine-tuned-RAG/ModelFinetune.ipynb index b982bf3934..f306875964 100644 --- a/examples/fine-tuned-RAG/ModelFinetune.ipynb +++ b/examples/fine-tuned-RAG/ModelFinetune.ipynb @@ -45,7 +45,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -66,7 +66,7 @@ }, { "cell_type": "code", - "execution_count": 49, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -87,47 +87,18 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 3, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "--2023-09-06 19:39:59-- https://rajpurkar.github.io/SQuAD-explorer/dataset/train-v2.0.json\n", - "Resolving rajpurkar.github.io (rajpurkar.github.io)... 185.199.111.153, 185.199.108.153, 185.199.110.153, ...\n", - "Connecting to rajpurkar.github.io (rajpurkar.github.io)|185.199.111.153|:443... connected.\n", - "HTTP request sent, awaiting response... 200 OK\n", - "Length: 42123633 (40M) [application/json]\n", - "Saving to: ‘local_cache/train.json’\n", - "\n", - "local_cache/train.j 100%[===================>] 40.17M 35.9MB/s in 1.1s \n", - "\n", - "2023-09-06 19:40:03 (35.9 MB/s) - ‘local_cache/train.json’ saved [42123633/42123633]\n", - "\n", - "--2023-09-06 19:40:03-- https://rajpurkar.github.io/SQuAD-explorer/dataset/dev-v2.0.json\n", - "Resolving rajpurkar.github.io (rajpurkar.github.io)... 185.199.108.153, 185.199.111.153, 185.199.110.153, ...\n", - "Connecting to rajpurkar.github.io (rajpurkar.github.io)|185.199.108.153|:443... connected.\n", - "HTTP request sent, awaiting response... 200 OK\n", - "Length: 4370528 (4.2M) [application/json]\n", - "Saving to: ‘local_cache/dev.json’\n", - "\n", - "local_cache/dev.jso 100%[===================>] 4.17M 13.7MB/s in 0.3s \n", - "\n", - "2023-09-06 19:40:04 (13.7 MB/s) - ‘local_cache/dev.json’ saved [4370528/4370528]\n", - "\n" - ] - } - ], + "outputs": [], "source": [ - "!mkdir -p local_cache\n", - "!wget https://rajpurkar.github.io/SQuAD-explorer/dataset/train-v2.0.json -O local_cache/train.json\n", - "!wget https://rajpurkar.github.io/SQuAD-explorer/dataset/dev-v2.0.json -O local_cache/dev.json" + "# !mkdir -p local_cache\n", + "# !wget https://rajpurkar.github.io/SQuAD-explorer/dataset/train-v2.0.json -O local_cache/train.json\n", + "# !wget https://rajpurkar.github.io/SQuAD-explorer/dataset/dev-v2.0.json -O local_cache/dev.json" ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -358,14 +329,18 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 2, "metadata": {}, "outputs": [ { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 100/100 [00:00<00:00, 65484.84it/s]\n" + "ename": "NameError", + "evalue": "name 'get_diverse_sample' 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[2], line 20\u001b[0m\n\u001b[1;32m 17\u001b[0m jsonl_output \u001b[39m=\u001b[39m df\u001b[39m.\u001b[39mprogress_apply(create_jsonl_entry, axis\u001b[39m=\u001b[39m\u001b[39m1\u001b[39m)\n\u001b[1;32m 18\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39m\"\u001b[39m\u001b[39m\\n\u001b[39;00m\u001b[39m\"\u001b[39m\u001b[39m.\u001b[39mjoin(jsonl_output)\n\u001b[0;32m---> 20\u001b[0m train_sample \u001b[39m=\u001b[39m get_diverse_sample(train_df, sample_size\u001b[39m=\u001b[39m\u001b[39m100\u001b[39m, random_state\u001b[39m=\u001b[39m\u001b[39m42\u001b[39m)\n\u001b[1;32m 22\u001b[0m \u001b[39mwith\u001b[39;00m \u001b[39mopen\u001b[39m(\u001b[39m\"\u001b[39m\u001b[39mlocal_cache/100_train.jsonl\u001b[39m\u001b[39m\"\u001b[39m, \u001b[39m\"\u001b[39m\u001b[39mw\u001b[39m\u001b[39m\"\u001b[39m) \u001b[39mas\u001b[39;00m f:\n\u001b[1;32m 23\u001b[0m f\u001b[39m.\u001b[39mwrite(dataframe_to_jsonl(train_sample))\n", + "\u001b[0;31mNameError\u001b[0m: name 'get_diverse_sample' is not defined" ] } ], @@ -963,7 +938,7 @@ }, { "cell_type": "code", - "execution_count": 66, + "execution_count": 5, "metadata": {}, "outputs": [ { @@ -1062,7 +1037,7 @@ "4 [late 1990s] " ] }, - "execution_count": 66, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" } @@ -1081,7 +1056,7 @@ }, { "cell_type": "code", - "execution_count": 67, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ @@ -1094,7 +1069,7 @@ }, { "cell_type": "code", - "execution_count": 68, + "execution_count": 10, "metadata": {}, "outputs": [ { @@ -1103,7 +1078,7 @@ "True" ] }, - "execution_count": 68, + "execution_count": 10, "metadata": {}, "output_type": "execute_result" } @@ -1113,7 +1088,7 @@ " url=os.getenv(\"QDRANT_URL\"), api_key=os.getenv(\"QDRANT_API_KEY\")\n", ")\n", "\n", - "collection_name = \"cookbook\" # An arbitrary name for the collection\n", + "collection_name = \"squadv2-cookbook\"\n", "\n", "\n", "# Create the collection\n", @@ -1125,7 +1100,7 @@ }, { "cell_type": "code", - "execution_count": 69, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ @@ -1134,7 +1109,7 @@ }, { "cell_type": "code", - "execution_count": 70, + "execution_count": 12, "metadata": {}, "outputs": [], "source": [ @@ -1151,13 +1126,13 @@ }, { "cell_type": "code", - "execution_count": 72, + "execution_count": 13, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "8e0d768e97884ee78c778c90d1351019", + "model_id": "994a3daab89c4e64b78caf39bcfee553", "version_major": 2, "version_minor": 0 }, @@ -1171,25 +1146,33 @@ ], "source": [ "def generate_points_from_dataframe(df: pd.DataFrame) -> List[PointStruct]:\n", + " batch_size = 512\n", " questions = df[\"question\"].tolist()\n", + " total_batches = len(questions) // batch_size + 1\n", + " \n", " pbar = tqdm(total=len(questions), desc=\"Generating embeddings\")\n", - "\n", - " # Generate embeddings for each question and update tqdm progress bar\n", + " \n", + " # Generate embeddings in batches to improve performance\n", " embeddings = []\n", - " for question in questions:\n", - " embedding = list(embedding_model.embed([question]))[0]\n", - " embeddings.append(embedding)\n", - " pbar.update(1)\n", + " for i in range(total_batches):\n", + " start_idx = i * batch_size\n", + " end_idx = min((i + 1) * batch_size, len(questions))\n", + " batch = questions[start_idx:end_idx]\n", + " \n", + " batch_embeddings = embedding_model.embed(batch, batch_size=batch_size)\n", + " embeddings.extend(batch_embeddings)\n", + " pbar.update(len(batch))\n", + " \n", " pbar.close()\n", - "\n", + " \n", " # Convert embeddings to list of lists\n", " embeddings_list = [embedding.tolist() for embedding in embeddings]\n", - "\n", + " \n", " # Create a temporary DataFrame to hold the embeddings and existing DataFrame columns\n", " temp_df = df.copy()\n", " temp_df[\"embeddings\"] = embeddings_list\n", " temp_df[\"id\"] = temp_df.index\n", - "\n", + " \n", " # Generate PointStruct objects using DataFrame apply method\n", " points = temp_df.progress_apply(\n", " lambda row: PointStruct(\n", @@ -1211,15 +1194,6 @@ "points = generate_points_from_dataframe(train_df)" ] }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "collection_name = \"squadv2-cookbook\"" - ] - }, { "cell_type": "code", "execution_count": null, From 350393d66d2c6351b559a34d56faaa4d357f9a32 Mon Sep 17 00:00:00 2001 From: NirantK Date: Thu, 7 Sep 2023 15:41:27 +0530 Subject: [PATCH 12/38] Add few shot RAG with Qdrant --- examples/fine-tuned-RAG/ModelFinetune.ipynb | 594 ++++++++++++++++---- 1 file changed, 492 insertions(+), 102 deletions(-) diff --git a/examples/fine-tuned-RAG/ModelFinetune.ipynb b/examples/fine-tuned-RAG/ModelFinetune.ipynb index f306875964..0c2cc587e5 100644 --- a/examples/fine-tuned-RAG/ModelFinetune.ipynb +++ b/examples/fine-tuned-RAG/ModelFinetune.ipynb @@ -155,7 +155,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 57, "metadata": {}, "outputs": [], "source": [ @@ -186,8 +186,8 @@ "\n", "\n", "# Main function to answer question\n", - "def answer_question(row, model=\"gpt-3.5-turbo-0613\"):\n", - " messages = get_prompt(row)\n", + "def answer_question(row, prompt_func=get_prompt, model=\"gpt-3.5-turbo-0613\"):\n", + " messages = prompt_func(row)\n", " response = api_call(messages, model)\n", " return response[\"choices\"][0][\"message\"][\"content\"]" ] @@ -245,23 +245,36 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 61, "metadata": {}, "outputs": [ { - "data": { - "text/plain": [ - "Expected and Right 43.00%\n", - "Expected but IDK 0.00%\n", - "Expected but Wrong 10.00%\n", - "Hallucination 47.00%\n", - "Did not Expect and IDK 0.00%\n", - "Name: count, dtype: object" - ] - }, - "execution_count": 12, - "metadata": {}, - "output_type": "execute_result" + "ename": "KeyError", + "evalue": "'generated_answer'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mKeyError\u001b[0m Traceback (most recent call last)", + "File \u001b[0;32m/opt/homebrew/Caskroom/miniconda/base/envs/fst/lib/python3.9/site-packages/pandas/core/indexes/base.py:3653\u001b[0m, in \u001b[0;36mIndex.get_loc\u001b[0;34m(self, key)\u001b[0m\n\u001b[1;32m 3652\u001b[0m \u001b[39mtry\u001b[39;00m:\n\u001b[0;32m-> 3653\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_engine\u001b[39m.\u001b[39;49mget_loc(casted_key)\n\u001b[1;32m 3654\u001b[0m \u001b[39mexcept\u001b[39;00m \u001b[39mKeyError\u001b[39;00m \u001b[39mas\u001b[39;00m err:\n", + "File \u001b[0;32m/opt/homebrew/Caskroom/miniconda/base/envs/fst/lib/python3.9/site-packages/pandas/_libs/index.pyx:147\u001b[0m, in \u001b[0;36mpandas._libs.index.IndexEngine.get_loc\u001b[0;34m()\u001b[0m\n", + "File \u001b[0;32m/opt/homebrew/Caskroom/miniconda/base/envs/fst/lib/python3.9/site-packages/pandas/_libs/index.pyx:176\u001b[0m, in \u001b[0;36mpandas._libs.index.IndexEngine.get_loc\u001b[0;34m()\u001b[0m\n", + "File \u001b[0;32mpandas/_libs/hashtable_class_helper.pxi:7080\u001b[0m, in \u001b[0;36mpandas._libs.hashtable.PyObjectHashTable.get_item\u001b[0;34m()\u001b[0m\n", + "File \u001b[0;32mpandas/_libs/hashtable_class_helper.pxi:7088\u001b[0m, in \u001b[0;36mpandas._libs.hashtable.PyObjectHashTable.get_item\u001b[0;34m()\u001b[0m\n", + "\u001b[0;31mKeyError\u001b[0m: 'generated_answer'", + "\nThe above exception was the direct cause of the following exception:\n", + "\u001b[0;31mKeyError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[61], line 46\u001b[0m\n\u001b[1;32m 42\u001b[0m \u001b[39mreturn\u001b[39;00m freq_series\n\u001b[1;32m 45\u001b[0m evaluator \u001b[39m=\u001b[39m ConfusionMatrixEvaluator(df, answers_column\u001b[39m=\u001b[39m\u001b[39m\"\u001b[39m\u001b[39mgenerated_answer\u001b[39m\u001b[39m\"\u001b[39m)\n\u001b[0;32m---> 46\u001b[0m evaluator\u001b[39m.\u001b[39;49mevaluate_answers()\n\u001b[1;32m 47\u001b[0m error_categories \u001b[39m=\u001b[39m evaluator\u001b[39m.\u001b[39mgenerate_matrices(use_percentages\u001b[39m=\u001b[39m\u001b[39mTrue\u001b[39;00m)\n\u001b[1;32m 48\u001b[0m error_categories\n", + "Cell \u001b[0;32mIn[61], line 34\u001b[0m, in \u001b[0;36mConfusionMatrixEvaluator.evaluate_answers\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 33\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mevaluate_answers\u001b[39m(\u001b[39mself\u001b[39m):\n\u001b[0;32m---> 34\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39my_pred \u001b[39m=\u001b[39m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mdf\u001b[39m.\u001b[39;49mapply(\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_evaluate_single_row, axis\u001b[39m=\u001b[39;49m\u001b[39m1\u001b[39;49m)\n", + "File \u001b[0;32m/opt/homebrew/Caskroom/miniconda/base/envs/fst/lib/python3.9/site-packages/pandas/core/frame.py:9423\u001b[0m, in \u001b[0;36mDataFrame.apply\u001b[0;34m(self, func, axis, raw, result_type, args, **kwargs)\u001b[0m\n\u001b[1;32m 9412\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39mpandas\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mcore\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mapply\u001b[39;00m \u001b[39mimport\u001b[39;00m frame_apply\n\u001b[1;32m 9414\u001b[0m op \u001b[39m=\u001b[39m frame_apply(\n\u001b[1;32m 9415\u001b[0m \u001b[39mself\u001b[39m,\n\u001b[1;32m 9416\u001b[0m func\u001b[39m=\u001b[39mfunc,\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 9421\u001b[0m kwargs\u001b[39m=\u001b[39mkwargs,\n\u001b[1;32m 9422\u001b[0m )\n\u001b[0;32m-> 9423\u001b[0m \u001b[39mreturn\u001b[39;00m op\u001b[39m.\u001b[39;49mapply()\u001b[39m.\u001b[39m__finalize__(\u001b[39mself\u001b[39m, method\u001b[39m=\u001b[39m\u001b[39m\"\u001b[39m\u001b[39mapply\u001b[39m\u001b[39m\"\u001b[39m)\n", + "File \u001b[0;32m/opt/homebrew/Caskroom/miniconda/base/envs/fst/lib/python3.9/site-packages/pandas/core/apply.py:678\u001b[0m, in \u001b[0;36mFrameApply.apply\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 675\u001b[0m \u001b[39melif\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mraw:\n\u001b[1;32m 676\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mapply_raw()\n\u001b[0;32m--> 678\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mapply_standard()\n", + "File \u001b[0;32m/opt/homebrew/Caskroom/miniconda/base/envs/fst/lib/python3.9/site-packages/pandas/core/apply.py:798\u001b[0m, in \u001b[0;36mFrameApply.apply_standard\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 797\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mapply_standard\u001b[39m(\u001b[39mself\u001b[39m):\n\u001b[0;32m--> 798\u001b[0m results, res_index \u001b[39m=\u001b[39m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mapply_series_generator()\n\u001b[1;32m 800\u001b[0m \u001b[39m# wrap results\u001b[39;00m\n\u001b[1;32m 801\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mwrap_results(results, res_index)\n", + "File \u001b[0;32m/opt/homebrew/Caskroom/miniconda/base/envs/fst/lib/python3.9/site-packages/pandas/core/apply.py:814\u001b[0m, in \u001b[0;36mFrameApply.apply_series_generator\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 811\u001b[0m \u001b[39mwith\u001b[39;00m option_context(\u001b[39m\"\u001b[39m\u001b[39mmode.chained_assignment\u001b[39m\u001b[39m\"\u001b[39m, \u001b[39mNone\u001b[39;00m):\n\u001b[1;32m 812\u001b[0m \u001b[39mfor\u001b[39;00m i, v \u001b[39min\u001b[39;00m \u001b[39menumerate\u001b[39m(series_gen):\n\u001b[1;32m 813\u001b[0m \u001b[39m# ignore SettingWithCopy here in case the user mutates\u001b[39;00m\n\u001b[0;32m--> 814\u001b[0m results[i] \u001b[39m=\u001b[39m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mf(v)\n\u001b[1;32m 815\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39misinstance\u001b[39m(results[i], ABCSeries):\n\u001b[1;32m 816\u001b[0m \u001b[39m# If we have a view on v, we need to make a copy because\u001b[39;00m\n\u001b[1;32m 817\u001b[0m \u001b[39m# series_generator will swap out the underlying data\u001b[39;00m\n\u001b[1;32m 818\u001b[0m results[i] \u001b[39m=\u001b[39m results[i]\u001b[39m.\u001b[39mcopy(deep\u001b[39m=\u001b[39m\u001b[39mFalse\u001b[39;00m)\n", + "Cell \u001b[0;32mIn[61], line 16\u001b[0m, in \u001b[0;36mConfusionMatrixEvaluator._evaluate_single_row\u001b[0;34m(self, row)\u001b[0m\n\u001b[1;32m 14\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39m_evaluate_single_row\u001b[39m(\u001b[39mself\u001b[39m, row):\n\u001b[1;32m 15\u001b[0m is_impossible \u001b[39m=\u001b[39m row[\u001b[39m\"\u001b[39m\u001b[39mis_impossible\u001b[39m\u001b[39m\"\u001b[39m]\n\u001b[0;32m---> 16\u001b[0m generated_answer \u001b[39m=\u001b[39m row[\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49manswers_column]\u001b[39m.\u001b[39mlower()\n\u001b[1;32m 17\u001b[0m actual_answers \u001b[39m=\u001b[39m [ans\u001b[39m.\u001b[39mlower() \u001b[39mfor\u001b[39;00m ans \u001b[39min\u001b[39;00m row[\u001b[39m\"\u001b[39m\u001b[39manswers\u001b[39m\u001b[39m\"\u001b[39m]]\n\u001b[1;32m 19\u001b[0m y_pred \u001b[39m=\u001b[39m (\n\u001b[1;32m 20\u001b[0m \u001b[39m\"\u001b[39m\u001b[39mExpected and Right\u001b[39m\u001b[39m\"\u001b[39m\n\u001b[1;32m 21\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mnot\u001b[39;00m is_impossible\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 29\u001b[0m \u001b[39melse\u001b[39;00m \u001b[39m\"\u001b[39m\u001b[39mDid not Expect and IDK\u001b[39m\u001b[39m\"\u001b[39m\n\u001b[1;32m 30\u001b[0m )\n", + "File \u001b[0;32m/opt/homebrew/Caskroom/miniconda/base/envs/fst/lib/python3.9/site-packages/pandas/core/series.py:1007\u001b[0m, in \u001b[0;36mSeries.__getitem__\u001b[0;34m(self, key)\u001b[0m\n\u001b[1;32m 1004\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_values[key]\n\u001b[1;32m 1006\u001b[0m \u001b[39melif\u001b[39;00m key_is_scalar:\n\u001b[0;32m-> 1007\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_get_value(key)\n\u001b[1;32m 1009\u001b[0m \u001b[39mif\u001b[39;00m is_hashable(key):\n\u001b[1;32m 1010\u001b[0m \u001b[39m# Otherwise index.get_value will raise InvalidIndexError\u001b[39;00m\n\u001b[1;32m 1011\u001b[0m \u001b[39mtry\u001b[39;00m:\n\u001b[1;32m 1012\u001b[0m \u001b[39m# For labels that don't resolve as scalars like tuples and frozensets\u001b[39;00m\n", + "File \u001b[0;32m/opt/homebrew/Caskroom/miniconda/base/envs/fst/lib/python3.9/site-packages/pandas/core/series.py:1116\u001b[0m, in \u001b[0;36mSeries._get_value\u001b[0;34m(self, label, takeable)\u001b[0m\n\u001b[1;32m 1113\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_values[label]\n\u001b[1;32m 1115\u001b[0m \u001b[39m# Similar to Index.get_value, but we do not fall back to positional\u001b[39;00m\n\u001b[0;32m-> 1116\u001b[0m loc \u001b[39m=\u001b[39m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mindex\u001b[39m.\u001b[39;49mget_loc(label)\n\u001b[1;32m 1118\u001b[0m \u001b[39mif\u001b[39;00m is_integer(loc):\n\u001b[1;32m 1119\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_values[loc]\n", + "File \u001b[0;32m/opt/homebrew/Caskroom/miniconda/base/envs/fst/lib/python3.9/site-packages/pandas/core/indexes/base.py:3655\u001b[0m, in \u001b[0;36mIndex.get_loc\u001b[0;34m(self, key)\u001b[0m\n\u001b[1;32m 3653\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_engine\u001b[39m.\u001b[39mget_loc(casted_key)\n\u001b[1;32m 3654\u001b[0m \u001b[39mexcept\u001b[39;00m \u001b[39mKeyError\u001b[39;00m \u001b[39mas\u001b[39;00m err:\n\u001b[0;32m-> 3655\u001b[0m \u001b[39mraise\u001b[39;00m \u001b[39mKeyError\u001b[39;00m(key) \u001b[39mfrom\u001b[39;00m \u001b[39merr\u001b[39;00m\n\u001b[1;32m 3656\u001b[0m \u001b[39mexcept\u001b[39;00m \u001b[39mTypeError\u001b[39;00m:\n\u001b[1;32m 3657\u001b[0m \u001b[39m# If we have a listlike key, _check_indexing_error will raise\u001b[39;00m\n\u001b[1;32m 3658\u001b[0m \u001b[39m# InvalidIndexError. Otherwise we fall through and re-raise\u001b[39;00m\n\u001b[1;32m 3659\u001b[0m \u001b[39m# the TypeError.\u001b[39;00m\n\u001b[1;32m 3660\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_check_indexing_error(key)\n", + "\u001b[0;31mKeyError\u001b[0m: 'generated_answer'" + ] } ], "source": [ @@ -1069,33 +1082,22 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 22, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "True" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "qdrant_client = QdrantClient(\n", - " url=os.getenv(\"QDRANT_URL\"), api_key=os.getenv(\"QDRANT_API_KEY\")\n", + " url=os.getenv(\"QDRANT_URL\"), api_key=os.getenv(\"QDRANT_API_KEY\"), timeout=6000, prefer_grpc=True\n", ")\n", "\n", - "collection_name = \"squadv2-cookbook\"\n", + "# collection_name = \"squadv2-cookbook\"\n", "\n", "\n", - "# Create the collection\n", - "qdrant_client.recreate_collection(\n", - " collection_name=collection_name,\n", - " vectors_config=VectorParams(size=384, distance=Distance.COSINE),\n", - ")" + "# # Create the collection\n", + "# qdrant_client.recreate_collection(\n", + "# collection_name=collection_name,\n", + "# vectors_config=VectorParams(size=384, distance=Distance.COSINE),\n", + "# )" ] }, { @@ -1124,6 +1126,17 @@ "embedding_model = DefaultEmbedding()" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Embedding the Questions\n", + "\n", + "We embed the entire training set questions. We'll use the question to question similarity to find the most similar questions to the question we're looking for. This is a workflow which is used in RAG to leverage the OpenAI model ability of incontext learning with more examples. This is what we call Few Shot Learning here.\n", + "\n", + "### ❗️ Important Note: This step can take upto 3 hours to complete. Please be patient. If you see Out of Memory errors or Kernel Crashes, please reduce the batch size to 32, restart the kernel and run the notebook again. This code needs to be run only ONCE. " + ] + }, { "cell_type": "code", "execution_count": 13, @@ -1142,61 +1155,84 @@ }, "metadata": {}, "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "3cf2827c330b434fa58295794d94356e", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/130319 [00:00 List[PointStruct]:\n", - " batch_size = 512\n", - " questions = df[\"question\"].tolist()\n", - " total_batches = len(questions) // batch_size + 1\n", + "# def generate_points_from_dataframe(df: pd.DataFrame) -> List[PointStruct]:\n", + "# batch_size = 512\n", + "# questions = df[\"question\"].tolist()\n", + "# total_batches = len(questions) // batch_size + 1\n", " \n", - " pbar = tqdm(total=len(questions), desc=\"Generating embeddings\")\n", + "# pbar = tqdm(total=len(questions), desc=\"Generating embeddings\")\n", " \n", - " # Generate embeddings in batches to improve performance\n", - " embeddings = []\n", - " for i in range(total_batches):\n", - " start_idx = i * batch_size\n", - " end_idx = min((i + 1) * batch_size, len(questions))\n", - " batch = questions[start_idx:end_idx]\n", + "# # Generate embeddings in batches to improve performance\n", + "# embeddings = []\n", + "# for i in range(total_batches):\n", + "# start_idx = i * batch_size\n", + "# end_idx = min((i + 1) * batch_size, len(questions))\n", + "# batch = questions[start_idx:end_idx]\n", " \n", - " batch_embeddings = embedding_model.embed(batch, batch_size=batch_size)\n", - " embeddings.extend(batch_embeddings)\n", - " pbar.update(len(batch))\n", + "# batch_embeddings = embedding_model.embed(batch, batch_size=batch_size)\n", + "# embeddings.extend(batch_embeddings)\n", + "# pbar.update(len(batch))\n", " \n", - " pbar.close()\n", + "# pbar.close()\n", " \n", - " # Convert embeddings to list of lists\n", - " embeddings_list = [embedding.tolist() for embedding in embeddings]\n", + "# # Convert embeddings to list of lists\n", + "# embeddings_list = [embedding.tolist() for embedding in embeddings]\n", " \n", - " # Create a temporary DataFrame to hold the embeddings and existing DataFrame columns\n", - " temp_df = df.copy()\n", - " temp_df[\"embeddings\"] = embeddings_list\n", - " temp_df[\"id\"] = temp_df.index\n", + "# # Create a temporary DataFrame to hold the embeddings and existing DataFrame columns\n", + "# temp_df = df.copy()\n", + "# temp_df[\"embeddings\"] = embeddings_list\n", + "# temp_df[\"id\"] = temp_df.index\n", " \n", - " # Generate PointStruct objects using DataFrame apply method\n", - " points = temp_df.progress_apply(\n", - " lambda row: PointStruct(\n", - " id=row[\"id\"],\n", - " vector=row[\"embeddings\"],\n", - " payload={\n", - " \"question\": row[\"question\"],\n", - " \"title\": row[\"title\"],\n", - " \"context\": row[\"context\"],\n", - " \"is_impossible\": row[\"is_impossible\"],\n", - " \"answers\": row[\"answers\"],\n", - " },\n", - " ),\n", - " axis=1,\n", - " ).tolist()\n", - "\n", - " return points\n", + "# # Generate PointStruct objects using DataFrame apply method\n", + "# points = temp_df.progress_apply(\n", + "# lambda row: PointStruct(\n", + "# id=row[\"id\"],\n", + "# vector=row[\"embeddings\"],\n", + "# payload={\n", + "# \"question\": row[\"question\"],\n", + "# \"title\": row[\"title\"],\n", + "# \"context\": row[\"context\"],\n", + "# \"is_impossible\": row[\"is_impossible\"],\n", + "# \"answers\": row[\"answers\"],\n", + "# },\n", + "# ),\n", + "# axis=1,\n", + "# ).tolist()\n", + "\n", + "# return points\n", + "\n", + "# points = generate_points_from_dataframe(train_df)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Upload the Embeddings to Qdrant\n", "\n", - "points = generate_points_from_dataframe(train_df)" + "Note that configuring Qdrant is outside the scope of this notebook. Please refer to the [Qdrant](https://qdrant.tech) for more information. We used a timeout of 600 seconds for the upload, and grpc compression to speed up the upload." ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 23, "metadata": {}, "outputs": [ { @@ -1208,35 +1244,44 @@ } ], "source": [ - "operation_info = qdrant_client.upsert(\n", - " collection_name=collection_name, wait=True, points=points\n", - ")\n", - "print(operation_info)" + "# operation_info = qdrant_client.upsert(\n", + "# collection_name=collection_name, wait=True, points=points\n", + "# )\n", + "# print(operation_info)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 25, "metadata": {}, "outputs": [], "source": [ - "train_sample.describe()" + "train_sample = get_diverse_sample(train_df, sample_size=100, random_state=42)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Using Qdrant to Improve RAG Prompt\n", + "\n", + "Now that we've uploaded the embeddings to Qdrant, we can use Qdrant to find the most similar questions to the question we're looking for. We'll use the top 5 most similar questions to create a prompt that we can use to fine-tune the model. We'll then measure the performance of the fine-tuned model on the same validation set, but with few shot prompting!" ] }, { "cell_type": "code", - "execution_count": 79, + "execution_count": 87, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "dcd828a1f36945a59b8b0d91d641e390", + "model_id": "ff39612710a749fdae166745b2bd2d5a", "version_major": 2, "version_minor": 0 }, "text/plain": [ - " 0%| | 0/1000 [00:00= 1:\n", - " rag_prompt += q_to_prompt(q1[0])\n", " # If the next best question is not the same as the question, add it to the prompt\n", - " if len(q2) >= 1 and (q2[0].payload[\"question\"] != q1[0].payload[\"question\"]):\n", - " rag_prompt += q_to_prompt(q2[0])\n", + " if len(q2) >= 1:\n", + " rag_prompt += q_to_prompt(q2[1])\n", + " if len(q1) >= 1:\n", + " rag_prompt += q_to_prompt(q1[1])\n", + " rag_prompt += q_to_prompt(q1[2])\n", + " if len(q2) >= 1:\n", + " rag_prompt += q_to_prompt(q2[2])\n", + " \n", + " \n", "\n", " rag_prompt += [\n", " {\n", @@ -1326,7 +1376,7 @@ }, { "cell_type": "code", - "execution_count": 73, + "execution_count": 88, "metadata": {}, "outputs": [ { @@ -1340,40 +1390,380 @@ "Name: few_shot_prompt_1K, dtype: object" ] }, - "execution_count": 73, + "execution_count": 88, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "df[\"few_shot_prompt_1K\"].head()" + "train_sample[\"few_shot_prompt_1K\"].head()" ] }, { "cell_type": "code", - "execution_count": 80, + "execution_count": 89, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[{'role': 'system',\n", + " 'content': \"Answer the following Question based on the Context only. Only answer from the Context. If you don't know the answer, say 'I don't know'.\\n\\n\"},\n", + " {'role': 'user',\n", + " 'content': 'Question: What is the Italian Quarter?\\n\\nContext: Small Armenian trading and religious communities have existed outside of Armenia for centuries. For example, a community has existed for over a millennium in the Holy Land, and one of the four quarters of the walled Old City of Jerusalem has been called the Armenian Quarter. An Armenian Catholic monastic community of 35 founded in 1717 exists on an island near Venice, Italy. There are also remnants of formerly populous communities in India, Myanmar, Thailand, Belgium, Portugal, Italy, Poland, Austria, Hungary, Bulgaria, Romania, Serbia, Ethiopia, Sudan and Egypt.[citation needed]\\n\\nAnswer:'},\n", + " {'role': 'assistant', 'content': \"I don't know\"},\n", + " {'role': 'user',\n", + " 'content': \"Question: What shape is a cirque, generally?\\n\\nContext: Glaciers form where the accumulation of snow and ice exceeds ablation. The area in which a glacier forms is called a cirque (corrie or cwm) - a typically armchair-shaped geological feature (such as a depression between mountains enclosed by arêtes) - which collects and compresses through gravity the snow which falls into it. This snow collects and is compacted by the weight of the snow falling above it forming névé. Further crushing of the individual snowflakes and squeezing the air from the snow turns it into 'glacial ice'. This glacial ice will fill the cirque until it 'overflows' through a geological weakness or vacancy, such as the gap between two mountains. When the mass of snow and ice is sufficiently thick, it begins to move due to a combination of surface slope, gravity and pressure. On steeper slopes, this can occur with as little as 15 m (50 ft) of snow-ice.\\n\\nAnswer:\"},\n", + " {'role': 'assistant', 'content': 'armchair-shaped'},\n", + " {'role': 'user',\n", + " 'content': 'Question: On which side is a cirque opened?\\n\\nContext: At the start of a classic valley glacier is a bowl-shaped cirque, which has escarped walls on three sides but is open on the side that descends into the valley. Cirques are where ice begins to accumulate in a glacier. Two glacial cirques may form back to back and erode their backwalls until only a narrow ridge, called an arête is left. This structure may result in a mountain pass. If multiple cirques encircle a single mountain, they create pointed pyramidal peaks; particularly steep examples are called horns.\\n\\nAnswer:'},\n", + " {'role': 'assistant', 'content': 'the side that descends into the valley'},\n", + " {'role': 'user',\n", + " 'content': 'Question: What are two indications of a larger cerebrum?\\n\\nContext: In intelligent mammals, such as primates, the cerebrum is larger relative to the rest of the brain. Intelligence itself is not easy to define, but indications of intelligence include the ability to learn, matched with behavioral flexibility. Rats, for example, are considered to be highly intelligent, as they can learn and perform new tasks, an ability that may be important when they first colonize a fresh habitat. In some mammals, food gathering appears to be related to intelligence: a deer feeding on plants has a brain smaller than a cat, which must think to outwit its prey.\\n\\nAnswer:'},\n", + " {'role': 'assistant', 'content': \"I don't know\"},\n", + " {'role': 'user',\n", + " 'content': \"Question: What is a cirque?\\n\\nContext: Glaciers form where the accumulation of snow and ice exceeds ablation. The area in which a glacier forms is called a cirque (corrie or cwm) - a typically armchair-shaped geological feature (such as a depression between mountains enclosed by arêtes) - which collects and compresses through gravity the snow which falls into it. This snow collects and is compacted by the weight of the snow falling above it forming névé. Further crushing of the individual snowflakes and squeezing the air from the snow turns it into 'glacial ice'. This glacial ice will fill the cirque until it 'overflows' through a geological weakness or vacancy, such as the gap between two mountains. When the mass of snow and ice is sufficiently thick, it begins to move due to a combination of surface slope, gravity and pressure. On steeper slopes, this can occur with as little as 15 m (50 ft) of snow-ice.\\n\\nAnswer:\"}]" + ] + }, + "execution_count": 89, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "train_sample[\"few_shot_prompt_1K\"].iloc[0]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## OpenAI Model Fine-Tuning\n", + "\n", + "### Upload the Fine-Tuning Data to OpenAI" + ] + }, + { + "cell_type": "code", + "execution_count": 90, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "9bf7fea68e3d45e4ade09e63f7abe907", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/100 [00:00 Date: Thu, 7 Sep 2023 15:41:55 +0530 Subject: [PATCH 13/38] Remove unused code --- examples/fine-tuned-RAG/ModelFinetune.ipynb | 5 ----- 1 file changed, 5 deletions(-) diff --git a/examples/fine-tuned-RAG/ModelFinetune.ipynb b/examples/fine-tuned-RAG/ModelFinetune.ipynb index 0c2cc587e5..d0dc1b5fbd 100644 --- a/examples/fine-tuned-RAG/ModelFinetune.ipynb +++ b/examples/fine-tuned-RAG/ModelFinetune.ipynb @@ -1483,11 +1483,6 @@ "metadata": {}, "outputs": [], "source": [ - "\n", - "os.environ[\"OPENAI_API_KEY\"] = \"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\"\n", - "openai.api_key = os.environ[\"OPENAI_API_KEY\"]\n", - "os.environ[\"QDRANT_URL\"] = \"https://4541e874-8a3f-439d-81c8-4ac59b2816e1.us-east-1-0.aws.cloud.qdrant.io:6333\"\n", - "os.environ[\"QDRANT_API_KEY\"] = \"A64kdbyOowZ9099dWCBMN1kDcKKUfaBGU3avHVU05jnRshUABoR5aQ\"\n", "# Create OpenAI File\n", "file_object = openai.File.create(\n", " file=open(\"local_cache/100_train_few_shot.jsonl\", \"r\"),\n", From fe59ced6261baed798ec85e91a6cd2a2138b8839 Mon Sep 17 00:00:00 2001 From: NirantK Date: Thu, 7 Sep 2023 15:44:12 +0530 Subject: [PATCH 14/38] more inline output --- examples/fine-tuned-RAG/ModelFinetune.ipynb | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/examples/fine-tuned-RAG/ModelFinetune.ipynb b/examples/fine-tuned-RAG/ModelFinetune.ipynb index d0dc1b5fbd..95495c19a6 100644 --- a/examples/fine-tuned-RAG/ModelFinetune.ipynb +++ b/examples/fine-tuned-RAG/ModelFinetune.ipynb @@ -1654,16 +1654,16 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 95, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "'ft:gpt-3.5-turbo-0613:qdrant:trnfewshot20230907:7w54vei9'" + "'ft:gpt-3.5-turbo-0613:qdrant:trnfewshot20230907:7w6Gapu0'" ] }, - "execution_count": 72, + "execution_count": 95, "metadata": {}, "output_type": "execute_result" } @@ -1675,13 +1675,13 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 96, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "4333f061f0e54cb5a8a30133308896a5", + "model_id": "e39ab52659a44ec59b5748399c2e24fa", "version_major": 2, "version_minor": 0 }, From 324a4f3402b4230b12acd4a47c55365392b2a524 Mon Sep 17 00:00:00 2001 From: NirantK Date: Thu, 7 Sep 2023 15:47:31 +0530 Subject: [PATCH 15/38] * fix(ModelFinetune.ipynb): update execution counts for code cells * fix(ModelFinetune.ipynb): update generated answer for few-shot question * fix(ModelFinetune.ipynb): update count percentages for different answer types --- examples/fine-tuned-RAG/ModelFinetune.ipynb | 28 ++++++++++----------- 1 file changed, 14 insertions(+), 14 deletions(-) diff --git a/examples/fine-tuned-RAG/ModelFinetune.ipynb b/examples/fine-tuned-RAG/ModelFinetune.ipynb index 95495c19a6..b3c9215849 100644 --- a/examples/fine-tuned-RAG/ModelFinetune.ipynb +++ b/examples/fine-tuned-RAG/ModelFinetune.ipynb @@ -45,7 +45,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 99, "metadata": {}, "outputs": [], "source": [ @@ -1706,44 +1706,44 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 100, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "{'ft_generated_answer_few_shot': 'illegal boycotts',\n", - " 'question': 'What is a type of disobedience against the federal government?',\n", - " 'context': 'Some forms of civil disobedience, such as illegal boycotts, refusals to pay taxes, draft dodging, distributed denial-of-service attacks, and sit-ins, make it more difficult for a system to function. In this way, they might be considered coercive. Brownlee notes that \"although civil disobedients are constrained in their use of coercion by their conscientious aim to engage in moral dialogue, nevertheless they may find it necessary to employ limited coercion in order to get their issue onto the table.\" The Plowshares organization temporarily closed GCSB Waihopai by padlocking the gates and using sickles to deflate one of the large domes covering two satellite dishes.',\n", - " 'is_impossible': False}" + "{'ft_generated_answer_few_shot': \"I don't know\",\n", + " 'question': 'When was the deportation of Canadians?',\n", + " 'context': 'Britain gained control of French Canada and Acadia, colonies containing approximately 80,000 primarily French-speaking Roman Catholic residents. The deportation of Acadians beginning in 1755 resulted in land made available to migrants from Europe and the colonies further south. The British resettled many Acadians throughout its North American provinces, but many went to France, and some went to New Orleans, which they had expected to remain French. Some were sent to colonize places as diverse as French Guiana and the Falkland Islands; these latter efforts were unsuccessful. Others migrated to places like Saint-Domingue, and fled to New Orleans after the Haitian Revolution. The Louisiana population contributed to the founding of the modern Cajun population. (The French word \"Acadien\" evolved to \"Cadien\", then to \"Cajun\".)',\n", + " 'is_impossible': True}" ] }, - "execution_count": 86, + "execution_count": 100, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "df[[\"ft_generated_answer_few_shot\", \"question\", \"context\", \"is_impossible\"]].iloc[5].to_dict()" + "df[[\"ft_generated_answer_few_shot\", \"question\", \"context\", \"is_impossible\"]].iloc[4].to_dict()" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 98, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Expected and Right 46.00%\n", - "Expected but IDK 0.00%\n", - "Expected but Wrong 7.00%\n", - "Hallucination 44.00%\n", - "Did not Expect and IDK 3.00%\n", + "Expected but IDK 5.00%\n", + "Expected but Wrong 2.00%\n", + "Hallucination 27.00%\n", + "Did not Expect and IDK 20.00%\n", "Name: count, dtype: object" ] }, - "execution_count": 75, + "execution_count": 98, "metadata": {}, "output_type": "execute_result" } From b3d2dfe6485839c98fca011cc4e8b48a1acf6121 Mon Sep 17 00:00:00 2001 From: NirantK Date: Thu, 7 Sep 2023 16:01:56 +0530 Subject: [PATCH 16/38] * chore(ModelFinetune.ipynb): update section titles and content * feat(ModelFinetune.ipynb): add new sections for Qdrant integration and Few-Shot Learning * fix(ModelFinetune.ipynb): fix typo in section title --- examples/fine-tuned-RAG/ModelFinetune.ipynb | 61 ++++++++++++++------- 1 file changed, 40 insertions(+), 21 deletions(-) diff --git a/examples/fine-tuned-RAG/ModelFinetune.ipynb b/examples/fine-tuned-RAG/ModelFinetune.ipynb index b3c9215849..0f810efd83 100644 --- a/examples/fine-tuned-RAG/ModelFinetune.ipynb +++ b/examples/fine-tuned-RAG/ModelFinetune.ipynb @@ -9,19 +9,18 @@ "\n", "\n", "\n", - "Here, we'll take you through the process, complete with code examples, to help you fine-tune your OpenAI model for usage with RAG like a pro.\n", - "\n", - "\n", + "Intent: Show how to fine-tune OpenAI models for RAG and improve them using Qdrant and Few-Shot Learning! 🤩\n", "\n", "To begin, we've selected a dataset where we've a guarantee that the retrieval is perfect. We've selected a subset of the [SQuAD](https://rajpurkar.github.io/SQuAD-explorer/) dataset, which is a collection of questions and answers about Wikipedia articles. We've also included samples where the answer is not present in the context, to demonstrate how RAG handles this case.\n", "\n", "## Table of Contents\n", "1. Setting up the Environment\n", "2. Data Preparation\n", - "3. Running the Model\n", - "4. Evaluation\n", - "5. Fine-Tuning\n", - "6. Comparison" + "3. OpenAI Model Fine-Tuning\n", + "4. Evaluation with OpenAI\n", + "5. Using Qdrant to Improve RAG Prompt\n", + "6. Few-Shot Learning with Qdrant\n", + "7. Comparison and Results" ] }, { @@ -78,10 +77,12 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Preparing the Data\n", + "## Data Preparation: SQuADv2 Data Subsets\n", "\n", "For the purpose of demonstration, we'll make small slices from the train and validation splits of the [SQuADv2](https://rajpurkar.github.io/SQuAD-explorer/) dataset. This dataset has questions and contexts where the answer is not present in the context, to help us evaluate how LLM handles this case.\n", "\n", + "We'll read the data from the JSON files and create a dataframe with the following columns: `question`, `context`, `answer`, `is_impossible`.\n", + "\n", "### Download the Data" ] }, @@ -96,6 +97,13 @@ "# !wget https://rajpurkar.github.io/SQuAD-explorer/dataset/dev-v2.0.json -O local_cache/dev.json" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## JSON to DataFrame" + ] + }, { "cell_type": "code", "execution_count": 4, @@ -333,7 +341,9 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Fine-Tuning\n", + "## Fine-Tuning the OpenAI Model\n", + "\n", + "For the complete fine-tuning process, please refer to the [OpenAI Fine-Tuning Docs](https://platform.openai.com/docs/guides/fine-tuning/use-a-fine-tuned-model).\n", "\n", "### Prepare the Fine-Tuning Data\n", "\n", @@ -388,7 +398,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### [Optional] Verify the Fine-Tuning Data\n", + "#### [Optional] Verify the Fine-Tuning Data\n", "\n", "The script below will verify that the data is in the format that OpenAI expects." ] @@ -576,7 +586,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### Push the Fine-Tuning data to OpenAI" + "### Upload the Fine-Tuning data to OpenAI" ] }, { @@ -1064,7 +1074,9 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### Embed the Training Data" + "### Embed the Training Data\n", + "\n", + "Embeddings are a way to represent sentences as an array of floats. We'll use the embeddings to find the most similar questions to the ones we're looking for." ] }, { @@ -1072,6 +1084,15 @@ "execution_count": 9, "metadata": {}, "outputs": [], + "source": [ + "# !pip install fastembed" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "import os\n", "from qdrant_client import QdrantClient\n", @@ -1080,6 +1101,13 @@ "from qdrant_client.http.models import Distance, VectorParams" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now that we've the Qdrant imports in place, " + ] + }, { "cell_type": "code", "execution_count": 22, @@ -1100,15 +1128,6 @@ "# )" ] }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [], - "source": [ - "# !pip install fastembed" - ] - }, { "cell_type": "code", "execution_count": 12, From 219fdab9f6bf979ccd4f85044dc640dfea153512 Mon Sep 17 00:00:00 2001 From: NirantK Date: Thu, 7 Sep 2023 16:23:32 +0530 Subject: [PATCH 17/38] * chore(ModelFinetune.ipynb): update headings and descriptions in the notebook * fix(ModelFinetune.ipynb): fix heading for the setting up section * fix(ModelFinetune.ipynb): fix heading for the data preparation section --- examples/fine-tuned-RAG/ModelFinetune.ipynb | 242 +++++--------------- 1 file changed, 56 insertions(+), 186 deletions(-) diff --git a/examples/fine-tuned-RAG/ModelFinetune.ipynb b/examples/fine-tuned-RAG/ModelFinetune.ipynb index 0f810efd83..f77fbc2209 100644 --- a/examples/fine-tuned-RAG/ModelFinetune.ipynb +++ b/examples/fine-tuned-RAG/ModelFinetune.ipynb @@ -5,11 +5,9 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Finetuning for RAG\n", + "# Fine-Tuning OpenAI Models for Retrieval Augmented Generation (RAG) with Qdrant and Few-Shot Learning\n", "\n", - "\n", - "\n", - "Intent: Show how to fine-tune OpenAI models for RAG and improve them using Qdrant and Few-Shot Learning! 🤩\n", + "The aim of this blog is to walk through a comprehensive example of how to fine-tune OpenAI models for Retrieval Augmented Generation (RAG). We will also be integrating Qdrant and Few-Shot Learning to boost the model's performance and reduce hallucinations. This could serve as a practical guide for ML practitioners, data scientists, and researchers interested in leveraging the power of OpenAI models for specific use-cases. 🤩\n", "\n", "To begin, we've selected a dataset where we've a guarantee that the retrieval is perfect. We've selected a subset of the [SQuAD](https://rajpurkar.github.io/SQuAD-explorer/) dataset, which is a collection of questions and answers about Wikipedia articles. We've also included samples where the answer is not present in the context, to demonstrate how RAG handles this case.\n", "\n", @@ -28,7 +26,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Setting Up\n", + "## 1. Setting Up\n", "\n", "### Install and Import Dependencies" ] @@ -77,7 +75,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Data Preparation: SQuADv2 Data Subsets\n", + "## 2.Data Preparation: SQuADv2 Data Subsets\n", "\n", "For the purpose of demonstration, we'll make small slices from the train and validation splits of the [SQuADv2](https://rajpurkar.github.io/SQuAD-explorer/) dataset. This dataset has questions and contexts where the answer is not present in the context, to help us evaluate how LLM handles this case.\n", "\n", @@ -1502,193 +1500,65 @@ "metadata": {}, "outputs": [], "source": [ - "# Create OpenAI File\n", - "file_object = openai.File.create(\n", - " file=open(\"local_cache/100_train_few_shot.jsonl\", \"r\"),\n", - " purpose=\"fine-tune\",\n", - ")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "💡 Wait: The file object status needs to change to \"processed\" before we can start our fine tuning job. " - ] - }, - { - "cell_type": "code", - "execution_count": 92, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "uploaded\n", - "uploaded\n", - "uploaded\n", - "uploaded\n", - "uploaded\n", - "uploaded\n", - "uploaded\n", - "uploaded\n", - "uploaded\n", - "uploaded\n", - "uploaded\n", - "uploaded\n", - "uploaded\n", - "uploaded\n", - "uploaded\n", - "uploaded\n", - "uploaded\n", - "uploaded\n", - "uploaded\n", - "uploaded\n", - "uploaded\n", - "uploaded\n", - "uploaded\n", - "uploaded\n", - "uploaded\n", - "uploaded\n", - "uploaded\n", - "uploaded\n", - "uploaded\n", - "uploaded\n", - "uploaded\n", - "uploaded\n", - "uploaded\n", - "uploaded\n", - "uploaded\n", - "uploaded\n", - "uploaded\n", - "uploaded\n", - "uploaded\n", - "uploaded\n", - "uploaded\n", - "uploaded\n", - "uploaded\n", - "uploaded\n", - "uploaded\n", - "uploaded\n", - "uploaded\n", - "uploaded\n", - "uploaded\n", - "uploaded\n", - "uploaded\n", - "uploaded\n", - "uploaded\n", - "uploaded\n", - "uploaded\n", - "uploaded\n", - "uploaded\n", - "uploaded\n", - "uploaded\n", - "uploaded\n", - "uploaded\n", - "uploaded\n", - "uploaded\n", - "uploaded\n", - "uploaded\n", - "uploaded\n", - "uploaded\n", - "uploaded\n", - "uploaded\n", - "uploaded\n", - "uploaded\n", - "uploaded\n", - "uploaded\n", - "uploaded\n", - "processed\n" - ] - } - ], - "source": [ - "while file_object.status!='processed':\n", - " time.sleep(20)\n", - " file_object.refresh()\n", - " print(file_object.status)" + "class OpenAIFineTuner:\n", + " def __init__(self, training_file_path, model_name, suffix):\n", + " self.training_file_path = training_file_path\n", + " self.model_name = model_name\n", + " self.suffix = suffix\n", + " self.file_object = None\n", + " self.fine_tuning_job = None\n", + " self.model_id = None\n", + "\n", + " def create_openai_file(self):\n", + " self.file_object = openai.File.create(\n", + " file=open(self.training_file_path, \"r\"),\n", + " purpose=\"fine-tune\",\n", + " )\n", + "\n", + " def wait_for_file_processing(self, sleep_time=20):\n", + " while self.file_object.status != 'processed':\n", + " time.sleep(sleep_time)\n", + " self.file_object.refresh()\n", + " print(\"File Status: \", self.file_object.status)\n", + "\n", + " def create_fine_tuning_job(self):\n", + " self.fine_tuning_job = openai.FineTuningJob.create(\n", + " training_file=self.file_object[\"id\"],\n", + " model=self.model_name,\n", + " suffix=self.suffix,\n", + " )\n", + "\n", + " def wait_for_fine_tuning(self, sleep_time=45):\n", + " while self.fine_tuning_job.status != 'succeeded':\n", + " time.sleep(sleep_time)\n", + " self.fine_tuning_job.refresh()\n", + " print(\"Job Status: \", self.fine_tuning_job.status)\n", + "\n", + " def retrieve_fine_tuned_model(self):\n", + " self.model_id = openai.FineTuningJob.retrieve(self.fine_tuning_job[\"id\"]).fine_tuned_model\n", + " return self.model_id\n", + "\n", + " def fine_tune_model(self):\n", + " self.create_openai_file()\n", + " self.wait_for_file_processing()\n", + " self.create_fine_tuning_job()\n", + " self.wait_for_fine_tuning()\n", + " return self.retrieve_fine_tuned_model()" ] }, { "cell_type": "code", - "execution_count": 93, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ - "# Finetuning job\n", - "ft_job = openai.FineTuningJob.create(\n", - " training_file=file_object[\"id\"], model=\"gpt-3.5-turbo\", suffix=\"trnfewshot20230907\"\n", - ")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "💡 Wait: We've to wait till the fine-tuning job is complete i.e. status changes to \"succeeded\" before we can use the fine-tuned model." - ] - }, - { - "cell_type": "code", - "execution_count": 94, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Status: created\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: succeeded\n" - ] - } - ], - "source": [ - "while ft_job.status!='succeeded':\n", - " ft_job.refresh()\n", - " print(\"Status: \", ft_job.status)\n", - " time.sleep(45)" - ] - }, - { - "cell_type": "code", - "execution_count": 95, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "'ft:gpt-3.5-turbo-0613:qdrant:trnfewshot20230907:7w6Gapu0'" - ] - }, - "execution_count": 95, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "model_id = openai.FineTuningJob.retrieve(ft_job[\"id\"]).fine_tuned_model\n", + "fine_tuner = OpenAIFineTuner(\n", + " training_file_path=\"local_cache/100_train_few_shot.jsonl\",\n", + " model_name=\"gpt-3.5-turbo\",\n", + " suffix=\"trnfewshot20230907\"\n", + " )\n", + "\n", + "model_id = fine_tuner.fine_tune_model()\n", "model_id" ] }, From 3fc4256ff41f1848cff342013c536a0c2c97bc6a Mon Sep 17 00:00:00 2001 From: NirantK Date: Thu, 7 Sep 2023 16:48:12 +0530 Subject: [PATCH 18/38] Reorganise --- examples/fine-tuned-RAG/ModelFinetune.ipynb | 883 ++++---------------- 1 file changed, 185 insertions(+), 698 deletions(-) diff --git a/examples/fine-tuned-RAG/ModelFinetune.ipynb b/examples/fine-tuned-RAG/ModelFinetune.ipynb index f77fbc2209..4f412c7cbd 100644 --- a/examples/fine-tuned-RAG/ModelFinetune.ipynb +++ b/examples/fine-tuned-RAG/ModelFinetune.ipynb @@ -13,11 +13,15 @@ "\n", "## Table of Contents\n", "1. Setting up the Environment\n", + "\n", + "### Section A: Zero-Shot Learning\n", "2. Data Preparation\n", "3. OpenAI Model Fine-Tuning\n", - "4. Evaluation with OpenAI\n", + "4. Baseline Results\n", + "\n", + "### Section B: Few-Shot Learning\n", "5. Using Qdrant to Improve RAG Prompt\n", - "6. Few-Shot Learning with Qdrant\n", + "6. Fine-Tuning OpenAI Model with Qdrant\n", "7. Comparison and Results" ] }, @@ -37,12 +41,12 @@ "metadata": {}, "outputs": [], "source": [ - "# !pip install pandas openai tqdm tenacity pandarallel scikit-learn tiktoken python-dotenv" + "# !pip install pandas openai tqdm tenacity matplotlib scikit-learn tiktoken python-dotenv " ] }, { "cell_type": "code", - "execution_count": 99, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -57,13 +61,17 @@ "from tqdm import tqdm\n", "from collections import defaultdict\n", "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "from sklearn.metrics import confusion_matrix\n", + "\n", "\n", "tqdm.pandas()" ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -75,7 +83,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## 2.Data Preparation: SQuADv2 Data Subsets\n", + "## 2. Data Preparation: SQuADv2 Data Subsets\n", "\n", "For the purpose of demonstration, we'll make small slices from the train and validation splits of the [SQuADv2](https://rajpurkar.github.io/SQuAD-explorer/) dataset. This dataset has questions and contexts where the answer is not present in the context, to help us evaluate how LLM handles this case.\n", "\n", @@ -86,7 +94,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -99,12 +107,12 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## JSON to DataFrame" + "## Read JSON to DataFrame" ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ @@ -153,15 +161,14 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Using the OpenAI Model for Question Answering\n", + "## Setting up Baseline Model Performance\n", "\n", - "### Prompt, API Call, and Answer\n", - "Create functions to get prompt messages and make API calls:" + "### Utility Functions: Zero Shot Prompt, API Call to OpenAI" ] }, { "cell_type": "code", - "execution_count": 57, + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ @@ -198,14 +205,6 @@ " return response[\"choices\"][0][\"message\"][\"content\"]" ] }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Running the model" - ] - }, { "cell_type": "code", "execution_count": 7, @@ -215,7 +214,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 100/100 [02:53<00:00, 1.73s/it]\n" + " 25%|██▌ | 25/100 [00:33<01:35, 1.28s/it]" ] } ], @@ -226,7 +225,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -234,108 +233,6 @@ ] }, { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Evaluation\n", - "\n", - "To evaluate the model's performance, compare the predicted answer to the actual answers -- if any of the actual answers are present in the predicted answer, then it's a match. We've also created error categories to help you understand where the model is struggling.\n", - "\n", - "1. Expected and Right: The model responsded the correct answer. It may have also included other answers that were not in the context.\n", - "2. Expected but \"IDK\": The model responded with \"I don't know\" (IDK) while the answer was present in the context. *This is a model error* and better than giving the wrong answer. We exclude this from the overall error rate.\n", - "3. Expected but Wrong: The model responded with an incorrect answer. *This is a model ERROR.*\n", - "4. Hallucination: The model responded with an answer, when \"I don't know\" was expected. **This is a model error.** \n", - "5. Did not expect and IDK: The model responded with \"I don't know\" (IDK) and the answer was not present in the context. *This is a model WIN.*" - ] - }, - { - "cell_type": "code", - "execution_count": 61, - "metadata": {}, - "outputs": [ - { - "ename": "KeyError", - "evalue": "'generated_answer'", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mKeyError\u001b[0m Traceback (most recent call last)", - "File \u001b[0;32m/opt/homebrew/Caskroom/miniconda/base/envs/fst/lib/python3.9/site-packages/pandas/core/indexes/base.py:3653\u001b[0m, in \u001b[0;36mIndex.get_loc\u001b[0;34m(self, key)\u001b[0m\n\u001b[1;32m 3652\u001b[0m \u001b[39mtry\u001b[39;00m:\n\u001b[0;32m-> 3653\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_engine\u001b[39m.\u001b[39;49mget_loc(casted_key)\n\u001b[1;32m 3654\u001b[0m \u001b[39mexcept\u001b[39;00m \u001b[39mKeyError\u001b[39;00m \u001b[39mas\u001b[39;00m err:\n", - "File \u001b[0;32m/opt/homebrew/Caskroom/miniconda/base/envs/fst/lib/python3.9/site-packages/pandas/_libs/index.pyx:147\u001b[0m, in \u001b[0;36mpandas._libs.index.IndexEngine.get_loc\u001b[0;34m()\u001b[0m\n", - "File \u001b[0;32m/opt/homebrew/Caskroom/miniconda/base/envs/fst/lib/python3.9/site-packages/pandas/_libs/index.pyx:176\u001b[0m, in \u001b[0;36mpandas._libs.index.IndexEngine.get_loc\u001b[0;34m()\u001b[0m\n", - "File \u001b[0;32mpandas/_libs/hashtable_class_helper.pxi:7080\u001b[0m, in \u001b[0;36mpandas._libs.hashtable.PyObjectHashTable.get_item\u001b[0;34m()\u001b[0m\n", - "File \u001b[0;32mpandas/_libs/hashtable_class_helper.pxi:7088\u001b[0m, in \u001b[0;36mpandas._libs.hashtable.PyObjectHashTable.get_item\u001b[0;34m()\u001b[0m\n", - "\u001b[0;31mKeyError\u001b[0m: 'generated_answer'", - "\nThe above exception was the direct cause of the following exception:\n", - "\u001b[0;31mKeyError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[61], line 46\u001b[0m\n\u001b[1;32m 42\u001b[0m \u001b[39mreturn\u001b[39;00m freq_series\n\u001b[1;32m 45\u001b[0m evaluator \u001b[39m=\u001b[39m ConfusionMatrixEvaluator(df, answers_column\u001b[39m=\u001b[39m\u001b[39m\"\u001b[39m\u001b[39mgenerated_answer\u001b[39m\u001b[39m\"\u001b[39m)\n\u001b[0;32m---> 46\u001b[0m evaluator\u001b[39m.\u001b[39;49mevaluate_answers()\n\u001b[1;32m 47\u001b[0m error_categories \u001b[39m=\u001b[39m evaluator\u001b[39m.\u001b[39mgenerate_matrices(use_percentages\u001b[39m=\u001b[39m\u001b[39mTrue\u001b[39;00m)\n\u001b[1;32m 48\u001b[0m error_categories\n", - "Cell \u001b[0;32mIn[61], line 34\u001b[0m, in \u001b[0;36mConfusionMatrixEvaluator.evaluate_answers\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 33\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mevaluate_answers\u001b[39m(\u001b[39mself\u001b[39m):\n\u001b[0;32m---> 34\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39my_pred \u001b[39m=\u001b[39m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mdf\u001b[39m.\u001b[39;49mapply(\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_evaluate_single_row, axis\u001b[39m=\u001b[39;49m\u001b[39m1\u001b[39;49m)\n", - "File \u001b[0;32m/opt/homebrew/Caskroom/miniconda/base/envs/fst/lib/python3.9/site-packages/pandas/core/frame.py:9423\u001b[0m, in \u001b[0;36mDataFrame.apply\u001b[0;34m(self, func, axis, raw, result_type, args, **kwargs)\u001b[0m\n\u001b[1;32m 9412\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39mpandas\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mcore\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mapply\u001b[39;00m \u001b[39mimport\u001b[39;00m frame_apply\n\u001b[1;32m 9414\u001b[0m op \u001b[39m=\u001b[39m frame_apply(\n\u001b[1;32m 9415\u001b[0m \u001b[39mself\u001b[39m,\n\u001b[1;32m 9416\u001b[0m func\u001b[39m=\u001b[39mfunc,\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 9421\u001b[0m kwargs\u001b[39m=\u001b[39mkwargs,\n\u001b[1;32m 9422\u001b[0m )\n\u001b[0;32m-> 9423\u001b[0m \u001b[39mreturn\u001b[39;00m op\u001b[39m.\u001b[39;49mapply()\u001b[39m.\u001b[39m__finalize__(\u001b[39mself\u001b[39m, method\u001b[39m=\u001b[39m\u001b[39m\"\u001b[39m\u001b[39mapply\u001b[39m\u001b[39m\"\u001b[39m)\n", - "File \u001b[0;32m/opt/homebrew/Caskroom/miniconda/base/envs/fst/lib/python3.9/site-packages/pandas/core/apply.py:678\u001b[0m, in \u001b[0;36mFrameApply.apply\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 675\u001b[0m \u001b[39melif\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mraw:\n\u001b[1;32m 676\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mapply_raw()\n\u001b[0;32m--> 678\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mapply_standard()\n", - "File \u001b[0;32m/opt/homebrew/Caskroom/miniconda/base/envs/fst/lib/python3.9/site-packages/pandas/core/apply.py:798\u001b[0m, in \u001b[0;36mFrameApply.apply_standard\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 797\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mapply_standard\u001b[39m(\u001b[39mself\u001b[39m):\n\u001b[0;32m--> 798\u001b[0m results, res_index \u001b[39m=\u001b[39m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mapply_series_generator()\n\u001b[1;32m 800\u001b[0m \u001b[39m# wrap results\u001b[39;00m\n\u001b[1;32m 801\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mwrap_results(results, res_index)\n", - "File \u001b[0;32m/opt/homebrew/Caskroom/miniconda/base/envs/fst/lib/python3.9/site-packages/pandas/core/apply.py:814\u001b[0m, in \u001b[0;36mFrameApply.apply_series_generator\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 811\u001b[0m \u001b[39mwith\u001b[39;00m option_context(\u001b[39m\"\u001b[39m\u001b[39mmode.chained_assignment\u001b[39m\u001b[39m\"\u001b[39m, \u001b[39mNone\u001b[39;00m):\n\u001b[1;32m 812\u001b[0m \u001b[39mfor\u001b[39;00m i, v \u001b[39min\u001b[39;00m \u001b[39menumerate\u001b[39m(series_gen):\n\u001b[1;32m 813\u001b[0m \u001b[39m# ignore SettingWithCopy here in case the user mutates\u001b[39;00m\n\u001b[0;32m--> 814\u001b[0m results[i] \u001b[39m=\u001b[39m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mf(v)\n\u001b[1;32m 815\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39misinstance\u001b[39m(results[i], ABCSeries):\n\u001b[1;32m 816\u001b[0m \u001b[39m# If we have a view on v, we need to make a copy because\u001b[39;00m\n\u001b[1;32m 817\u001b[0m \u001b[39m# series_generator will swap out the underlying data\u001b[39;00m\n\u001b[1;32m 818\u001b[0m results[i] \u001b[39m=\u001b[39m results[i]\u001b[39m.\u001b[39mcopy(deep\u001b[39m=\u001b[39m\u001b[39mFalse\u001b[39;00m)\n", - "Cell \u001b[0;32mIn[61], line 16\u001b[0m, in \u001b[0;36mConfusionMatrixEvaluator._evaluate_single_row\u001b[0;34m(self, row)\u001b[0m\n\u001b[1;32m 14\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39m_evaluate_single_row\u001b[39m(\u001b[39mself\u001b[39m, row):\n\u001b[1;32m 15\u001b[0m is_impossible \u001b[39m=\u001b[39m row[\u001b[39m\"\u001b[39m\u001b[39mis_impossible\u001b[39m\u001b[39m\"\u001b[39m]\n\u001b[0;32m---> 16\u001b[0m generated_answer \u001b[39m=\u001b[39m row[\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49manswers_column]\u001b[39m.\u001b[39mlower()\n\u001b[1;32m 17\u001b[0m actual_answers \u001b[39m=\u001b[39m [ans\u001b[39m.\u001b[39mlower() \u001b[39mfor\u001b[39;00m ans \u001b[39min\u001b[39;00m row[\u001b[39m\"\u001b[39m\u001b[39manswers\u001b[39m\u001b[39m\"\u001b[39m]]\n\u001b[1;32m 19\u001b[0m y_pred \u001b[39m=\u001b[39m (\n\u001b[1;32m 20\u001b[0m \u001b[39m\"\u001b[39m\u001b[39mExpected and Right\u001b[39m\u001b[39m\"\u001b[39m\n\u001b[1;32m 21\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mnot\u001b[39;00m is_impossible\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 29\u001b[0m \u001b[39melse\u001b[39;00m \u001b[39m\"\u001b[39m\u001b[39mDid not Expect and IDK\u001b[39m\u001b[39m\"\u001b[39m\n\u001b[1;32m 30\u001b[0m )\n", - "File \u001b[0;32m/opt/homebrew/Caskroom/miniconda/base/envs/fst/lib/python3.9/site-packages/pandas/core/series.py:1007\u001b[0m, in \u001b[0;36mSeries.__getitem__\u001b[0;34m(self, key)\u001b[0m\n\u001b[1;32m 1004\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_values[key]\n\u001b[1;32m 1006\u001b[0m \u001b[39melif\u001b[39;00m key_is_scalar:\n\u001b[0;32m-> 1007\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_get_value(key)\n\u001b[1;32m 1009\u001b[0m \u001b[39mif\u001b[39;00m is_hashable(key):\n\u001b[1;32m 1010\u001b[0m \u001b[39m# Otherwise index.get_value will raise InvalidIndexError\u001b[39;00m\n\u001b[1;32m 1011\u001b[0m \u001b[39mtry\u001b[39;00m:\n\u001b[1;32m 1012\u001b[0m \u001b[39m# For labels that don't resolve as scalars like tuples and frozensets\u001b[39;00m\n", - "File \u001b[0;32m/opt/homebrew/Caskroom/miniconda/base/envs/fst/lib/python3.9/site-packages/pandas/core/series.py:1116\u001b[0m, in \u001b[0;36mSeries._get_value\u001b[0;34m(self, label, takeable)\u001b[0m\n\u001b[1;32m 1113\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_values[label]\n\u001b[1;32m 1115\u001b[0m \u001b[39m# Similar to Index.get_value, but we do not fall back to positional\u001b[39;00m\n\u001b[0;32m-> 1116\u001b[0m loc \u001b[39m=\u001b[39m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mindex\u001b[39m.\u001b[39;49mget_loc(label)\n\u001b[1;32m 1118\u001b[0m \u001b[39mif\u001b[39;00m is_integer(loc):\n\u001b[1;32m 1119\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_values[loc]\n", - "File \u001b[0;32m/opt/homebrew/Caskroom/miniconda/base/envs/fst/lib/python3.9/site-packages/pandas/core/indexes/base.py:3655\u001b[0m, in \u001b[0;36mIndex.get_loc\u001b[0;34m(self, key)\u001b[0m\n\u001b[1;32m 3653\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_engine\u001b[39m.\u001b[39mget_loc(casted_key)\n\u001b[1;32m 3654\u001b[0m \u001b[39mexcept\u001b[39;00m \u001b[39mKeyError\u001b[39;00m \u001b[39mas\u001b[39;00m err:\n\u001b[0;32m-> 3655\u001b[0m \u001b[39mraise\u001b[39;00m \u001b[39mKeyError\u001b[39;00m(key) \u001b[39mfrom\u001b[39;00m \u001b[39merr\u001b[39;00m\n\u001b[1;32m 3656\u001b[0m \u001b[39mexcept\u001b[39;00m \u001b[39mTypeError\u001b[39;00m:\n\u001b[1;32m 3657\u001b[0m \u001b[39m# If we have a listlike key, _check_indexing_error will raise\u001b[39;00m\n\u001b[1;32m 3658\u001b[0m \u001b[39m# InvalidIndexError. Otherwise we fall through and re-raise\u001b[39;00m\n\u001b[1;32m 3659\u001b[0m \u001b[39m# the TypeError.\u001b[39;00m\n\u001b[1;32m 3660\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_check_indexing_error(key)\n", - "\u001b[0;31mKeyError\u001b[0m: 'generated_answer'" - ] - } - ], - "source": [ - "class ConfusionMatrixEvaluator:\n", - " def __init__(self, df, answers_column=\"generated_answer\"):\n", - " self.df = df\n", - " self.y_pred = []\n", - " self.labels = [\n", - " \"Expected and Right\",\n", - " \"Expected but IDK\",\n", - " \"Expected but Wrong\",\n", - " \"Hallucination\",\n", - " \"Did not Expect and IDK\",\n", - " ]\n", - " self.answers_column = answers_column\n", - "\n", - " def _evaluate_single_row(self, row):\n", - " is_impossible = row[\"is_impossible\"]\n", - " generated_answer = row[self.answers_column].lower()\n", - " actual_answers = [ans.lower() for ans in row[\"answers\"]]\n", - "\n", - " y_pred = (\n", - " \"Expected and Right\"\n", - " if not is_impossible\n", - " and any(ans in generated_answer for ans in actual_answers)\n", - " else \"Expected but IDK\"\n", - " if not is_impossible and generated_answer == \"i don't know\"\n", - " else \"Expected but Wrong\"\n", - " if not is_impossible and generated_answer not in actual_answers\n", - " else \"Hallucination\"\n", - " if is_impossible and generated_answer != \"i don't know\"\n", - " else \"Did not Expect and IDK\"\n", - " )\n", - " return y_pred\n", - "\n", - " def evaluate_answers(self):\n", - " self.y_pred = self.df.apply(self._evaluate_single_row, axis=1)\n", - "\n", - " def generate_matrices(self, use_percentages=False):\n", - " # Using value_counts to create a Series of frequencies, then reindexing to include missing labels with count 0\n", - " freq_series = self.y_pred.value_counts().reindex(self.labels, fill_value=0)\n", - " if use_percentages:\n", - " total = freq_series.sum()\n", - " freq_series = (freq_series / total * 100).apply(\"{0:.2f}%\".format)\n", - " return freq_series\n", - "\n", - "\n", - "evaluator = ConfusionMatrixEvaluator(df, answers_column=\"generated_answer\")\n", - "evaluator.evaluate_answers()\n", - "error_categories = evaluator.generate_matrices(use_percentages=True)\n", - "error_categories" - ] - }, - { - "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -350,21 +247,9 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "ename": "NameError", - "evalue": "name 'get_diverse_sample' 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[2], line 20\u001b[0m\n\u001b[1;32m 17\u001b[0m jsonl_output \u001b[39m=\u001b[39m df\u001b[39m.\u001b[39mprogress_apply(create_jsonl_entry, axis\u001b[39m=\u001b[39m\u001b[39m1\u001b[39m)\n\u001b[1;32m 18\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39m\"\u001b[39m\u001b[39m\\n\u001b[39;00m\u001b[39m\"\u001b[39m\u001b[39m.\u001b[39mjoin(jsonl_output)\n\u001b[0;32m---> 20\u001b[0m train_sample \u001b[39m=\u001b[39m get_diverse_sample(train_df, sample_size\u001b[39m=\u001b[39m\u001b[39m100\u001b[39m, random_state\u001b[39m=\u001b[39m\u001b[39m42\u001b[39m)\n\u001b[1;32m 22\u001b[0m \u001b[39mwith\u001b[39;00m \u001b[39mopen\u001b[39m(\u001b[39m\"\u001b[39m\u001b[39mlocal_cache/100_train.jsonl\u001b[39m\u001b[39m\"\u001b[39m, \u001b[39m\"\u001b[39m\u001b[39mw\u001b[39m\u001b[39m\"\u001b[39m) \u001b[39mas\u001b[39;00m f:\n\u001b[1;32m 23\u001b[0m f\u001b[39m.\u001b[39mwrite(dataframe_to_jsonl(train_sample))\n", - "\u001b[0;31mNameError\u001b[0m: name 'get_diverse_sample' is not defined" - ] - } - ], + "outputs": [], "source": [ "def dataframe_to_jsonl(df):\n", " def create_jsonl_entry(row):\n", @@ -392,7 +277,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -403,45 +287,9 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Num examples: 100\n", - "First example:\n", - "{'role': 'system', 'content': 'You are a helpful assistant.'}\n", - "{'role': 'user', 'content': \"Answer the following Question based on the Context only. Only answer from the Context. If you don't know the answer, say 'I don't know'.\\n Question: What is a cirque?\\n\\n\\n Context: Glaciers form where the accumulation of snow and ice exceeds ablation. The area in which a glacier forms is called a cirque (corrie or cwm) - a typically armchair-shaped geological feature (such as a depression between mountains enclosed by arêtes) - which collects and compresses through gravity the snow which falls into it. This snow collects and is compacted by the weight of the snow falling above it forming névé. Further crushing of the individual snowflakes and squeezing the air from the snow turns it into 'glacial ice'. This glacial ice will fill the cirque until it 'overflows' through a geological weakness or vacancy, such as the gap between two mountains. When the mass of snow and ice is sufficiently thick, it begins to move due to a combination of surface slope, gravity and pressure. On steeper slopes, this can occur with as little as 15 m (50 ft) of snow-ice.\\n\\n\\n Answer:\\n\"}\n", - "{'role': 'assistant', 'content': 'The area in which a glacier forms'}\n", - "No errors found\n", - "Num examples missing system message: 0\n", - "Num examples missing user message: 0\n", - "\n", - "#### Distribution of num_messages_per_example:\n", - "min / max: 3, 3\n", - "mean / median: 3.0, 3.0\n", - "p5 / p95: 3.0, 3.0\n", - "\n", - "#### Distribution of num_total_tokens_per_example:\n", - "min / max: 114, 689\n", - "mean / median: 236.88, 217.0\n", - "p5 / p95: 166.7, 321.3\n", - "\n", - "#### Distribution of num_assistant_tokens_per_example:\n", - "min / max: 1, 13\n", - "mean / median: 3.81, 4.0\n", - "p5 / p95: 1.0, 5.0\n", - "\n", - "0 examples may be over the 4096 token limit, they will be truncated during fine-tuning\n", - "Dataset has ~23688 tokens that will be charged for during training\n", - "By default, you'll train for 3 epochs on this dataset\n", - "By default, you'll be charged for ~71064 tokens\n", - "See pricing page to estimate total costs\n" - ] - } - ], + "outputs": [], "source": [ "# Specify the data path and open the JSONL file\n", "\n", @@ -580,16 +428,15 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ - "### Upload the Fine-Tuning data to OpenAI" + "### Upload the Fine-Tuning Data to OpenAI" ] }, { "cell_type": "code", - "execution_count": 50, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -599,31 +446,18 @@ ")" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "💡 Wait: For file to be uploaded and then processed by OpenAI." + ] + }, { "cell_type": "code", - "execution_count": 51, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - " JSON: {\n", - " \"object\": \"file\",\n", - " \"id\": \"file-iuSjUY6kK84A1cOB9QffTxfD\",\n", - " \"purpose\": \"fine-tune\",\n", - " \"filename\": \"file\",\n", - " \"bytes\": 120415,\n", - " \"created_at\": 1694012894,\n", - " \"status\": \"processed\",\n", - " \"status_details\": null\n", - "}" - ] - }, - "execution_count": 51, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "while file_object.status!='processed':\n", " time.sleep(5)\n", @@ -632,16 +466,15 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ - "### Create Fine Tuning Job" + "### Create a Fine Tuning Job" ] }, { "cell_type": "code", - "execution_count": 52, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -650,70 +483,18 @@ ")" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "💡 Wait: For the fine-tuning job to complete and status to be \"succeeded\"." + ] + }, { "cell_type": "code", - "execution_count": 58, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: succeeded\n" - ] - } - ], + "outputs": [], "source": [ "while ft_job.status!='succeeded':\n", " time.sleep(15)\n", @@ -723,27 +504,15 @@ }, { "cell_type": "code", - "execution_count": 63, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "'ft:gpt-3.5-turbo-0613:qdrant:100train20230906:7vp2AzMY'" - ] - }, - "execution_count": 63, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "model_id = openai.FineTuningJob.retrieve(ft_job[\"id\"]).fine_tuned_model\n", "model_id" ] }, { - "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ @@ -752,20 +521,9 @@ }, { "cell_type": "code", - "execution_count": 60, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{\n", - " \"role\": \"assistant\",\n", - " \"content\": \"I don't know\"\n", - "}\n" - ] - } - ], + "outputs": [], "source": [ "completion = openai.ChatCompletion.create(\n", " model=model_id,\n", @@ -784,70 +542,118 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ - "## Comparison\n", - "\n", - "### Get Answers from the Fine-Tuned Model" + "### Using the Fine-Tuned Model" ] }, { "cell_type": "code", - "execution_count": 61, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 100/100 [05:16<00:00, 3.17s/it]\n" - ] - } - ], + "outputs": [], "source": [ "df[\"ft_generated_answer\"] = df.progress_apply(answer_question, model=model_id, axis=1)" ] }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Evaluate Baseline Model Performance\n", + "\n", + "To evaluate the model's performance, compare the predicted answer to the actual answers -- if any of the actual answers are present in the predicted answer, then it's a match. We've also created error categories to help you understand where the model is struggling.\n", + "\n", + "1. Expected and Right: The model responsded the correct answer. It may have also included other answers that were not in the context.\n", + "2. Expected but \"IDK\": The model responded with \"I don't know\" (IDK) while the answer was present in the context. *This is a model error* and better than giving the wrong answer. We exclude this from the overall error rate.\n", + "3. Expected but Wrong: The model responded with an incorrect answer. *This is a model ERROR.*\n", + "4. Hallucination: The model responded with an answer, when \"I don't know\" was expected. **This is a model error.** \n", + "5. Did not expect and IDK: The model responded with \"I don't know\" (IDK) and the answer was not present in the context. *This is a model WIN.*" + ] + }, { "cell_type": "code", - "execution_count": 62, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Expected and Right 30.00%\n", - "Expected but IDK 21.00%\n", - "Expected but Wrong 2.00%\n", - "Hallucination 5.00%\n", - "Did not Expect and IDK 42.00%\n", - "Name: count, dtype: object" - ] - }, - "execution_count": 62, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ - "# Initialize the evaluator\n", - "finetuned_model_evaluator = ConfusionMatrixEvaluator(\n", - " df, answers_column=\"ft_generated_answer\"\n", - ")\n", + "class ConfusionMatrixEvaluator:\n", + " def __init__(self, df, answers_column=\"generated_answer\"):\n", + " self.df = df\n", + " self.y_pred = []\n", + " self.labels = [\n", + " \"Expected and Right\",\n", + " \"Expected but IDK\",\n", + " \"Expected but Wrong\",\n", + " \"Hallucination\",\n", + " \"Did not Expect and IDK\",\n", + " ]\n", + " self.answers_column = answers_column\n", "\n", - "# Run the evaluation\n", - "finetuned_model_evaluator.evaluate_answers()\n", - "finetuned_model_error_categories = finetuned_model_evaluator.generate_matrices(\n", - " use_percentages=True\n", - ")\n", - "finetuned_model_error_categories" + " def _evaluate_single_row(self, row):\n", + " is_impossible = row[\"is_impossible\"]\n", + " generated_answer = row[self.answers_column].lower()\n", + " actual_answers = [ans.lower() for ans in row[\"answers\"]]\n", + "\n", + " y_pred = (\n", + " \"Expected and Right\"\n", + " if not is_impossible\n", + " and any(ans in generated_answer for ans in actual_answers)\n", + " else \"Expected but IDK\"\n", + " if not is_impossible and generated_answer == \"i don't know\"\n", + " else \"Expected but Wrong\"\n", + " if not is_impossible and generated_answer not in actual_answers\n", + " else \"Hallucination\"\n", + " if is_impossible and generated_answer != \"i don't know\"\n", + " else \"Did not Expect and IDK\"\n", + " )\n", + " return y_pred\n", + "\n", + " def evaluate_answers(self):\n", + " self.y_pred = self.df.apply(self._evaluate_single_row, axis=1)\n", + "\n", + " def generate_matrices(self, use_percentages=False):\n", + " # Using value_counts to create a Series of frequencies, then reindexing to include missing labels with count 0\n", + " freq_series = self.y_pred.value_counts().reindex(self.labels, fill_value=0)\n", + " if use_percentages:\n", + " total = freq_series.sum()\n", + " freq_series = (freq_series / total * 100).apply(\"{0:.2f}%\".format)\n", + " return freq_series\n", + "\n", + "\n", + "def evaluate_model(df, answers_column):\n", + " \"\"\"\n", + " Evaluate the confusion matrix for a given DataFrame and answer column.\n", + " \"\"\"\n", + " evaluator = ConfusionMatrixEvaluator(df, answers_column=answers_column)\n", + " evaluator.evaluate_answers()\n", + " error_categories = evaluator.generate_matrices(use_percentages=True)\n", + " return error_categories" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "evaluate_model(df, \"generated_answer\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "evaluate_model(df, \"ft_generated_answer\")" ] }, { "cell_type": "code", - "execution_count": 64, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -865,62 +671,27 @@ }, { "cell_type": "code", - "execution_count": 65, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ - "# Importing required libraries for plotting\n", - "import matplotlib.pyplot as plt\n", - "import numpy as np\n", - "\n", - "\n", - "def evaluate_matrix(df, answers_column):\n", - " \"\"\"\n", - " Evaluate the confusion matrix for a given DataFrame and answer column.\n", - " \"\"\"\n", - " evaluator = ConfusionMatrixEvaluator(df, answers_column=answers_column)\n", - " evaluator.evaluate_answers()\n", - " matrix = evaluator.generate_matrices(use_percentages=True)\n", - " return matrix\n", - "\n", - "\n", - "def plot_overall_error(matrix1, matrix2, label1, label2):\n", - " \"\"\"\n", - " Plot a bar chart showing only the overall error between two confusion matrices.\n", - " \"\"\"\n", - " # Calculate overall error\n", + "def plot_overall_error(df, answer_columns):\n", " error_categories = [\"Expected but Wrong\", \"Hallucination\"]\n", - " matrix1_error = sum(\n", - " [float(matrix1.loc[cat].replace(\"%\", \"\")) for cat in error_categories]\n", - " )\n", - " matrix2_error = sum(\n", - " [float(matrix2.loc[cat].replace(\"%\", \"\")) for cat in error_categories]\n", - " )\n", - "\n", " labels = [\"Overall Error\"]\n", - " matrix1_values = [matrix1_error]\n", - " matrix2_values = [matrix2_error]\n", - "\n", " x = np.arange(len(labels))\n", - " width = 0.35\n", + " width = 0.35 / len(answer_columns)\n", "\n", " fig, ax = plt.subplots()\n", - " ax.bar(x - width / 2, matrix1_values, width, label=label1)\n", - " ax.bar(x + width / 2, matrix2_values, width, label=label2)\n", + "\n", + " for i, col in enumerate(answer_columns):\n", + " results = evaluate_model(df, col)\n", + " matrix_error = sum(\n", + " [float(results[col].loc[cat].replace(\"%\", \"\")) for cat in error_categories]\n", + " )\n", + " ax.bar(x + (i - len(answer_columns)/2) * width, [matrix_error], width, label=col)\n", "\n", " ax.set_ylabel(\"Error (%) - Lower is Better\")\n", - " ax.set_title(\"Comparison between {} and {}\".format(label1, label2))\n", + " ax.set_title(\"Overall Error Comparison\")\n", " ax.set_xticks(x)\n", " ax.set_xticklabels(labels)\n", " ax.legend()\n", @@ -928,11 +699,8 @@ " fig.tight_layout()\n", " plt.show()\n", "\n", - "\n", - "matrix_plain = evaluate_matrix(df, \"generated_answer\")\n", - "matrix_ft = evaluate_matrix(df, \"ft_generated_answer\")\n", "# Plot only the overall error\n", - "plot_overall_error(matrix_plain, matrix_ft, \"gpt-3.5-turbo-0613\", \"Fine Tuned\")" + "plot_overall_error(df, answer_columns=[\"generated_answer\", \"ft_generated_answer\"])" ] }, { @@ -940,131 +708,14 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Few Shot Learning with Qdrant to Improve RAG\n", + "# Few Shot Learning\n", "\n", - "So far, we've been using the OpenAI model to answer questions where the answer is present in the context. But what if we want to answer questions where the answer is not present in the context? This is where few-shot learning comes in. Few-shot learning is a type of transfer learning that allows us to answer questions where the answer is not present in the context. We can do this by providing a few examples of the answer we're looking for, and the model will learn to answer questions where the answer is not present in the context." - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Few Shot Prompting\n", "\n", - "We'll select a few examples from the dataset, including cases where the answer is not present in the context. We'll then use these examples to create a prompt that we can use to fine-tune the model.\n", + "We'll select a few examples from the dataset, including cases where the answer is not present in the context. We'll then use these examples to create a prompt that we can use to fine-tune the model. We'll then measure the performance of the fine-tuned model.\n", "\n", - "We'll measure the baseline on our previous 1K dataset, and then we'll fine-tune the model on the new dataset. We'll then measure the performance of the fine-tuned model on the same 1K dataset." - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "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", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
titlequestioncontextis_impossibleanswers
0BeyoncéWhen did Beyonce start becoming popular?Beyoncé Giselle Knowles-Carter (/biːˈjɒnseɪ/ b...False[in the late 1990s]
1BeyoncéWhat areas did Beyonce compete in when she was...Beyoncé Giselle Knowles-Carter (/biːˈjɒnseɪ/ b...False[singing and dancing]
2BeyoncéWhen did Beyonce leave Destiny's Child and bec...Beyoncé Giselle Knowles-Carter (/biːˈjɒnseɪ/ b...False[2003]
3BeyoncéIn what city and state did Beyonce grow up?Beyoncé Giselle Knowles-Carter (/biːˈjɒnseɪ/ b...False[Houston, Texas]
4BeyoncéIn which decade did Beyonce become famous?Beyoncé Giselle Knowles-Carter (/biːˈjɒnseɪ/ b...False[late 1990s]
\n", - "
" - ], - "text/plain": [ - " title question \\\n", - "0 Beyoncé When did Beyonce start becoming popular? \n", - "1 Beyoncé What areas did Beyonce compete in when she was... \n", - "2 Beyoncé When did Beyonce leave Destiny's Child and bec... \n", - "3 Beyoncé In what city and state did Beyonce grow up? \n", - "4 Beyoncé In which decade did Beyonce become famous? \n", - "\n", - " context is_impossible \\\n", - "0 Beyoncé Giselle Knowles-Carter (/biːˈjɒnseɪ/ b... False \n", - "1 Beyoncé Giselle Knowles-Carter (/biːˈjɒnseɪ/ b... False \n", - "2 Beyoncé Giselle Knowles-Carter (/biːˈjɒnseɪ/ b... False \n", - "3 Beyoncé Giselle Knowles-Carter (/biːˈjɒnseɪ/ b... False \n", - "4 Beyoncé Giselle Knowles-Carter (/biːˈjɒnseɪ/ b... False \n", - "\n", - " answers \n", - "0 [in the late 1990s] \n", - "1 [singing and dancing] \n", - "2 [2003] \n", - "3 [Houston, Texas] \n", - "4 [late 1990s] " - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "train_df.head()" + "## 5. Fine-Tuning OpenAI Model with Qdrant\n", + "\n", + "So far, we've been using the OpenAI model to answer questions where the answer is present in the context. But what if we want to answer questions where the answer is not present in the context? This is where few-shot learning comes in. Few-shot learning is a type of transfer learning that allows us to answer questions where the answer is not present in the context. We can do this by providing a few examples of the answer we're looking for, and the model will learn to answer questions where the answer is not present in the context." ] }, { @@ -1079,7 +730,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -1108,7 +759,7 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -1118,7 +769,6 @@ "\n", "# collection_name = \"squadv2-cookbook\"\n", "\n", - "\n", "# # Create the collection\n", "# qdrant_client.recreate_collection(\n", "# collection_name=collection_name,\n", @@ -1128,7 +778,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -1156,38 +806,9 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "994a3daab89c4e64b78caf39bcfee553", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Generating embeddings: 0%| | 0/130319 [00:00 List[PointStruct]:\n", "# batch_size = 512\n", @@ -1249,17 +870,9 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "operation_id=0 status=\n" - ] - } - ], + "outputs": [], "source": [ "# operation_info = qdrant_client.upsert(\n", "# collection_name=collection_name, wait=True, points=points\n", @@ -1267,15 +880,6 @@ "# print(operation_info)" ] }, - { - "cell_type": "code", - "execution_count": 25, - "metadata": {}, - "outputs": [], - "source": [ - "train_sample = get_diverse_sample(train_df, sample_size=100, random_state=42)" - ] - }, { "cell_type": "markdown", "metadata": {}, @@ -1287,24 +891,9 @@ }, { "cell_type": "code", - "execution_count": 87, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "ff39612710a749fdae166745b2bd2d5a", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - " 0%| | 0/100 [00:00 Date: Thu, 7 Sep 2023 18:39:59 +0530 Subject: [PATCH 19/38] =?UTF-8?q?Add=20pretty=20plots=20=E2=9C=A8?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- examples/fine-tuned-RAG/ModelFinetune.ipynb | 554 ++++++++++++++++---- 1 file changed, 461 insertions(+), 93 deletions(-) diff --git a/examples/fine-tuned-RAG/ModelFinetune.ipynb b/examples/fine-tuned-RAG/ModelFinetune.ipynb index 4f412c7cbd..78f2c91a28 100644 --- a/examples/fine-tuned-RAG/ModelFinetune.ipynb +++ b/examples/fine-tuned-RAG/ModelFinetune.ipynb @@ -37,16 +37,16 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 76, "metadata": {}, "outputs": [], "source": [ - "# !pip install pandas openai tqdm tenacity matplotlib scikit-learn tiktoken python-dotenv " + "# !pip install pandas openai tqdm tenacity scikit-learn tiktoken python-dotenv seaborn --upgrade --quiet" ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 78, "metadata": {}, "outputs": [], "source": [ @@ -57,6 +57,7 @@ "import pandas as pd\n", "import openai\n", "import tiktoken\n", + "import seaborn as sns\n", "from tenacity import retry, wait_exponential\n", "from tqdm import tqdm\n", "from collections import defaultdict\n", @@ -214,7 +215,7 @@ "name": "stderr", "output_type": "stream", "text": [ - " 25%|██▌ | 25/100 [00:33<01:35, 1.28s/it]" + "100%|██████████| 100/100 [02:21<00:00, 1.41s/it]\n" ] } ], @@ -225,7 +226,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ @@ -247,9 +248,17 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 100/100 [00:00<00:00, 68067.25it/s]\n" + ] + } + ], "source": [ "def dataframe_to_jsonl(df):\n", " def create_jsonl_entry(row):\n", @@ -287,9 +296,45 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Num examples: 100\n", + "First example:\n", + "{'role': 'system', 'content': 'You are a helpful assistant.'}\n", + "{'role': 'user', 'content': \"Answer the following Question based on the Context only. Only answer from the Context. If you don't know the answer, say 'I don't know'.\\n Question: What is a cirque?\\n\\n\\n Context: Glaciers form where the accumulation of snow and ice exceeds ablation. The area in which a glacier forms is called a cirque (corrie or cwm) - a typically armchair-shaped geological feature (such as a depression between mountains enclosed by arêtes) - which collects and compresses through gravity the snow which falls into it. This snow collects and is compacted by the weight of the snow falling above it forming névé. Further crushing of the individual snowflakes and squeezing the air from the snow turns it into 'glacial ice'. This glacial ice will fill the cirque until it 'overflows' through a geological weakness or vacancy, such as the gap between two mountains. When the mass of snow and ice is sufficiently thick, it begins to move due to a combination of surface slope, gravity and pressure. On steeper slopes, this can occur with as little as 15 m (50 ft) of snow-ice.\\n\\n\\n Answer:\\n\"}\n", + "{'role': 'assistant', 'content': 'The area in which a glacier forms'}\n", + "No errors found\n", + "Num examples missing system message: 0\n", + "Num examples missing user message: 0\n", + "\n", + "#### Distribution of num_messages_per_example:\n", + "min / max: 3, 3\n", + "mean / median: 3.0, 3.0\n", + "p5 / p95: 3.0, 3.0\n", + "\n", + "#### Distribution of num_total_tokens_per_example:\n", + "min / max: 114, 689\n", + "mean / median: 236.88, 217.0\n", + "p5 / p95: 166.7, 321.3\n", + "\n", + "#### Distribution of num_assistant_tokens_per_example:\n", + "min / max: 1, 13\n", + "mean / median: 3.81, 4.0\n", + "p5 / p95: 1.0, 5.0\n", + "\n", + "0 examples may be over the 4096 token limit, they will be truncated during fine-tuning\n", + "Dataset has ~23688 tokens that will be charged for during training\n", + "By default, you'll train for 3 epochs on this dataset\n", + "By default, you'll be charged for ~71064 tokens\n", + "See pricing page to estimate total costs\n" + ] + } + ], "source": [ "# Specify the data path and open the JSONL file\n", "\n", @@ -436,7 +481,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 11, "metadata": {}, "outputs": [], "source": [ @@ -455,9 +500,29 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + " JSON: {\n", + " \"object\": \"file\",\n", + " \"id\": \"file-X0QsHJXqT3DrG1OaXHKMnwXg\",\n", + " \"purpose\": \"fine-tune\",\n", + " \"filename\": \"file\",\n", + " \"bytes\": 120415,\n", + " \"created_at\": 1694085592,\n", + " \"status\": \"processed\",\n", + " \"status_details\": null\n", + "}" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "while file_object.status!='processed':\n", " time.sleep(5)\n", @@ -474,7 +539,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 13, "metadata": {}, "outputs": [], "source": [ @@ -492,9 +557,93 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 14, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Status: running\n", + "Status: running\n", + "Status: running\n", + "Status: running\n", + "Status: running\n", + "Status: running\n", + "Status: running\n", + "Status: running\n", + "Status: running\n", + "Status: running\n", + "Status: running\n", + "Status: running\n", + "Status: running\n", + "Status: running\n", + "Status: running\n", + "Status: running\n", + "Status: running\n", + "Status: running\n", + "Status: running\n", + "Status: running\n", + "Status: running\n", + "Status: running\n", + "Status: running\n", + "Status: running\n", + "Status: running\n", + "Status: running\n", + "Status: running\n", + "Status: running\n", + "Status: running\n", + "Status: running\n", + "Status: running\n", + "Status: running\n", + "Status: running\n", + "Status: running\n", + "Status: running\n", + "Status: running\n", + "Status: running\n", + "Status: running\n", + "Status: running\n", + "Status: running\n", + "Status: running\n", + "Status: running\n", + "Status: running\n", + "Status: running\n", + "Status: running\n", + "Status: running\n", + "Status: running\n", + "Status: running\n", + "Status: running\n", + "Status: running\n", + "Status: running\n", + "Status: running\n", + "Status: running\n", + "Status: running\n", + "Status: running\n", + "Status: running\n", + "Status: running\n", + "Status: running\n", + "Status: running\n", + "Status: running\n", + "Status: running\n", + "Status: running\n", + "Status: running\n", + "Status: running\n", + "Status: running\n", + "Status: running\n", + "Status: running\n", + "Status: running\n", + "Status: running\n", + "Status: running\n", + "Status: running\n", + "Status: running\n", + "Status: running\n", + "Status: running\n", + "Status: running\n", + "Status: running\n", + "Status: succeeded\n" + ] + } + ], "source": [ "while ft_job.status!='succeeded':\n", " time.sleep(15)\n", @@ -504,9 +653,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 15, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "'ft:gpt-3.5-turbo-0613:qdrant:100train20230906:7w7eYRbu'" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "model_id = openai.FineTuningJob.retrieve(ft_job[\"id\"]).fine_tuned_model\n", "model_id" @@ -521,9 +681,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 16, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{\n", + " \"role\": \"assistant\",\n", + " \"content\": \"I don't know\"\n", + "}\n" + ] + } + ], "source": [ "completion = openai.ChatCompletion.create(\n", " model=model_id,\n", @@ -550,9 +721,17 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 17, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 100/100 [04:54<00:00, 2.94s/it]\n" + ] + } + ], "source": [ "df[\"ft_generated_answer\"] = df.progress_apply(answer_question, model=model_id, axis=1)" ] @@ -575,7 +754,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 18, "metadata": {}, "outputs": [], "source": [ @@ -635,25 +814,57 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 19, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "Expected and Right 43.00%\n", + "Expected but IDK 0.00%\n", + "Expected but Wrong 10.00%\n", + "Hallucination 47.00%\n", + "Did not Expect and IDK 0.00%\n", + "Name: count, dtype: object" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "evaluate_model(df, \"generated_answer\")" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 20, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "Expected and Right 34.00%\n", + "Expected but IDK 17.00%\n", + "Expected but Wrong 2.00%\n", + "Hallucination 8.00%\n", + "Did not Expect and IDK 39.00%\n", + "Name: count, dtype: object" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "evaluate_model(df, \"ft_generated_answer\")" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 21, "metadata": {}, "outputs": [], "source": [ @@ -671,36 +882,48 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 144, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ - "def plot_overall_error(df, answer_columns):\n", + "def plot_overall_error(df, answer_columns, labels):\n", " error_categories = [\"Expected but Wrong\", \"Hallucination\"]\n", - " labels = [\"Overall Error\"]\n", - " x = np.arange(len(labels))\n", - " width = 0.35 / len(answer_columns)\n", - "\n", - " fig, ax = plt.subplots()\n", - "\n", + " \n", + " # Prepare data for Seaborn\n", + " data = []\n", " for i, col in enumerate(answer_columns):\n", " results = evaluate_model(df, col)\n", - " matrix_error = sum(\n", - " [float(results[col].loc[cat].replace(\"%\", \"\")) for cat in error_categories]\n", - " )\n", - " ax.bar(x + (i - len(answer_columns)/2) * width, [matrix_error], width, label=col)\n", + " matrix_error = sum([float(results.loc[cat].replace(\"%\", \"\")) for cat in error_categories])\n", + " data.append([labels[i], matrix_error])\n", "\n", - " ax.set_ylabel(\"Error (%) - Lower is Better\")\n", - " ax.set_title(\"Overall Error Comparison\")\n", - " ax.set_xticks(x)\n", - " ax.set_xticklabels(labels)\n", - " ax.legend()\n", + " df_plot = pd.DataFrame(data, columns=[\"Model\", \"Overall Error\"])\n", + " \n", + " # Create the plot\n", + " plt.figure(figsize=(10, 6))\n", + " ax = sns.barplot(x=\"Overall Error\", y=\"Model\", data=df_plot, palette=\"icefire\")\n", + " \n", + " # Add annotations\n", + " for i, p in enumerate(ax.patches):\n", + " ax.text(p.get_width() - 6, p.get_y() + p.get_height() / 2, f\"{p.get_width():.0f}%\", \n", + " va='center', color='white', fontweight='bold')\n", "\n", - " fig.tight_layout()\n", + " plt.xlabel(\"Error (%) - Lower is Better\")\n", + " plt.title(\"Total Error Comparison\")\n", " plt.show()\n", "\n", "# Plot only the overall error\n", - "plot_overall_error(df, answer_columns=[\"generated_answer\", \"ft_generated_answer\"])" + "plot_overall_error(df, answer_columns=[\"generated_answer\", \"ft_generated_answer\"], labels=[\"Base gpt-3.5-turbo-0613 Model\", \"Fine-Tuned Model\"])\n" ] }, { @@ -739,7 +962,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 51, "metadata": {}, "outputs": [], "source": [ @@ -759,7 +982,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 57, "metadata": {}, "outputs": [], "source": [ @@ -767,7 +990,7 @@ " url=os.getenv(\"QDRANT_URL\"), api_key=os.getenv(\"QDRANT_API_KEY\"), timeout=6000, prefer_grpc=True\n", ")\n", "\n", - "# collection_name = \"squadv2-cookbook\"\n", + "collection_name = \"squadv2-cookbook\"\n", "\n", "# # Create the collection\n", "# qdrant_client.recreate_collection(\n", @@ -778,7 +1001,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 58, "metadata": {}, "outputs": [], "source": [ @@ -806,7 +1029,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 59, "metadata": {}, "outputs": [], "source": [ @@ -870,7 +1093,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 60, "metadata": {}, "outputs": [], "source": [ @@ -891,9 +1114,24 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 62, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "ca88ff9dbfe24e9592ca03fc5c33c80e", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/100 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ - "# Evaluate this using the Evaluator\n", + "plot_overall_error(df, answer_columns=[\"generated_answer\", \"ft_generated_answer\", \"ft_generated_answer_few_shot\"], labels=[\"Base Model\", \"Fine-Tuned Model\", \"Fine-Tuned Model with Few-Shot\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 141, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/opt/homebrew/Caskroom/miniconda/base/envs/fst/lib/python3.9/site-packages/seaborn/axisgrid.py:118: UserWarning: The figure layout has changed to tight\n", + " self._figure.tight_layout(*args, **kwargs)\n", + "/var/folders/b4/grpbcmrd36gc7q5_11whbn540000gn/T/ipykernel_3534/765969223.py:24: UserWarning: The figure layout has changed to tight\n", + " plt.tight_layout()\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def plot_correctness(df, answer_columns, labels):\n", + " error_categories = [\"Expected and Right\", \"Expected but IDK\", \"Expected but Wrong\"]\n", + " annotations = [\"Correct\", \"I don't know\", \"Wrong\"]\n", + " cat_map = dict(zip(error_categories, annotations)) \n", + " # Prepare data for Seaborn\n", + " data = []\n", + " for i, col in enumerate(answer_columns):\n", + " results = evaluate_model(df, col)\n", + " for category in error_categories:\n", + " matrix_error = float(results.loc[category].replace(\"%\", \"\"))\n", + " data.append([labels[i], cat_map[category], matrix_error])\n", "\n", - "# Initialize the evaluator\n", - "evaluator = ConfusionMatrixEvaluator(\n", - " df, answers_column=\"ft_generated_answer_few_shot\"\n", - ")\n", - "evaluator.evaluate_answers()\n", - "error_categories = evaluator.generate_matrices(use_percentages=True)\n", - "error_categories" + " df_plot = pd.DataFrame(data, columns=[\"Model\", \"Error Category\", \"Percentage\"])\n", + " \n", + " # Create the plot\n", + " g = sns.catplot(x=\"Percentage\", y=\"Model\", hue=\"Error Category\", data=df_plot, kind=\"bar\", height=6, aspect=1.5, palette=\"icefire\")\n", + " \n", + " ax = g.facet_axis(0, 0)\n", + " \n", + " # Add annotations\n", + " for i, p in enumerate(ax.patches):\n", + " ax.annotate(f\"{p.get_width():.0f}%\", (p.get_width(), p.get_y() + p.get_height() / 2),\n", + " ha=\"left\", va=\"center\")\n", + " plt.tight_layout()\n", + " plt.xlabel(\"Percentage (%) - Higher is Better\")\n", + " plt.title(\"When Expecting an Answer\")\n", + " plt.show()\n", + "\n", + "plot_correctness(df, answer_columns=[\"generated_answer\", \"ft_generated_answer\", \"ft_generated_answer_few_shot\"], labels=[\"Base Model\", \"Fine-Tuned Model\", \"Few Shot Fine-Tuned Model with Qdrant\"])" ] } ], From 5260c4f026dff889032cbb7cd05a2f3f33f8546e Mon Sep 17 00:00:00 2001 From: NirantK Date: Thu, 7 Sep 2023 19:07:23 +0530 Subject: [PATCH 20/38] * chore(ModelFinetune.ipynb): add introduction and table of contents to the blog post * feat(ModelFinetune.ipynb): add section on why to read the blog post --- examples/fine-tuned-RAG/ModelFinetune.ipynb | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/examples/fine-tuned-RAG/ModelFinetune.ipynb b/examples/fine-tuned-RAG/ModelFinetune.ipynb index 78f2c91a28..61c643ede6 100644 --- a/examples/fine-tuned-RAG/ModelFinetune.ipynb +++ b/examples/fine-tuned-RAG/ModelFinetune.ipynb @@ -9,6 +9,12 @@ "\n", "The aim of this blog is to walk through a comprehensive example of how to fine-tune OpenAI models for Retrieval Augmented Generation (RAG). We will also be integrating Qdrant and Few-Shot Learning to boost the model's performance and reduce hallucinations. This could serve as a practical guide for ML practitioners, data scientists, and researchers interested in leveraging the power of OpenAI models for specific use-cases. 🤩\n", "\n", + "## Why should you read this blog?\n", + "\n", + "- You want to learn how to fine-tune OpenAI models for specific use-cases\n", + "- You want to learn how to use Qdrant to improve the performance of your RAG model\n", + "- You want to learn how to use fine-tune to improve the correctness of your RAG model\n", + "\n", "To begin, we've selected a dataset where we've a guarantee that the retrieval is perfect. We've selected a subset of the [SQuAD](https://rajpurkar.github.io/SQuAD-explorer/) dataset, which is a collection of questions and answers about Wikipedia articles. We've also included samples where the answer is not present in the context, to demonstrate how RAG handles this case.\n", "\n", "## Table of Contents\n", From 2a61773d6f3abd8e9356112a1fe86962701049ea Mon Sep 17 00:00:00 2001 From: NirantK Date: Thu, 7 Sep 2023 19:08:14 +0530 Subject: [PATCH 21/38] * chore(ModelFinetune.ipynb): update bullet points in the introduction section * feat(ModelFinetune.ipynb): add information about reducing hallucinations in the introduction section --- examples/fine-tuned-RAG/ModelFinetune.ipynb | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/examples/fine-tuned-RAG/ModelFinetune.ipynb b/examples/fine-tuned-RAG/ModelFinetune.ipynb index 61c643ede6..faf5883d32 100644 --- a/examples/fine-tuned-RAG/ModelFinetune.ipynb +++ b/examples/fine-tuned-RAG/ModelFinetune.ipynb @@ -11,9 +11,10 @@ "\n", "## Why should you read this blog?\n", "\n", - "- You want to learn how to fine-tune OpenAI models for specific use-cases\n", - "- You want to learn how to use Qdrant to improve the performance of your RAG model\n", - "- You want to learn how to use fine-tune to improve the correctness of your RAG model\n", + "You want to learn how to \n", + "- Fine-tune OpenAI models for specific use-cases\n", + "- Use Qdrant to improve the performance of your RAG model\n", + "- Use fine-tuning to improve the correctness of your RAG model and reduce hallucinations\n", "\n", "To begin, we've selected a dataset where we've a guarantee that the retrieval is perfect. We've selected a subset of the [SQuAD](https://rajpurkar.github.io/SQuAD-explorer/) dataset, which is a collection of questions and answers about Wikipedia articles. We've also included samples where the answer is not present in the context, to demonstrate how RAG handles this case.\n", "\n", From 448a0595b84ced3bebc9a1568b625e748f9c1d60 Mon Sep 17 00:00:00 2001 From: NirantK Date: Thu, 7 Sep 2023 19:08:49 +0530 Subject: [PATCH 22/38] * docs(ModelFinetune.ipynb): update introduction to clarify the aim of the notebook and target audience --- examples/fine-tuned-RAG/ModelFinetune.ipynb | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/examples/fine-tuned-RAG/ModelFinetune.ipynb b/examples/fine-tuned-RAG/ModelFinetune.ipynb index faf5883d32..c7f10010b8 100644 --- a/examples/fine-tuned-RAG/ModelFinetune.ipynb +++ b/examples/fine-tuned-RAG/ModelFinetune.ipynb @@ -7,7 +7,9 @@ "source": [ "# Fine-Tuning OpenAI Models for Retrieval Augmented Generation (RAG) with Qdrant and Few-Shot Learning\n", "\n", - "The aim of this blog is to walk through a comprehensive example of how to fine-tune OpenAI models for Retrieval Augmented Generation (RAG). We will also be integrating Qdrant and Few-Shot Learning to boost the model's performance and reduce hallucinations. This could serve as a practical guide for ML practitioners, data scientists, and researchers interested in leveraging the power of OpenAI models for specific use-cases. 🤩\n", + "The aim of this notebook is to walk through a comprehensive example of how to fine-tune OpenAI models for Retrieval Augmented Generation (RAG). \n", + "\n", + "We will also be integrating Qdrant and Few-Shot Learning to boost the model's performance and reduce hallucinations. This could serve as a practical guide for ML practitioners, data scientists, and AI Engineers interested in leveraging the power of OpenAI models for specific use-cases. 🤩\n", "\n", "## Why should you read this blog?\n", "\n", From 5c6ae43cd0ba1edd64734d43479a2066e00a0f7b Mon Sep 17 00:00:00 2001 From: NirantK Date: Thu, 7 Sep 2023 19:23:51 +0530 Subject: [PATCH 23/38] Replace the data verification with a link --- examples/fine-tuned-RAG/ModelFinetune.ipynb | 180 +------------------- 1 file changed, 1 insertion(+), 179 deletions(-) diff --git a/examples/fine-tuned-RAG/ModelFinetune.ipynb b/examples/fine-tuned-RAG/ModelFinetune.ipynb index c7f10010b8..f39ee5e06a 100644 --- a/examples/fine-tuned-RAG/ModelFinetune.ipynb +++ b/examples/fine-tuned-RAG/ModelFinetune.ipynb @@ -300,185 +300,7 @@ "source": [ "#### [Optional] Verify the Fine-Tuning Data\n", "\n", - "The script below will verify that the data is in the format that OpenAI expects." - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Num examples: 100\n", - "First example:\n", - "{'role': 'system', 'content': 'You are a helpful assistant.'}\n", - "{'role': 'user', 'content': \"Answer the following Question based on the Context only. Only answer from the Context. If you don't know the answer, say 'I don't know'.\\n Question: What is a cirque?\\n\\n\\n Context: Glaciers form where the accumulation of snow and ice exceeds ablation. The area in which a glacier forms is called a cirque (corrie or cwm) - a typically armchair-shaped geological feature (such as a depression between mountains enclosed by arêtes) - which collects and compresses through gravity the snow which falls into it. This snow collects and is compacted by the weight of the snow falling above it forming névé. Further crushing of the individual snowflakes and squeezing the air from the snow turns it into 'glacial ice'. This glacial ice will fill the cirque until it 'overflows' through a geological weakness or vacancy, such as the gap between two mountains. When the mass of snow and ice is sufficiently thick, it begins to move due to a combination of surface slope, gravity and pressure. On steeper slopes, this can occur with as little as 15 m (50 ft) of snow-ice.\\n\\n\\n Answer:\\n\"}\n", - "{'role': 'assistant', 'content': 'The area in which a glacier forms'}\n", - "No errors found\n", - "Num examples missing system message: 0\n", - "Num examples missing user message: 0\n", - "\n", - "#### Distribution of num_messages_per_example:\n", - "min / max: 3, 3\n", - "mean / median: 3.0, 3.0\n", - "p5 / p95: 3.0, 3.0\n", - "\n", - "#### Distribution of num_total_tokens_per_example:\n", - "min / max: 114, 689\n", - "mean / median: 236.88, 217.0\n", - "p5 / p95: 166.7, 321.3\n", - "\n", - "#### Distribution of num_assistant_tokens_per_example:\n", - "min / max: 1, 13\n", - "mean / median: 3.81, 4.0\n", - "p5 / p95: 1.0, 5.0\n", - "\n", - "0 examples may be over the 4096 token limit, they will be truncated during fine-tuning\n", - "Dataset has ~23688 tokens that will be charged for during training\n", - "By default, you'll train for 3 epochs on this dataset\n", - "By default, you'll be charged for ~71064 tokens\n", - "See pricing page to estimate total costs\n" - ] - } - ], - "source": [ - "# Specify the data path and open the JSONL file\n", - "\n", - "data_path = \"local_cache/100_train.jsonl\"\n", - "\n", - "# Load dataset\n", - "with open(data_path) as f:\n", - " dataset = [json.loads(line) for line in f]\n", - "\n", - "# We can inspect the data quickly by checking the number of examples and the first item\n", - "\n", - "# Initial dataset stats\n", - "print(\"Num examples:\", len(dataset))\n", - "print(\"First example:\")\n", - "for message in dataset[0][\"messages\"]:\n", - " print(message)\n", - "\n", - "# Now that we have a sense of the data, we need to go through all the different examples and check to make sure the formatting is correct and matches the Chat completions message structure\n", - "\n", - "# Format error checks\n", - "format_errors = defaultdict(int)\n", - "\n", - "for ex in dataset:\n", - " if not isinstance(ex, dict):\n", - " format_errors[\"data_type\"] += 1\n", - " continue\n", - "\n", - " messages = ex.get(\"messages\", None)\n", - " if not messages:\n", - " format_errors[\"missing_messages_list\"] += 1\n", - " continue\n", - "\n", - " for message in messages:\n", - " if \"role\" not in message or \"content\" not in message:\n", - " format_errors[\"message_missing_key\"] += 1\n", - "\n", - " if any(k not in (\"role\", \"content\", \"name\") for k in message):\n", - " format_errors[\"message_unrecognized_key\"] += 1\n", - "\n", - " if message.get(\"role\", None) not in (\"system\", \"user\", \"assistant\"):\n", - " format_errors[\"unrecognized_role\"] += 1\n", - "\n", - " content = message.get(\"content\", None)\n", - " if not content or not isinstance(content, str):\n", - " format_errors[\"missing_content\"] += 1\n", - "\n", - " if not any(message.get(\"role\", None) == \"assistant\" for message in messages):\n", - " format_errors[\"example_missing_assistant_message\"] += 1\n", - "\n", - "if format_errors:\n", - " print(\"Found errors:\")\n", - " for k, v in format_errors.items():\n", - " print(f\"{k}: {v}\")\n", - "else:\n", - " print(\"No errors found\")\n", - "\n", - "# Beyond the structure of the message, we also need to ensure that the length does not exceed the 4096 token limit.\n", - "\n", - "# Token counting functions\n", - "encoding = tiktoken.get_encoding(\"cl100k_base\")\n", - "\n", - "# not exact!\n", - "# simplified from https://github.com/openai/openai-cookbook/blob/main/examples/How_to_count_tokens_with_tiktoken.ipynb\n", - "def num_tokens_from_messages(messages, tokens_per_message=3, tokens_per_name=1):\n", - " num_tokens = 0\n", - " for message in messages:\n", - " num_tokens += tokens_per_message\n", - " for key, value in message.items():\n", - " num_tokens += len(encoding.encode(value))\n", - " if key == \"name\":\n", - " num_tokens += tokens_per_name\n", - " num_tokens += 3\n", - " return num_tokens\n", - "\n", - "def num_assistant_tokens_from_messages(messages):\n", - " num_tokens = 0\n", - " for message in messages:\n", - " if message[\"role\"] == \"assistant\":\n", - " num_tokens += len(encoding.encode(message[\"content\"]))\n", - " return num_tokens\n", - "\n", - "def print_distribution(values, name):\n", - " print(f\"\\n#### Distribution of {name}:\")\n", - " print(f\"min / max: {min(values)}, {max(values)}\")\n", - " print(f\"mean / median: {np.mean(values)}, {np.median(values)}\")\n", - " print(f\"p5 / p95: {np.quantile(values, 0.1)}, {np.quantile(values, 0.9)}\")\n", - "\n", - "# Last, we can look at the results of the different formatting operations before proceeding with creating a fine-tuning job:\n", - "\n", - "# Warnings and tokens counts\n", - "n_missing_system = 0\n", - "n_missing_user = 0\n", - "n_messages = []\n", - "convo_lens = []\n", - "assistant_message_lens = []\n", - "\n", - "for ex in dataset:\n", - " messages = ex[\"messages\"]\n", - " if not any(message[\"role\"] == \"system\" for message in messages):\n", - " n_missing_system += 1\n", - " if not any(message[\"role\"] == \"user\" for message in messages):\n", - " n_missing_user += 1\n", - " n_messages.append(len(messages))\n", - " convo_lens.append(num_tokens_from_messages(messages))\n", - " assistant_message_lens.append(num_assistant_tokens_from_messages(messages))\n", - "\n", - "print(\"Num examples missing system message:\", n_missing_system)\n", - "print(\"Num examples missing user message:\", n_missing_user)\n", - "print_distribution(n_messages, \"num_messages_per_example\")\n", - "print_distribution(convo_lens, \"num_total_tokens_per_example\")\n", - "print_distribution(assistant_message_lens, \"num_assistant_tokens_per_example\")\n", - "n_too_long = sum(l > 4096 for l in convo_lens)\n", - "print(f\"\\n{n_too_long} examples may be over the 4096 token limit, they will be truncated during fine-tuning\")\n", - "\n", - "# Pricing and default n_epochs estimate\n", - "MAX_TOKENS_PER_EXAMPLE = 4096\n", - "\n", - "MIN_TARGET_EXAMPLES = 100\n", - "MAX_TARGET_EXAMPLES = 25000\n", - "TARGET_EPOCHS = 3\n", - "MIN_EPOCHS = 1\n", - "MAX_EPOCHS = 25\n", - "\n", - "n_epochs = TARGET_EPOCHS\n", - "n_train_examples = len(dataset)\n", - "if n_train_examples * TARGET_EPOCHS < MIN_TARGET_EXAMPLES:\n", - " n_epochs = min(MAX_EPOCHS, MIN_TARGET_EXAMPLES // n_train_examples)\n", - "elif n_train_examples * TARGET_EPOCHS > MAX_TARGET_EXAMPLES:\n", - " n_epochs = max(MIN_EPOCHS, MAX_TARGET_EXAMPLES // n_train_examples)\n", - "\n", - "n_billing_tokens_in_dataset = sum(min(MAX_TOKENS_PER_EXAMPLE, length) for length in convo_lens)\n", - "print(f\"Dataset has ~{n_billing_tokens_in_dataset} tokens that will be charged for during training\")\n", - "print(f\"By default, you'll train for {n_epochs} epochs on this dataset\")\n", - "print(f\"By default, you'll be charged for ~{n_epochs * n_billing_tokens_in_dataset} tokens\")\n", - "print(\"See pricing page to estimate total costs\")" + "You can see this [cookbook](https://github.com/openai/openai-cookbook/blob/main/examples/Chat_finetuning_data_prep.ipynb) for more details on how to prepare the data for fine-tuning." ] }, { From 4c74a97c631cfaf168857c20738a89046e1d362d Mon Sep 17 00:00:00 2001 From: NirantK Date: Thu, 7 Sep 2023 19:26:23 +0530 Subject: [PATCH 24/38] * feat(ModelFinetune.ipynb): refactor code to use OpenAIFineTuner class for fine-tuning the OpenAI model --- examples/fine-tuned-RAG/ModelFinetune.ipynb | 285 ++++---------------- 1 file changed, 54 insertions(+), 231 deletions(-) diff --git a/examples/fine-tuned-RAG/ModelFinetune.ipynb b/examples/fine-tuned-RAG/ModelFinetune.ipynb index f39ee5e06a..28b66badfd 100644 --- a/examples/fine-tuned-RAG/ModelFinetune.ipynb +++ b/examples/fine-tuned-RAG/ModelFinetune.ipynb @@ -307,199 +307,74 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### Upload the Fine-Tuning Data to OpenAI" + "## Fine-Tune OpenAI Model" ] }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ - "file_object = openai.File.create(\n", - " file=open(\"local_cache/100_train.jsonl\", \"r\"),\n", - " purpose=\"fine-tune\",\n", - ")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "💡 Wait: For file to be uploaded and then processed by OpenAI." - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - " JSON: {\n", - " \"object\": \"file\",\n", - " \"id\": \"file-X0QsHJXqT3DrG1OaXHKMnwXg\",\n", - " \"purpose\": \"fine-tune\",\n", - " \"filename\": \"file\",\n", - " \"bytes\": 120415,\n", - " \"created_at\": 1694085592,\n", - " \"status\": \"processed\",\n", - " \"status_details\": null\n", - "}" - ] - }, - "execution_count": 12, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "while file_object.status!='processed':\n", - " time.sleep(5)\n", - " file_object.refresh()\n", - "file_object" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Create a Fine Tuning Job" + "class OpenAIFineTuner:\n", + " def __init__(self, training_file_path, model_name, suffix):\n", + " self.training_file_path = training_file_path\n", + " self.model_name = model_name\n", + " self.suffix = suffix\n", + " self.file_object = None\n", + " self.fine_tuning_job = None\n", + " self.model_id = None\n", + "\n", + " def create_openai_file(self):\n", + " self.file_object = openai.File.create(\n", + " file=open(self.training_file_path, \"r\"),\n", + " purpose=\"fine-tune\",\n", + " )\n", + "\n", + " def wait_for_file_processing(self, sleep_time=20):\n", + " while self.file_object.status != 'processed':\n", + " time.sleep(sleep_time)\n", + " self.file_object.refresh()\n", + " print(\"File Status: \", self.file_object.status)\n", + "\n", + " def create_fine_tuning_job(self):\n", + " self.fine_tuning_job = openai.FineTuningJob.create(\n", + " training_file=self.file_object[\"id\"],\n", + " model=self.model_name,\n", + " suffix=self.suffix,\n", + " )\n", + "\n", + " def wait_for_fine_tuning(self, sleep_time=45):\n", + " while self.fine_tuning_job.status != 'succeeded':\n", + " time.sleep(sleep_time)\n", + " self.fine_tuning_job.refresh()\n", + " print(\"Job Status: \", self.fine_tuning_job.status)\n", + "\n", + " def retrieve_fine_tuned_model(self):\n", + " self.model_id = openai.FineTuningJob.retrieve(self.fine_tuning_job[\"id\"]).fine_tuned_model\n", + " return self.model_id\n", + "\n", + " def fine_tune_model(self):\n", + " self.create_openai_file()\n", + " self.wait_for_file_processing()\n", + " self.create_fine_tuning_job()\n", + " self.wait_for_fine_tuning()\n", + " return self.retrieve_fine_tuned_model()\n", + "\n", + "fine_tuner = OpenAIFineTuner(\n", + " training_file_path=\"local_cache/100_train.jsonl\",\n", + " model_name=\"gpt-3.5-turbo\",\n", + " suffix=\"100trn20230907\"\n", + " )" ] }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 11, "metadata": {}, "outputs": [], "source": [ - "ft_job = openai.FineTuningJob.create(\n", - " training_file=file_object[\"id\"], model=\"gpt-3.5-turbo\", suffix=\"100train20230906\"\n", - ")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "💡 Wait: For the fine-tuning job to complete and status to be \"succeeded\"." - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: running\n", - "Status: succeeded\n" - ] - } - ], - "source": [ - "while ft_job.status!='succeeded':\n", - " time.sleep(15)\n", - " ft_job.refresh()\n", - " print(\"Status: \", ft_job.status)" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "'ft:gpt-3.5-turbo-0613:qdrant:100train20230906:7w7eYRbu'" - ] - }, - "execution_count": 15, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "model_id = openai.FineTuningJob.retrieve(ft_job[\"id\"]).fine_tuned_model\n", + "model_id = fine_tuner.fine_tune_model()\n", "model_id" ] }, @@ -1092,58 +967,6 @@ " f.write(dataframe_to_jsonl(train_sample))" ] }, - { - "cell_type": "code", - "execution_count": 64, - "metadata": {}, - "outputs": [], - "source": [ - "class OpenAIFineTuner:\n", - " def __init__(self, training_file_path, model_name, suffix):\n", - " self.training_file_path = training_file_path\n", - " self.model_name = model_name\n", - " self.suffix = suffix\n", - " self.file_object = None\n", - " self.fine_tuning_job = None\n", - " self.model_id = None\n", - "\n", - " def create_openai_file(self):\n", - " self.file_object = openai.File.create(\n", - " file=open(self.training_file_path, \"r\"),\n", - " purpose=\"fine-tune\",\n", - " )\n", - "\n", - " def wait_for_file_processing(self, sleep_time=20):\n", - " while self.file_object.status != 'processed':\n", - " time.sleep(sleep_time)\n", - " self.file_object.refresh()\n", - " print(\"File Status: \", self.file_object.status)\n", - "\n", - " def create_fine_tuning_job(self):\n", - " self.fine_tuning_job = openai.FineTuningJob.create(\n", - " training_file=self.file_object[\"id\"],\n", - " model=self.model_name,\n", - " suffix=self.suffix,\n", - " )\n", - "\n", - " def wait_for_fine_tuning(self, sleep_time=45):\n", - " while self.fine_tuning_job.status != 'succeeded':\n", - " time.sleep(sleep_time)\n", - " self.fine_tuning_job.refresh()\n", - " print(\"Job Status: \", self.fine_tuning_job.status)\n", - "\n", - " def retrieve_fine_tuned_model(self):\n", - " self.model_id = openai.FineTuningJob.retrieve(self.fine_tuning_job[\"id\"]).fine_tuned_model\n", - " return self.model_id\n", - "\n", - " def fine_tune_model(self):\n", - " self.create_openai_file()\n", - " self.wait_for_file_processing()\n", - " self.create_fine_tuning_job()\n", - " self.wait_for_fine_tuning()\n", - " return self.retrieve_fine_tuned_model()" - ] - }, { "cell_type": "code", "execution_count": 65, From 4fa2b68a7ca7e1fb16090a34552914cb27ecc5fb Mon Sep 17 00:00:00 2001 From: NirantK Date: Thu, 7 Sep 2023 19:30:45 +0530 Subject: [PATCH 25/38] * chore(ModelFinetune.ipynb): update error category descriptions in evaluation section --- examples/fine-tuned-RAG/ModelFinetune.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/examples/fine-tuned-RAG/ModelFinetune.ipynb b/examples/fine-tuned-RAG/ModelFinetune.ipynb index 28b66badfd..14ea4d8d97 100644 --- a/examples/fine-tuned-RAG/ModelFinetune.ipynb +++ b/examples/fine-tuned-RAG/ModelFinetune.ipynb @@ -452,7 +452,7 @@ "To evaluate the model's performance, compare the predicted answer to the actual answers -- if any of the actual answers are present in the predicted answer, then it's a match. We've also created error categories to help you understand where the model is struggling.\n", "\n", "1. Expected and Right: The model responsded the correct answer. It may have also included other answers that were not in the context.\n", - "2. Expected but \"IDK\": The model responded with \"I don't know\" (IDK) while the answer was present in the context. *This is a model error* and better than giving the wrong answer. We exclude this from the overall error rate.\n", + "2. Expected but \"IDK\": The model responded with \"I don't know\" (IDK) while the answer was present in the context. *This is a model error* and better than giving the wrong answer. It's better for the model say \"I don't know\" than giving a hallucinated or made up and wrong answer. In our design, we know that a true answer exists and hence we're able to measure it -- this is not always the case. We exclude this from the overall error rate. \n", "3. Expected but Wrong: The model responded with an incorrect answer. *This is a model ERROR.*\n", "4. Hallucination: The model responded with an answer, when \"I don't know\" was expected. **This is a model error.** \n", "5. Did not expect and IDK: The model responded with \"I don't know\" (IDK) and the answer was not present in the context. *This is a model WIN.*" From 3d1311450c6f07fefdd8f76126cfe69d728962d6 Mon Sep 17 00:00:00 2001 From: NirantK Date: Thu, 7 Sep 2023 19:31:45 +0530 Subject: [PATCH 26/38] * docs(ModelFinetune.ipynb): add link to OpenAI Cookbook guide for fine-tuning chat models --- examples/fine-tuned-RAG/ModelFinetune.ipynb | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/examples/fine-tuned-RAG/ModelFinetune.ipynb b/examples/fine-tuned-RAG/ModelFinetune.ipynb index 14ea4d8d97..f5eb297639 100644 --- a/examples/fine-tuned-RAG/ModelFinetune.ipynb +++ b/examples/fine-tuned-RAG/ModelFinetune.ipynb @@ -307,7 +307,9 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Fine-Tune OpenAI Model" + "## Fine-Tune OpenAI Model\n", + "\n", + "If you're new to OpenAI Model Fine-Tuning, please refer to the [How to finetune Chat models](https://github.com/openai/openai-cookbook/blob/448a0595b84ced3bebc9a1568b625e748f9c1d60/examples/How_to_finetune_chat_models.ipynb)." ] }, { From b9d633e9390b6354b009a54ec5b1fb1649ee9c57 Mon Sep 17 00:00:00 2001 From: NirantK Date: Thu, 7 Sep 2023 19:32:21 +0530 Subject: [PATCH 27/38] * docs(ModelFinetune.ipynb): update link to OpenAI Fine-Tuning Docs and add more details in the comment --- examples/fine-tuned-RAG/ModelFinetune.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/examples/fine-tuned-RAG/ModelFinetune.ipynb b/examples/fine-tuned-RAG/ModelFinetune.ipynb index f5eb297639..2bc25359af 100644 --- a/examples/fine-tuned-RAG/ModelFinetune.ipynb +++ b/examples/fine-tuned-RAG/ModelFinetune.ipynb @@ -309,7 +309,7 @@ "source": [ "## Fine-Tune OpenAI Model\n", "\n", - "If you're new to OpenAI Model Fine-Tuning, please refer to the [How to finetune Chat models](https://github.com/openai/openai-cookbook/blob/448a0595b84ced3bebc9a1568b625e748f9c1d60/examples/How_to_finetune_chat_models.ipynb)." + "If you're new to OpenAI Model Fine-Tuning, please refer to the [How to finetune Chat models](https://github.com/openai/openai-cookbook/blob/448a0595b84ced3bebc9a1568b625e748f9c1d60/examples/How_to_finetune_chat_models.ipynb) notebook. You can also refer to the [OpenAI Fine-Tuning Docs](platform.openai.com/docs/guides/fine-tuning/use-a-fine-tuned-model) for more details." ] }, { From 1c9ea7eb72333de6802a514d794cbc8d7605f370 Mon Sep 17 00:00:00 2001 From: NirantK Date: Fri, 8 Sep 2023 13:11:52 +0530 Subject: [PATCH 28/38] * chore(fine-tuned-RAG): remove .gitignore file for *.parquet --- examples/fine-tuned-RAG/.gitignore | 1 - 1 file changed, 1 deletion(-) delete mode 100644 examples/fine-tuned-RAG/.gitignore diff --git a/examples/fine-tuned-RAG/.gitignore b/examples/fine-tuned-RAG/.gitignore deleted file mode 100644 index bccc1450f2..0000000000 --- a/examples/fine-tuned-RAG/.gitignore +++ /dev/null @@ -1 +0,0 @@ -*.parquet \ No newline at end of file From f347a9c283fb38f8dfa93f08cb145582724de44d Mon Sep 17 00:00:00 2001 From: NirantK Date: Fri, 8 Sep 2023 13:19:53 +0530 Subject: [PATCH 29/38] Move nbs --- .../ft_retrieval_augmented_generation.ipynb} | 104 +++++++----------- 1 file changed, 41 insertions(+), 63 deletions(-) rename examples/{fine-tuned-RAG/ModelFinetune.ipynb => fine-tuned_qa/ft_retrieval_augmented_generation.ipynb} (63%) diff --git a/examples/fine-tuned-RAG/ModelFinetune.ipynb b/examples/fine-tuned_qa/ft_retrieval_augmented_generation.ipynb similarity index 63% rename from examples/fine-tuned-RAG/ModelFinetune.ipynb rename to examples/fine-tuned_qa/ft_retrieval_augmented_generation.ipynb index 2bc25359af..8489e364a6 100644 --- a/examples/fine-tuned-RAG/ModelFinetune.ipynb +++ b/examples/fine-tuned_qa/ft_retrieval_augmented_generation.ipynb @@ -55,7 +55,7 @@ }, { "cell_type": "code", - "execution_count": 78, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -631,7 +631,7 @@ " plt.show()\n", "\n", "# Plot only the overall error\n", - "plot_overall_error(df, answer_columns=[\"generated_answer\", \"ft_generated_answer\"], labels=[\"Base gpt-3.5-turbo-0613 Model\", \"Fine-Tuned Model\"])\n" + "plot_overall_error(df, answer_columns=[\"generated_answer\", \"ft_generated_answer\"], labels=[\"Base gpt-3.5-turbo-0613 Model\", \"Fine-Tuned Model\"])" ] }, { @@ -923,7 +923,7 @@ " rag_prompt = [{\"role\": \"system\", \"content\": instruction}] + rag_prompt\n", " return rag_prompt\n", "\n", - "train_sample[\"few_shot_prompt_1K\"] = train_sample.progress_apply(get_few_shot_prompt, axis=1)" + "train_sample[\"few_shot_prompt\"] = train_sample.progress_apply(get_few_shot_prompt, axis=1)" ] }, { @@ -959,7 +959,7 @@ "# Prepare the OpenAI File format i.e. JSONL from train_sample\n", "def dataframe_to_jsonl(df):\n", " def create_jsonl_entry(row):\n", - " messages = row[\"few_shot_prompt_1K\"]\n", + " messages = row[\"few_shot_prompt\"]\n", " return json.dumps({\"messages\": messages})\n", "\n", " jsonl_output = df.progress_apply(create_jsonl_entry, axis=1)\n", @@ -971,48 +971,19 @@ }, { "cell_type": "code", - "execution_count": 65, + "execution_count": 7, "metadata": {}, "outputs": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "File Status: uploaded\n", - "File Status: uploaded\n", - "File Status: processed\n", - "Job Status: running\n", - "Job Status: running\n", - "Job Status: running\n", - "Job Status: running\n", - "Job Status: running\n", - "Job Status: running\n", - "Job Status: running\n", - "Job Status: running\n", - "Job Status: running\n", - "Job Status: running\n", - "Job Status: running\n", - "Job Status: running\n", - "Job Status: running\n", - "Job Status: running\n", - "Job Status: running\n", - "Job Status: running\n", - "Job Status: running\n", - "Job Status: running\n", - "Job Status: running\n", - "Job Status: running\n", - "Job Status: succeeded\n" + "ename": "NameError", + "evalue": "name 'OpenAIFineTuner' 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 fine_tuner \u001b[39m=\u001b[39m OpenAIFineTuner(\n\u001b[1;32m 2\u001b[0m training_file_path\u001b[39m=\u001b[39m\u001b[39m\"\u001b[39m\u001b[39mlocal_cache/100_train_few_shot.jsonl\u001b[39m\u001b[39m\"\u001b[39m,\n\u001b[1;32m 3\u001b[0m model_name\u001b[39m=\u001b[39m\u001b[39m\"\u001b[39m\u001b[39mgpt-3.5-turbo\u001b[39m\u001b[39m\"\u001b[39m,\n\u001b[1;32m 4\u001b[0m suffix\u001b[39m=\u001b[39m\u001b[39m\"\u001b[39m\u001b[39mtrnfewshot20230907\u001b[39m\u001b[39m\"\u001b[39m\n\u001b[1;32m 5\u001b[0m )\n\u001b[1;32m 7\u001b[0m model_id \u001b[39m=\u001b[39m fine_tuner\u001b[39m.\u001b[39mfine_tune_model()\n\u001b[1;32m 8\u001b[0m model_id\n", + "\u001b[0;31mNameError\u001b[0m: name 'OpenAIFineTuner' is not defined" ] - }, - { - "data": { - "text/plain": [ - "'ft:gpt-3.5-turbo-0613:qdrant:trnfewshot20230907:7w8Fhrg6'" - ] - }, - "execution_count": 65, - "metadata": {}, - "output_type": "execute_result" } ], "source": [ @@ -1050,6 +1021,15 @@ "df[\"ft_generated_answer_few_shot\"] = df.progress_apply(answer_question, model=model_id, prompt_func=get_few_shot_prompt, axis=1)" ] }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "df.to_json(\"local_cache/100_val_ft_few_shot.json\", orient=\"records\", lines=True)" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -1104,28 +1084,19 @@ }, { "cell_type": "code", - "execution_count": 141, + "execution_count": 1, "metadata": {}, "outputs": [ { - "name": "stderr", - "output_type": "stream", - "text": [ - "/opt/homebrew/Caskroom/miniconda/base/envs/fst/lib/python3.9/site-packages/seaborn/axisgrid.py:118: UserWarning: The figure layout has changed to tight\n", - " self._figure.tight_layout(*args, **kwargs)\n", - "/var/folders/b4/grpbcmrd36gc7q5_11whbn540000gn/T/ipykernel_3534/765969223.py:24: UserWarning: The figure layout has changed to tight\n", - " plt.tight_layout()\n" + "ename": "NameError", + "evalue": "name 'df' 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[1], line 29\u001b[0m\n\u001b[1;32m 26\u001b[0m plt\u001b[39m.\u001b[39mtitle(\u001b[39m\"\u001b[39m\u001b[39mWhen Expecting an Answer\u001b[39m\u001b[39m\"\u001b[39m)\n\u001b[1;32m 27\u001b[0m plt\u001b[39m.\u001b[39mshow()\n\u001b[0;32m---> 29\u001b[0m plot_correctness(df, answer_columns\u001b[39m=\u001b[39m[\u001b[39m\"\u001b[39m\u001b[39mgenerated_answer\u001b[39m\u001b[39m\"\u001b[39m, \u001b[39m\"\u001b[39m\u001b[39mft_generated_answer\u001b[39m\u001b[39m\"\u001b[39m, \u001b[39m\"\u001b[39m\u001b[39mft_generated_answer_few_shot\u001b[39m\u001b[39m\"\u001b[39m], labels\u001b[39m=\u001b[39m[\u001b[39m\"\u001b[39m\u001b[39mBase Model\u001b[39m\u001b[39m\"\u001b[39m, \u001b[39m\"\u001b[39m\u001b[39mFine-Tuned Model\u001b[39m\u001b[39m\"\u001b[39m, \u001b[39m\"\u001b[39m\u001b[39mFew Shot Fine-Tuned Model with Qdrant\u001b[39m\u001b[39m\"\u001b[39m])\n", + "\u001b[0;31mNameError\u001b[0m: name 'df' is not defined" ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" } ], "source": [ @@ -1141,10 +1112,10 @@ " matrix_error = float(results.loc[category].replace(\"%\", \"\"))\n", " data.append([labels[i], cat_map[category], matrix_error])\n", "\n", - " df_plot = pd.DataFrame(data, columns=[\"Model\", \"Error Category\", \"Percentage\"])\n", + " df_plot = pd.DataFrame(data, columns=[\"Model\", \"Response\", \"Percentage\"])\n", " \n", " # Create the plot\n", - " g = sns.catplot(x=\"Percentage\", y=\"Model\", hue=\"Error Category\", data=df_plot, kind=\"bar\", height=6, aspect=1.5, palette=\"icefire\")\n", + " g = sns.catplot(x=\"Percentage\", y=\"Model\", hue=\"Response\", data=df_plot, kind=\"bar\", height=6, aspect=1.5, palette=\"icefire\")\n", " \n", " ax = g.facet_axis(0, 0)\n", " \n", @@ -1153,12 +1124,19 @@ " ax.annotate(f\"{p.get_width():.0f}%\", (p.get_width(), p.get_y() + p.get_height() / 2),\n", " ha=\"left\", va=\"center\")\n", " plt.tight_layout()\n", - " plt.xlabel(\"Percentage (%) - Higher is Better\")\n", + " plt.xlabel(\"Percentage (%)\")\n", " plt.title(\"When Expecting an Answer\")\n", " plt.show()\n", "\n", "plot_correctness(df, answer_columns=[\"generated_answer\", \"ft_generated_answer\", \"ft_generated_answer_few_shot\"], labels=[\"Base Model\", \"Fine-Tuned Model\", \"Few Shot Fine-Tuned Model with Qdrant\"])" ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { From faca10b112dbb68ce4aaf014f9bbdbe3619d9497 Mon Sep 17 00:00:00 2001 From: NirantK Date: Fri, 8 Sep 2023 16:22:40 +0530 Subject: [PATCH 30/38] * chore(.gitignore): update ignored directory path for fine-tuned_qa/local_cache/ --- .gitignore | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.gitignore b/.gitignore index e4a66a7b25..1ecd08687b 100644 --- a/.gitignore +++ b/.gitignore @@ -133,4 +133,4 @@ dmypy.json /examples/data/transactions* *.DS_Store tmp_* -examples/fine-tuned-RAG/local_cache/* +examples/fine-tuned_qa/local_cache/* From d1c0f4eb97ba44503a7a8f24142811b9c9fbe393 Mon Sep 17 00:00:00 2001 From: NirantK Date: Fri, 8 Sep 2023 18:56:56 +0530 Subject: [PATCH 31/38] Better numbering, easier to read, renamed error categories --- .../ft_retrieval_augmented_generation.ipynb | 714 +++++++++++++----- 1 file changed, 507 insertions(+), 207 deletions(-) diff --git a/examples/fine-tuned_qa/ft_retrieval_augmented_generation.ipynb b/examples/fine-tuned_qa/ft_retrieval_augmented_generation.ipynb index 8489e364a6..a7385e5184 100644 --- a/examples/fine-tuned_qa/ft_retrieval_augmented_generation.ipynb +++ b/examples/fine-tuned_qa/ft_retrieval_augmented_generation.ipynb @@ -14,8 +14,8 @@ "## Why should you read this blog?\n", "\n", "You want to learn how to \n", - "- Fine-tune OpenAI models for specific use-cases\n", - "- Use Qdrant to improve the performance of your RAG model\n", + "- [Fine-tune OpenAI models](https://platform.openai.com/docs/guides/fine-tuning/) for specific use-cases\n", + "- Use [Qdrant](https://qdrant.tech/documentation/) to improve the performance of your RAG model\n", "- Use fine-tuning to improve the correctness of your RAG model and reduce hallucinations\n", "\n", "To begin, we've selected a dataset where we've a guarantee that the retrieval is perfect. We've selected a subset of the [SQuAD](https://rajpurkar.github.io/SQuAD-explorer/) dataset, which is a collection of questions and answers about Wikipedia articles. We've also included samples where the answer is not present in the context, to demonstrate how RAG handles this case.\n", @@ -24,9 +24,10 @@ "1. Setting up the Environment\n", "\n", "### Section A: Zero-Shot Learning\n", - "2. Data Preparation\n", - "3. OpenAI Model Fine-Tuning\n", - "4. Baseline Results\n", + "2. Data Preparation: SQuADv2 Dataset\n", + "3. Answering using Base gpt-3.5-turbo-0613 model\n", + "4. Fine-tuning and Answering using Fine-tuned model\n", + "5. **Evaluation**: How well does the model perform?\n", "\n", "### Section B: Few-Shot Learning\n", "5. Using Qdrant to Improve RAG Prompt\n", @@ -39,7 +40,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## 1. Setting Up\n", + "## 1. Setting Up the Environment\n", "\n", "### Install and Import Dependencies" ] @@ -79,20 +80,13 @@ "tqdm.pandas()" ] }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "openai.api_key = os.environ[\"OPENAI_API_KEY\"]" - ] - }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ + "## Section A\n", + "\n", "## 2. Data Preparation: SQuADv2 Data Subsets\n", "\n", "For the purpose of demonstration, we'll make small slices from the train and validation splits of the [SQuADv2](https://rajpurkar.github.io/SQuAD-explorer/) dataset. This dataset has questions and contexts where the answer is not present in the context, to help us evaluate how LLM handles this case.\n", @@ -104,25 +98,54 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 6, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--2023-09-08 16:40:51-- https://rajpurkar.github.io/SQuAD-explorer/dataset/train-v2.0.json\n", + "Resolving rajpurkar.github.io (rajpurkar.github.io)... 185.199.111.153, 185.199.108.153, 185.199.109.153, ...\n", + "Connecting to rajpurkar.github.io (rajpurkar.github.io)|185.199.111.153|:443... connected.\n", + "HTTP request sent, awaiting response... 200 OK\n", + "Length: 42123633 (40M) [application/json]\n", + "Saving to: ‘local_cache/train.json’\n", + "\n", + "local_cache/train.j 100%[===================>] 40.17M 36.1MB/s in 1.1s \n", + "\n", + "2023-09-08 16:40:55 (36.1 MB/s) - ‘local_cache/train.json’ saved [42123633/42123633]\n", + "\n", + "--2023-09-08 16:40:55-- https://rajpurkar.github.io/SQuAD-explorer/dataset/dev-v2.0.json\n", + "Resolving rajpurkar.github.io (rajpurkar.github.io)... 185.199.108.153, 185.199.109.153, 185.199.110.153, ...\n", + "Connecting to rajpurkar.github.io (rajpurkar.github.io)|185.199.108.153|:443... connected.\n", + "HTTP request sent, awaiting response... 200 OK\n", + "Length: 4370528 (4.2M) [application/json]\n", + "Saving to: ‘local_cache/dev.json’\n", + "\n", + "local_cache/dev.jso 100%[===================>] 4.17M 14.0MB/s in 0.3s \n", + "\n", + "2023-09-08 16:40:56 (14.0 MB/s) - ‘local_cache/dev.json’ saved [4370528/4370528]\n", + "\n" + ] + } + ], "source": [ - "# !mkdir -p local_cache\n", - "# !wget https://rajpurkar.github.io/SQuAD-explorer/dataset/train-v2.0.json -O local_cache/train.json\n", - "# !wget https://rajpurkar.github.io/SQuAD-explorer/dataset/dev-v2.0.json -O local_cache/dev.json" + "!mkdir -p local_cache\n", + "!wget https://rajpurkar.github.io/SQuAD-explorer/dataset/train-v2.0.json -O local_cache/train.json\n", + "!wget https://rajpurkar.github.io/SQuAD-explorer/dataset/dev-v2.0.json -O local_cache/dev.json" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## Read JSON to DataFrame" + "### Read JSON to DataFrame" ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ @@ -171,14 +194,14 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Setting up Baseline Model Performance\n", + "## 3. Answering using Base gpt-3.5-turbo-0613 model\n", "\n", - "### Utility Functions: Zero Shot Prompt, API Call to OpenAI" + "### 3.1 Zero Shot Prompt" ] }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ @@ -193,9 +216,22 @@ " Context: {row.context}\\n\\n\n", " Answer:\\n\"\"\",\n", " },\n", - " ]\n", - "\n", - "\n", + " ]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 3.2 Answering using Zero Shot Prompt" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ "# Function with tenacity for retries\n", "@retry(wait=wait_exponential(multiplier=1, min=2, max=6))\n", "def api_call(messages, model):\n", @@ -215,16 +251,23 @@ " return response[\"choices\"][0][\"message\"][\"content\"]" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "⏰ **Time to run: ~3 min**" + ] + }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 12, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 100/100 [02:21<00:00, 1.41s/it]\n" + "100%|██████████| 100/100 [01:28<00:00, 1.13it/s]\n" ] } ], @@ -235,7 +278,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 13, "metadata": {}, "outputs": [], "source": [ @@ -246,25 +289,25 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Fine-Tuning the OpenAI Model\n", + "## 4. Fine-tuning and Answering using Fine-tuned model\n", "\n", "For the complete fine-tuning process, please refer to the [OpenAI Fine-Tuning Docs](https://platform.openai.com/docs/guides/fine-tuning/use-a-fine-tuned-model).\n", "\n", - "### Prepare the Fine-Tuning Data\n", + "### 4.1 Prepare the Fine-Tuning Data\n", "\n", "We need to prepare the data for fine-tuning. We'll use a few samples from train split of same dataset as before, but we'll add the answer to the context. This will help the model learn to retrieve the answer from the context." ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 14, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 100/100 [00:00<00:00, 68067.25it/s]\n" + "100%|██████████| 100/100 [00:00<00:00, 65659.11it/s]\n" ] } ], @@ -298,23 +341,18 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "#### [Optional] Verify the Fine-Tuning Data\n", + "**Tip: 💡 Verify the Fine-Tuning Data**\n", "\n", - "You can see this [cookbook](https://github.com/openai/openai-cookbook/blob/main/examples/Chat_finetuning_data_prep.ipynb) for more details on how to prepare the data for fine-tuning." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Fine-Tune OpenAI Model\n", + "You can see this [cookbook](https://github.com/openai/openai-cookbook/blob/main/examples/Chat_finetuning_data_prep.ipynb) for more details on how to prepare the data for fine-tuning.\n", + "\n", + "### 4.2 Fine-Tune OpenAI Model\n", "\n", "If you're new to OpenAI Model Fine-Tuning, please refer to the [How to finetune Chat models](https://github.com/openai/openai-cookbook/blob/448a0595b84ced3bebc9a1568b625e748f9c1d60/examples/How_to_finetune_chat_models.ipynb) notebook. You can also refer to the [OpenAI Fine-Tuning Docs](platform.openai.com/docs/guides/fine-tuning/use-a-fine-tuned-model) for more details." ] }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 15, "metadata": {}, "outputs": [], "source": [ @@ -370,11 +408,58 @@ " )" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "⏰ **Time to run: ~10-20 minutes**" + ] + }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 16, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "File Status: uploaded\n", + "File Status: processed\n", + "Job Status: running\n", + "Job Status: running\n", + "Job Status: running\n", + "Job Status: running\n", + "Job Status: running\n", + "Job Status: running\n", + "Job Status: running\n", + "Job Status: running\n", + "Job Status: running\n", + "Job Status: running\n", + "Job Status: running\n", + "Job Status: running\n", + "Job Status: running\n", + "Job Status: running\n", + "Job Status: running\n", + "Job Status: running\n", + "Job Status: running\n", + "Job Status: running\n", + "Job Status: running\n", + "Job Status: running\n", + "Job Status: succeeded\n" + ] + }, + { + "data": { + "text/plain": [ + "'ft:gpt-3.5-turbo-0613:qdrant:100trn20230907:7wU85Xwb'" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "model_id = fine_tuner.fine_tune_model()\n", "model_id" @@ -384,12 +469,12 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### Try out the Fine-Tuned Model" + "#### 4.2.1 Try out the Fine-Tuned Model" ] }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 17, "metadata": {}, "outputs": [ { @@ -424,19 +509,26 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### Using the Fine-Tuned Model" + "### 4.3 Answer Using the Fine-Tuned Model" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "⏰ **Time to run: ~5 min**" ] }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 18, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 100/100 [04:54<00:00, 2.94s/it]\n" + "100%|██████████| 100/100 [05:09<00:00, 3.10s/it]\n" ] } ], @@ -449,20 +541,25 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Evaluate Baseline Model Performance\n", + "## 5. Evaluation: How well does the model perform?\n", "\n", "To evaluate the model's performance, compare the predicted answer to the actual answers -- if any of the actual answers are present in the predicted answer, then it's a match. We've also created error categories to help you understand where the model is struggling.\n", "\n", - "1. Expected and Right: The model responsded the correct answer. It may have also included other answers that were not in the context.\n", - "2. Expected but \"IDK\": The model responded with \"I don't know\" (IDK) while the answer was present in the context. *This is a model error* and better than giving the wrong answer. It's better for the model say \"I don't know\" than giving a hallucinated or made up and wrong answer. In our design, we know that a true answer exists and hence we're able to measure it -- this is not always the case. We exclude this from the overall error rate. \n", - "3. Expected but Wrong: The model responded with an incorrect answer. *This is a model ERROR.*\n", - "4. Hallucination: The model responded with an answer, when \"I don't know\" was expected. **This is a model error.** \n", - "5. Did not expect and IDK: The model responded with \"I don't know\" (IDK) and the answer was not present in the context. *This is a model WIN.*" + "When we know that a correct answer exists in the context, we can measure the model's performance, there are 3 possible outcomes:\n", + "\n", + "1. ✅ **Answered Correctly**: The model responsded the correct answer. It may have also included other answers that were not in the context.\n", + "2. ❎ **Skipped**: The model responded with \"I don't know\" (IDK) while the answer was present in the context. It's better than giving the wrong answer. It's better for the model say \"I don't know\" than giving the wrong answer. In our design, we know that a true answer exists and hence we're able to measure it -- this is not always the case. *This is a model error*. We exclude this from the overall error rate. \n", + "3. ❌ **Wrong**: The model responded with an incorrect answer. **This is a model ERROR.**\n", + "\n", + "When we know that a correct answer does not exist in the context, we can measure the model's performance, there are 2 possible outcomes:\n", + "\n", + "4. ❌ **Hallucination**: The model responded with an answer, when \"I don't know\" was expected. **This is a model ERROR.** \n", + "5. ✅ **I don't know**: The model responded with \"I don't know\" (IDK) and the answer was not present in the context. **This is a model WIN.**" ] }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 30, "metadata": {}, "outputs": [], "source": [ @@ -471,11 +568,11 @@ " self.df = df\n", " self.y_pred = []\n", " self.labels = [\n", - " \"Expected and Right\",\n", - " \"Expected but IDK\",\n", - " \"Expected but Wrong\",\n", - " \"Hallucination\",\n", - " \"Did not Expect and IDK\",\n", + " \"✅ Answered Correctly\",\n", + " \"❎ Skipped\",\n", + " \"❌ Wrong Answer\", \n", + " \"❌ Hallucination\", \n", + " \"✅ I don't know\"\n", " ]\n", " self.answers_column = answers_column\n", "\n", @@ -485,16 +582,16 @@ " actual_answers = [ans.lower() for ans in row[\"answers\"]]\n", "\n", " y_pred = (\n", - " \"Expected and Right\"\n", + " \"✅ Answered Correctly\"\n", " if not is_impossible\n", " and any(ans in generated_answer for ans in actual_answers)\n", - " else \"Expected but IDK\"\n", + " else \"❎ Skipped\"\n", " if not is_impossible and generated_answer == \"i don't know\"\n", - " else \"Expected but Wrong\"\n", + " else \"❌ Wrong Answer\"\n", " if not is_impossible and generated_answer not in actual_answers\n", - " else \"Hallucination\"\n", + " else \"❌ Hallucination\"\n", " if is_impossible and generated_answer != \"i don't know\"\n", - " else \"Did not Expect and IDK\"\n", + " else \"✅ I don't know\"\n", " )\n", " return y_pred\n", "\n", @@ -522,21 +619,21 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 31, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "Expected and Right 43.00%\n", - "Expected but IDK 0.00%\n", - "Expected but Wrong 10.00%\n", - "Hallucination 47.00%\n", - "Did not Expect and IDK 0.00%\n", + "✅ Answered Correctly 44.00%\n", + "❎ Skipped 0.00%\n", + "❌ Wrong Answer 9.00%\n", + "❌ Hallucination 47.00%\n", + "✅ I don't know 0.00%\n", "Name: count, dtype: object" ] }, - "execution_count": 19, + "execution_count": 31, "metadata": {}, "output_type": "execute_result" } @@ -547,21 +644,21 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 32, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "Expected and Right 34.00%\n", - "Expected but IDK 17.00%\n", - "Expected but Wrong 2.00%\n", - "Hallucination 8.00%\n", - "Did not Expect and IDK 39.00%\n", + "✅ Answered Correctly 32.00%\n", + "❎ Skipped 18.00%\n", + "❌ Wrong Answer 3.00%\n", + "❌ Hallucination 7.00%\n", + "✅ I don't know 40.00%\n", "Name: count, dtype: object" ] }, - "execution_count": 20, + "execution_count": 32, "metadata": {}, "output_type": "execute_result" } @@ -572,7 +669,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 33, "metadata": {}, "outputs": [], "source": [ @@ -580,6 +677,15 @@ "df.to_json(\"local_cache/100_val_ft.json\", orient=\"records\", lines=True)" ] }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [], + "source": [ + "df = pd.read_json(\"local_cache/100_val_ft.json\", orient=\"records\", lines=True)" + ] + }, { "attachments": {}, "cell_type": "markdown", @@ -590,12 +696,24 @@ }, { "cell_type": "code", - "execution_count": 144, + "execution_count": 36, "metadata": {}, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/opt/homebrew/Caskroom/miniconda/base/envs/fst/lib/python3.9/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n", + " if pd.api.types.is_categorical_dtype(vector):\n", + "/opt/homebrew/Caskroom/miniconda/base/envs/fst/lib/python3.9/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n", + " if pd.api.types.is_categorical_dtype(vector):\n", + "/opt/homebrew/Caskroom/miniconda/base/envs/fst/lib/python3.9/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n", + " if pd.api.types.is_categorical_dtype(vector):\n" + ] + }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABD8AAAIxCAYAAABKExMEAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAABuMUlEQVR4nO3dd3xP1+PH8XemSMwQm1oVipAgsWMlRSmxqdi0CKXVGl+lWkqNUqM2RcUmtffeqy1Ve8aovSIhkXx+f+SXT/tpEpII4Xo9H4886nPuufee+/mcqPv+nHuOlclkMgkAAAAAAMCgrFO6AQAAAAAAAC8T4QcAAAAAADA0wg8AAAAAAGBohB8AAAAAAMDQCD8AAAAAAIChEX4AAAAAAABDI/wAAAAAAACGRvgBAAAAAAAMjfADAAAAAAAYmm1KNwAAAOB1Nm7cOI0fPz5BdXPmzKnNmzcn+Njnz5/XiRMnVKtWrSS1zdXVVYULF9avv/76zHp9+vTRsmXLnns8T09PzZkzJ0lteZUiIiK0du1aBQUF6cyZM7p9+7YyZMigUqVKqXXr1vLw8EjpJr5y/v7+2r9/vw4cOKB06dKldHMA4LVD+AEAAPAMnp6eCggIsChbtmyZrly5olatWlncaKZNmzbBxz1x4oQaNWqk5s2bJzn8SCw/Pz/lzJkz3u3P2va6+Pvvv/Xpp5/q999/V86cOVW+fHk5Ozvr0qVL2rRpk9atW6evvvpKH330UUo39ZXy8/OTp6enUqVKldJNAYDXEuEHAADAM3h5ecnLy8uibP/+/bpy5Ypat26tXLlyJem49+/fV0RERHI0McH8/PxiXcub5MmTJ+rQoYNOnz6tbt266eOPP5adnZ15+/nz59WqVSt9++23ypUrl7y9vVOwta9WgwYNUroJAPBaY84PAAAAvBEmT56s06dPq0mTJgoICLAIPiQpX758Gjp0qEwmkyZMmJBCrQQAvI4IPwAAAJLRjRs3NGDAAHl7e6tYsWLy9vbWgAEDdOPGDXOdcePGqVWrVpKk2bNny9XVVfv27TNvDwoKkr+/v8qUKaNixYqpYsWK+vzzzxUcHPzKrqNPnz5ydXXVkSNHVLt2bRUvXlzNmjWTyWSSq6ur+vTpo0mTJql06dIqXbq0fv75Z0lSVFSUAgMDVb9+fbm5ualUqVJq27atdu3aZXH8ffv2ydXVVYGBgfrss8/k5uamihUr6tChQ3G2x2QyaenSpZKkTz75JN52x7xXAQEBMplM5vKHDx9q+PDhqlGjhooVK6by5cvr888/1/nz5y32X7p0qVxdXbV//35NmTJF1apVk5ubm+rXr68dO3ZIkhYvXqxatWqpRIkSqlu3rtauXRvne3f79m198cUXKl26tDw9PdWlSxedPn06VpuvXLmigQMHqkaNGipevLjc3d3VoEEDzZs3z6LeuHHj5Orqqj179qhx48YqVqyY3n//fT169Ej+/v5ydXXVgwcPzPV37typ1q1bq1y5cnJzc1PdunU1efJkhYeHWxw3oZ/Z5cuX5erqqnHjxmnTpk1q1KiR3NzcVK5cOfXv31937tyJ93MBgJTGYy8AAADJ5NKlS2revLlu3bql8uXLq1atWjp58qQWLFigzZs3a968ecqdO7c8PT3l5+enZcuWqUSJEqpUqZJ5vo3vv/9eM2bMUOHCheXn5ycrKysdOHBAK1eu1KFDh7R27Vo5ODi8smvq3LmzihcvrgoVKsjR0VFWVlaSpB07dmjDhg3y8/PTrVu3VKJECUVFRalnz55au3atcufOrYYNGyo0NFSbNm1S+/bt45yLY8KECXJ0dFTLli115swZFS1aNM52nDp1SteuXVP+/PmfOzdJp06dLF7fvXtXzZs31/nz51WyZElVr15dwcHBWr16tbZu3aoZM2aoRIkSFvt89913+vvvv/XBBx8oNDRUv/76qzp37qxmzZppyZIlql27tsqWLaugoCD17NlTefLk0XvvvWdxjI4dO+rmzZtq2LCh/v77b23YsEH79+/XL7/8osKFC0uKDhQaNWqksLAw+fj4KHv27Lp+/brWrVunr7/+WpGRkWrZsqXFcXv16qX8+fPL399fjx49kpOTU6z34ODBg/rkk0+UMWNG1a5dW6lSpdLu3bv1ww8/6OLFi/ruu+8kKUmf2ZYtW/TTTz+pSpUq8vLy0q5du7Ro0SKdOXNG8+fPf+ZnAwAphfADAAAgmXz11Ve6deuWBg8erMaNG5vLAwMDNWjQIPXv31+zZs0yz7sRE35069ZNknT9+nX9/PPPKlOmjGbNmiUbGxvzMTp16qRt27bp4MGDqlixYpLat2zZMu3fvz/e7c2aNZOLi4tFmYeHh8aNGxer7q1btzRx4kRVq1bNXBYUFKS1a9eqYsWKGjdunBwdHSVJwcHBat68ub777jtVrlxZuXPnNu/z6NEjBQUFxTrvf/3999+SpLx58z73Ov9rxIgROn/+vDp37qwePXqYy7dt26aPP/5YX375pVavXm3xfgcHB2vFihXKkSOHJMnFxUWTJ09WYGCgli5dag4v3Nzc1KdPH61atSpW+HHv3j39+uuvcnZ2liStW7dO3bt315AhQ8yr6kyZMkV3797VzJkzVb58efO+LVu2VOPGjbVy5cpY4Ue2bNk0a9YsWVvHP4h79uzZioiIUGBgoPn9joiIUOPGjRUUFKR+/fopTZo0Wr58eaI/s2PHjmnMmDHmiXp79OghPz8//fbbbzp79qwKFCiQgE8FAF4twg8AAIBkcO3aNe3du1elS5e2CD4kqUWLFlq6dKn27t2ry5cvxztJqr29vYYPH66CBQta3IhLUpkyZbRt2zbdvn07yW183nK3NWrUiBVC+Pr6xlnXwcEh1oSiMcf/+uuvzTfRkpQ7d2517txZ33zzjYKCgsxhjxQdrjwv+JCiH1uRFOcoh2cJDw/XqlWrlDNnTnXv3t1im7e3t3x9fbVu3TodPHjQYjJYX19fc/AR005JKleunDn4kKLDDyn60ZX/6ty5szn4kKT3339fpUqV0v79+3X9+nVlzZpVH374oUqUKGERfMQc18HBIc7P28fH55nBhxQ9okOSjh49ag4u7OzsNHXqVDk4OChNmjSSkvaZ5c6d22KFIjs7O5UrV06nT5/WlStXCD8AvJYIPwAAAJLB8ePHJUmlS5eOc7uHh4eOHj2qEydOxBt+ZMyYUXXr1lVUVJROnTqls2fPKjg4WCdPntTu3bsl/XNTmxSzZ89O9Gov8bU1W7ZssQKaEydOKGvWrBajBGKUKlXKXCchx/+vDBkySJLFnBYJcf78eT1+/FgeHh5xBgalSpXSunXrdOLECYv3Jk+ePBb1UqdOHWd7Y5aW/e88GlJ0YPVfbm5uOnTokPm9ipkz5d69ezp+/LguXbqk8+fP6/fff9eTJ08UGRkZ6xgJec8aN26sjRs3qmfPnvrxxx9VqVIlVa5cWWXLlpW9vb25XlI+s7hG38Qs8xzX+wAArwPCDwAAgGQQEhIi6Z+bwP/KkiWLJOnx48fPPM769es1atQoXbhwQZLk6OioYsWKqXDhwtq9e7fFJJ6vQnzzi8RVHhISosyZM8dZP77rjwkPnifm5vzixYvPrRscHKwsWbIoVapUSf5cYsKO//p3cPA8WbNmjVUW8/7EjGS5f/++hg4dqpUrVyoiIkJWVlbKmTOnypYtq7/++ivO4yZkzhdvb2/Nnj1b06dP1+7duzVnzhzNmTNHGTJkUEBAgPz9/SUl7TOL6z2ImQsGAF5XhB8AAADJIOZxjOvXr8e5PWbEQswIhrj88ccf+vTTT5UtWzb98MMPKl68uHLnzi0rKytNmTLFPPrjdeXk5BTv9d+/f1/Ss6//Wd555x3lyZNHFy5c0JUrV5456eknn3yi4OBgLVmyJFk+l6R6/PhxrBAlJvTImDGjJOmLL77Qtm3b1KxZM9WrV0+FChUyP5KyYsWKFzq/p6enPD09FRoaqoMHD2rr1q1atmyZBg8erDx58sjb2/ulfmYA8DphqVsAAIBkUKRIEUnS4cOH49x+4MABWVlZqWDBgpLi/qZ81apVioqK0sCBA/XBBx8oT5485nrnzp2TpFc+8iMxChcurIcPH+rUqVOxth08eFCSzNefFH5+fpKkiRMnxltn165dOnPmjLJmzaoCBQoof/78SpUqlY4ePRrnIxkHDhx44XbF5+jRo7HKfvvtN9na2qpo0aJ68OCBtm3bpmLFimnQoEHy8PAwBx+XL1/WkydPkvx5z5o1S2PGjJEUPXqocuXKGjBggAYOHChJ5iWFX/ZnBgCvC8IPAACAZJAjRw55eXnpzz//VGBgoMW2RYsW6fDhw/Ly8lK2bNkkSba20QNwIyIizPViHgG5deuWxf579uzRypUrJUlPnz59adfwoho0aCBJGjJkiEJDQ83lwcHBmjBhguzs7PTBBx8k+fjt2rVTzpw5tWjRIk2YMCHWfBhHjx5Vr169JEWPqLC2tpa9vb0++OAD3bhxQ2PHjrWov337dq1Zs0bvvPOOeULT5DRu3DjzYzeStHbtWu3bt0/Vq1dXhgwZZGdnJ2traz148MAimHn8+LG+/fZbSZb9IzF27typSZMm6ffff7coj5mYNWYy15f9mQHA64LHXgAAAJLJN998o48++kiDBg3Shg0b5OrqqlOnTmnXrl3KkiWL+YZW+mc+iDVr1sjR0VF+fn6qXbu2Zs6cqUGDBunAgQNycXHRyZMntXPnTmXMmFG3b9/WvXv3kty+5y11K0UvqZvQeTj+q169etq8ebPWrVunDz/8UJUrV1ZoaKg2bdqkkJAQ9e/fP9ZEoonh4OCgmTNnql27dho7dqyWLFmiChUqKE2aNDp16pT5saDPP//cYpWaL774QocPH9bUqVN14MABubu7Kzg4WJs3b5aTk5NGjBjxUuasOH/+vOrXr68qVaro+vXr2rhxo7Jmzao+ffpIip5XxMfHR+vWrVPjxo1VoUIFhYaGasuWLbp165bSp0+vhw8fKioq6rmru/xXt27dtG/fPrVq1Uo1a9ZU1qxZdebMGW3ZskUFChTQhx9+KOnlf2YA8Log/AAAAEgmefPm1ZIlSzRhwgRt3bpVBw4cUJYsWeTv76/OnTsrU6ZM5ro5c+ZUjx49NGvWLM2dO1cFChRQw4YNNWXKFI0dO1YbN26UjY2NeYnWRo0aqXLlytq2bZs+/vjjJLXveUvdSlLr1q2THH5YWVlpzJgxmjt3rhYvXqzFixcrderUKlmypNq3b6+yZcsm6bj/9s477+jXX3/VkiVLtHr1am3ZskX37t1ThgwZVKtWLbVp08a8/GwMZ2dnLVy4UJMmTdK6dev0yy+/yNnZWfXr11fnzp1f2s39qFGjtGTJEi1ZskSpU6dW/fr11aNHD4uJUL/77jtly5ZNGzdu1C+//CIXFxcVL15cnTp10sqVKzVr1izt27dP5cqVS9S53dzc9Msvv2jixInau3ev7ty5oyxZsqhVq1bq3LmzeVnbV/GZAcDrwMr0Oj84CgAAALxh+vTpo2XLlikoKMg8FwwAIGUx5wcAAAAAADA0wg8AAAAAAGBohB8AAAAAAMDQmPMDAAAAAAAYGiM/AAAAAACAoRF+AAAAAAAAQ7NN6QYAQGL99ttvMplMsrOzS+mmAAAAAEhBERERsrKykru7+zPrMfIDwBvHZDKZf/B2MplMCg8Ppw+85egHoA9Aoh+APvC2S+h9ASM/ALxx7OzsFB4eroIFC8rR0TGlm4MUEBoaquPHj9MH3nL0A9AHINEPQB942x09ejRB9Rj5AQAAAAAADI3wAwAAAAAAGBrhBwAAAAAAMDTCDwAAAAAAYGiEHwAAAAAAwNAIPwAAAAAAgKERfgAAAAAAAEMj/AAAAAAAAIZG+AEAAAAAAAyN8AMAAAAAABga4QcAAAAAADA0wg8AAAAAAGBohB8AAAAAAMDQCD8AAAAAAIChEX4AAAAAAABDI/wAAAAAAACGRvgBAAAAAAAMjfADAAAAAAAYGuEHAAAAAAAwNMIPAAAAAABgaIQfAN5YVlZWKd0EpBArKyulTp2aPvCWox+APgCJfgD6ABLGymQymVK6EQCQGEePHpUkFS9ePIVbAgAAALxdoqKiZG39+oyjSOi9ge2raAwAvAwjRyxUcPDNlG4GAAAA8FbIndtFvb5oktLNSBLCDwBvrODgmzp79mpKNwMAAADAa+71GasCAAAAAADwEhB+AAAAAAAAQyP8AAAAAAAAhkb4AQAAAAAADI3wAwAAAAAAGBrhBwAAAAAAMDTCDwAAAAAAYGiEHwAAAAAAwNAIPwAAAAAAgKERfgAAAAAAAEMj/AAAAAAAAIZG+AEAAAAAAAyN8AMAAAAAABga4QcAAAAAADA0wg8AAAAAAGBohB8AAAAAAMDQCD8AAAAAAIChEX4AAAAAAABDI/wAAAAAAACGRvgBAAAAAAAMjfADAAAAAAAYGuEHAAAAAAAwNMIPAAAAAABgaIQfAAAAAADA0Ag/AAAAAACAoRF+AAAAAAAAQyP8AAAAAAAAhkb4AQAAAAAADI3wAwAAAAAAGBrhBwAAAAAAMDTCDwAAAAAAYGiEHwAAAAAAwNAIPwAAAAAAgKERfgAAAAAAAEMj/AAAAAAAAIZG+AEAAAAAAAyN8AMAAAAAABga4QcAAAAAADA0wg8AAAAAAGBohB8AAAAAAMDQCD8AAAAAAIChEX4AAAAAAABDI/wAAAAAAACGRvgBAAAAAAAMjfADAAAAAAAYGuEHAAAAAAAwNMIPAAAAAABgaIQfAAAAAADA0Ag/AAAAAACAoRF+AAAAAAAAQyP8AAAAAAAAhkb4AQAAAAAADI3wAwAAAAAAGBrhBwAAAAAAMDTCDwAAAAAAYGiEHwAAAAAAwNAIPwAAAAAAgKERfgAAAAAAAEMj/AAAAAAAAIZG+AEAAAAAAAyN8AMAAAAAABga4QcAAAAAADA0wg8AAAAAAGBohB8AAAAAAMDQCD8AAAAAAIChEX4AAAAAAABDI/wAAAAAAACGRvgBAAAAAAAMjfADAAAAAAAYGuEHAAAAAAAwNMIPAAAAAABgaIQfAAAAAADA0Ag/AAAAAACAoRF+AAAAAAAAQyP8AAAAAAAAhkb4AQAAAAAADI3wAwAAAAAAGBrhBwAAAAAAMDTCDwAAAAAAYGiEHwAAAAAAwNBsU7oBAAAAAACkpJo1yyigW/04t4WEhKlZ08FauWrIc48zevRibdr4m6ysrNSocWW9/35ppUvnpAsX/taM6Wt04kSwRf3K3m768sum2rjxsMaMXpIcl4J4MPIDAAAAAPBWy5c/e7IcJzIySpL0/vul1bq1rzJlSqcnTyL03nvv6OtBrZUunaO5rrW1lZo3r6rIyEgtmL8lWc6P+DHyAwAAAADwVsubN6sk6cyZK5o/zzKIePr/gcbgb3+JtZ+NjbW6dfdTmjSpderkZe3c8ackqVKl4pKk6dPXaM3q/Zox8wtlypROHqXe1dYtf0iKHvWRO3cWbdx4WNeu3Xlp14Zor93Ijz59+sjV1dXip1ixYvL29la/fv10/fr1lG7iK3fp0qUE1z148KD8/f1VqlQplStXTn379tWtW7cStO8PP/wQ672P+Xnw4EGytzUhxo0bJ1dXV509ezZZjxufq1evqmfPnipbtqxKlSqlrl27Kjg4OFa9yMhITZ8+Xe+//77c3Nz0/vvva8aMGYqMjIz32MHBwSpRooS2b98ea5vJZNKiRYtUt25dlShRQtWrV9f48eMVERHx3Db/+3fm4sWL8dYbNGiQXF1dVaFCheceM6H27dsnV1dXzZs3L9H7urq6qmfPnsnWFgAAACCp8ubNJkk6cSJYe/cet/g5eOCkJMUq37v3uLJkzag0aVIrPDxCo0Yt0tOn0fcDzpnSSpKuXL6lyMgo3bhxV5KUKVM6STGjPqox6uMVem1HfvTt21cZM2aUJIWHh+v8+fNauHChDhw4oGXLlilNmjQp3MJXo3379kqXLp1Gjx793LoHDx5Uq1atVKBAAfXo0UP37t3Tzz//rIMHDyboPTt16pRy586tbt26xdqWOnXq555/wIABOnnypBYsWPDcuq+je/fuqVWrVgoJCVHr1q1lb2+vGTNm6KOPPlJQUJCcnZ3NdQcMGKDFixerfv36atOmjXbt2qXvv/9ed+/e1eeffx7r2Pfv31eXLl30+PHjOM89efJkjR49WlWrVlWLFi10/PhxTZgwQadPn9aPP/6Y4GvYuHGj2rdvH6vcZDJpw4YNCT4OAAAA8LbImjWjnJwcJElXr95WoUK55OTkoPMX/ta9uyHx7ufikl4tWlSTJP0atFtXrvzzpfOdOw+VO3cW5cyVWUeOnFOWLNH3trdvR3+pXKVqSeXMmZlRH6/Qaxt+1KhRQ7ly5bIoc3d3V0BAgIKCgtSyZcsUatmrtXPnTtWuXTtBdYcNGyZnZ2cFBgYqbdropLFYsWL65JNPtHjxYrVp0+aZ+586dUolSpRQvXr1ktzWzJkzJ2nf18HPP/+sy5cva/HixSpWrJgkqVKlSqpfv76mTp2q3r17S4oe7bB48WK1b99eX375pSSpefPm6tKli2bMmKGPP/7YImg6efKkunfvrgsXLsR53gcPHmj8+PGqVKmSJk2aZC53cnLSjBkzdPz4cRUpUuS57c+dO3e84cfhw4d18+ZNiwAHAAAAgJQvXzbzn1u18pGDg72k6Pk7Vq3aq2lT1ygqKirWfi0+qq7UqVPp0aPHWrRom8W2nTv/VIkSBdS+fS01bVpVGTOmUUhImA4fOi1ra2s1a8ZcH6/aa/fYy7N4eXlJks6cOZPCLXn9PHnyRBkyZFCjRo3MwYckeXp6Soq+AX+WkJAQXb16VQUKFHip7XydrVy5UiVLljQHH5JUqFAhlS1bVitXrjSXLVmyRI6OjuratavF/h9//LE++eQTPXr0yFz2yy+/qEGDBnr48KEaN24c53kvX76sYsWKqUWLFhblMZ/diRMnEtR+Hx8f/f7773E+5rRhwwblzZtXBQsWTNCxAAAAgLdF3n+FHzHBhxQ9n8eHH5bXJ5/UibVPunSO8vZ2kyRt2HBIoaFPLLavW3tAc2Zv0O3bD+TgYKcTxy/p669n68GDUFWv4a4cOTJpy5Y/GPXxCr1R4cfVq1clSe+8845F+f79+/XJJ5+obNmyKlq0qMqXL6/PPvvMXD/Gpk2b1LhxY3l4eMjd3V3NmzfXxo0bY51n+fLlatCggdzc3OTl5aVPP/00wXNZ7N69W82aNZO7u7u8vb01YcIEjR8/Xq6uruY6MfNYnDt3Tu3atVOJEiVUqVIlDRs2TGFhYZKib4hj9lm9erVcXV21b9++eM+bKlUqTZs2TT169LAoP378uCQpe/Znz1585swZmUwmc/gRFhYWZ7oZH1dXV125ckV//PGHXF1dtXTpUvM1jBw50qLukydP5Orqqj59+pjL/P395e/vr59++kkeHh7y8vLS7t27zdsvXbqk9u3by83NTRUrVtSwYcMUGhoa67hjx46Vj4+PihUrpkqVKmnQoEG6e/fuc9t///59BQcHWwQfMYoWLaobN27oxo0bkqIfL/Lw8JCTk5MkKTQ0VFFRUSpRooS6deumrFmzmvc9ceKE6tevrxUrVsjDwyPOc7/33nuaP3++qlWrZlGe0M8uho+Pj6KiorR58+ZY29avX6/3338/zv2uX7+uvn37qnz58ipWrJhq1aqlqVOnxpq/5N69exowYIAqVKggd3d3de/eXTdv3ozzmC/yOwQAAAC8Sqns7RQSEqb79x/p229/UQO/gerXd7ru34/+UrNmrTLKkSOTxT7v1ywje3s7RUVFacXyPbGOGRVl0oIFW9Wh/Sg1bvSNevWarBPHL8nGxlpNm1Yxj/pwcnJQz54N9cvcvpo1q7c6dKwtW1ubV3Ldb5vXNvx48OCB7ty5ozt37ujGjRvav3+/+vXrp5w5c6phw4bmenv27FGbNm10+/ZtdenSRV999ZUqVqyo1atX6+OPPzbXO3jwoLp37y47Ozt9/vnn6tWrl0JDQxUQEKA9e/7prD/99JO++OILZcmSRb1791bLli114MABNW7c+JmTSUrStm3b1KFDBz148EDdu3eXn5+fZsyYoTlz5sRZv3379nr69Km++OILVahQQTNnztQnn3wik8kkZ2dnDR8+XJJUsmRJDR8+PFGjMq5fv67Vq1erV69eypw5s5o2bfrM+qdOnZIk7dixQ1WqVFHJkiVVqlQpff311+ZA5lmGDx+ujBkzKk+ePBo+fLjKlCmT4LbG+PPPP7Vo0SJ9/vnnatiwodzc3MzbPvvsM0lS7969ze9V165dZTKZJEkRERHq0KGDJkyYIDc3N/Xr108+Pj5auHChmjVrpvv37z/z3DET6f47uIiRJUsWSdK1a9f05MkTXb16VTlz5tSKFSvk6+srd3d3lSpVSkOGDFF4eLjFvgMGDNCQIUOUKVOmWMeNy9OnT3Xx4kXNmDFDP/30kzw9Pc0jnp6naNGiypkzZ6xA79ixY7py5Uqc4cfVq1fVsGFDrV69WvXq1VPfvn2VN29ejRw50vyeS9Hz7rRq1UpLlixR7dq19dlnn+nWrVv66quvYh3zRX6HAAAAgFdt1qz1atZ0sNq0Hq59e48rPPypjhw5p6VLd0iSrK2tVapUIYt9ataMvt85deqyrl9//petMWr4lFK2bM7mUR9f9m6q6jU8dOXyLT15Eq769SuoQ8eETXuAxHlt5/zw8/OLVWZjY6OffvpJ6dKlM5fNnDlTGTNm1OzZs82TcjZr1kxPnz7VqlWrdP36dWXNmlWrVq3S06dPNX78ePO8B7Vr11azZs108uRJlStXTsHBwRo/frz8/f3Vv39/8zkaN26s2rVra+TIkRo3bly8bR48eLCyZMmihQsXmud8qF69eryPO+TPn19Tp06VtXV0BpU5c2ZNnTpVmzZtUo0aNVSvXj19+eWXypEjR6Lm4YiIiFCVKlUUFRUlGxsbDRs2LM6b+n+LCT+OHj2qgIAApUmTRtu2bdO8efN09uxZzZo1y9zOuNSrV08//vijMmbMaG7r5cuXE9xmKXoExYQJE1S+fPlY28qWLauffvpJVlZW+uijj5QpUyZNnz5dW7duVdWqVbV06VLt379fPXr0UOfOnc37lS5dWj179tSECRPUr1+/eM8d86hKXBO7Ojg4mNsXEhIik8mkffv2acWKFerUqZMKFCigLVu2aPbs2bpz545GjRpl3tfe3j7W8Z7lwIED5rlZMmXKpP/973+ysrJK8P4+Pj4KDAxUSEiIuQ+uX79euXLlUtGiRWPVHzVqlG7evKm5c+eqdOnSkqSPPvpIgwYNUmBgoDZu3KgaNWpoyZIlOnnypEaMGKEPP/xQUvQ8Jx07drQYofOiv0MAAABASomIeGrx+uKFf1YazZz5n3vQfPmzK2vW6AlM9+9/9vQC/2Zra6OmTb3Noz4yZHBSqVKFFBHxVF9/PUuFC+fRt4Pbqlq1kpo8aaX5i14kj9d25MeIESM0c+ZMzZw5U1OmTNG3335rnrwzKCjIXG/ixIlauXKlxU1rSEiIUqVKJUnmRyOyZYt+juvbb7/Vn39Gr72cMWNGrVu3znyzuXHjRkVGRqpGjRrmUSd37tyRvb29PD09tX37dj19avkLEePEiRO6dOmSmjZtajHZZfHixeNdWrRTp04WgUK7du0kKc7HFhIjIiJCw4cP16hRo1SmTBl98cUXmjJlyjP3qVSpkrp06aIFCxaoUaNGqlmzpoYOHar27dtr//79r2SlEFtbW/MN+H+1b9/eIgRo3bq1JGnLlugJgjZu3CgHBwfzexijdu3aypcvX5yPN/1bzF8szwoarKyszCM7Lly4oNGjR6tz587y9fXV0KFD1aBBA61cuVLHjh17zpXGL3v27Bo3bpwGDRokR0dHNW3a9JmPO/2Xj4+PwsPDLZbTXb9+vXx9fWPVjYyM1ObNm+Xp6Rnrfe/SpYskmd+3rVu3Kl26dKpT55/nHW1tbWNNPPwiv0MAAABASsiXL5tKl3GVR6l3Lcr/Pf9HWNg/I7xLlshv/vNvh08n+Dw+vqWUJUtG86iPbNmiv5R/8CBUYWHh5hEkjo4OSp/BKUnXgvi9tiM/PDw8Yq32Uq9ePdWtW1dDhw5VzZo15eDgIBsbG127dk3jx4/X6dOndfnyZV29etV8Mxszb0XLli21e/durV69WqtXr5aLi4sqV66sevXqmR8riBmSH3NjHZc7d+6YH4P4t5h98+bNG2tbgQIFtHPnzljl775r+cvl7Oys9OnT68qVK/Ge/969e4qIiLAoS58+vcUIA0dHR9WtW1dS9M1/ixYtNG7cODVp0kQZMmSI87je3t7y9vaOVd6iRQtNnz5de/fu1fvvvx/nHA8uLi7xtjcx0qZNG+9Iifz581u8zpo1qxwcHMzv1eXLl5UjRw5z6PVvBQoU0KZNmxQVFaVHjx7FWm42bdq0cnR0lKQ4H/GJqZ8mTRpzyObi4qIqVapY1PPz89PSpUu1b9++OEdZJETevHnNfah69eqqVauWRowYocWLFydofw8PD2XOnFmbNm1S7dq1debMGZ07d07Dhg2LVffu3bsKDQ2N9d5K0deXLl06i/c3V65csUb//PdRrBf5HQIAAABSwlcDWipLloy6f/+ROnYYZZ689N+Puhw/8c/8de8Wir5Pffo0Uhf+NTrkWWxtbdSkiXecK7zY2Fib6+DleW3Dj7ikSpVKVatW1c8//6xz587pvffe088//6yhQ4cqT548KlOmjKpWrapixYppx44dmjx5snlfJycnzZo1S0ePHtWmTZu0c+dOLVu2TEuWLFFAQIC6detmDkrGjh1rsWLKv6VPnz7O8phvs+O6eY/rhlyK/ub8vyIjI+Msj9GtWzft37/fomz27NnxzgthbW2tmjVr6rffftOZM2fiHVkRn5i5KmJG0FSsWDFWneetJPNf/51IM4aNTfy/7PGNyIh5r541JCwqKkq2traytrbWkCFDtGzZMovtQ4cOlY+PjyTFGe7ETHSaNWtWpU+fXo6OjnHO4RFT9u/VXl6Ei4uLypQpox07digqKuqZjx3FsLa2VvXq1bVq1SqFh4dr/fr1yp49u8X8KTFi3rP43ruoqCjZ2dlJin7//xsaxdSJ63VSfocAAACAlLBjx59q2LCS0qd30jffttHqVftUsGBOVa/hLkm6cOFvHfnjnLl+7lzRX/5euXIr1qMy8alZs4xcXDJo48bD5hVe/v47+r/p0jkqS5YMKlgwhyQpNPSJ7t9LnnsK/OONCj+kf26urK2t9eTJE40ZM0bu7u6aPXu2RfCwfPlyi/2Cg4N148YNlSpVSsWLF1ePHj107do1tWnTRjNmzFBAQIBy5swpKXqCS3d3d4v9YyZFjW9kQp48eSRFPw7xX/FN8njp0iWL1UVu376tkJCQWKvZ/Fvv3r314MEDi7LChQvrzJkz6tSpk1q2bBnr0Y+QkBBJ/8xdEZc2bdrI2tpaM2bMsCg/dy76lzx37tySoudYSaiYMOO/k4DGtRTr81y5ckUZM2Y0v7569aoeP35sbleuXLm0f/9+PX78ONZ1njt3zvzYU4cOHcxzVsQoWLCg0qZNqzx58sT5yMqxY8eULVs28wiXIkWK6Pjx4woPD7foD8HBwZISvjpLjGXLlmnkyJGaOHFirJDi0aNHsrOzS1DwEcPHx0cLFizQvn37tH79evn4+MQZHjk7O8vR0VHnz5+Pte3GjRsKCQkxv2+5cuXS3r17473mGC/yOwQAAACkhLm/bJSHe0Hly59dhQvnUeHCeczbHj4M1fDvF1h8YZjZJfrLvNu3H8Q6Vlzs7GzVuHHsUR/37j3S4cOn5eHxrsaOC5C9ffTt+dYtvzPfx0vw2s75EZewsDBt2rRJzs7OKliwoB4/fqywsDC98847FjdUV69e1fr16yX9M8pgzJgxatu2rflbfCn6JjVLliyytraWlZWVeanRyZMnW3yjHRwcrM6dO2vUqFHxjkAoWrSocuXKpaVLl1o8OnHx4kVt27Ytzn1mz55t8XratGmSpJo1a5rLrK2tLdpSrFgxlS9f3uInffr0eueddxQSEqL58+dbnP/+/ftavHixsmXLpiJFisTZDknKkCGDdu/erd9++81cFhUVpfHjx8vGxka1a0fPOPzfc/97ctL/tjVDhgyytbU1L9kaY+XKlfG2Iz4LFy60eB3zXsWM2KhevbqePHkSK5xZu3atLly4oKpVq0qKDjr+2/6YRzBq1qypQ4cOWQQgp06d0t69ey3muqhbt65CQ0M1d+5cc1lUVJRmz54tOzu7WI/DPE/BggV169YtzZo1y6L8jz/+0MGDB2Mtgfs8ZcuWVbp06TRnzhwdP3483iVubWxsVKVKFe3fv18HDx602DZp0iRJMp/b19dXYWFhFisXmUymWCsZvcjvEAAAAJASwsOfqk+faVq2dKf+/vuOIiKe6u7dh9q86Td17zZBly7dsKgfMxdIyMPnr4opSbVqlVGmzOnMc3382/DvF2jzpt/09GmkQkIea/ny3Zo6dXXyXBgsvLYjPzZu3Gj+pt9kMun27dtasmSJrly5oiFDhsjW1lbp06eXu7u7VqxYoXTp0qlQoUK6dOmSFi5caA4AYh5BaNu2rdavX6+WLVuqSZMmSpcunfbu3av9+/frk08+kRQ9B0fbtm01c+ZMffTRR6pVq5YeP36sX375RZGRkerTp0+87bW2ttb//vc/de3aVU2aNFHDhg0VEhKiX375Jd591q5dq9DQUJUrV06HDx/WypUrVbduXXl6eprrODs769ChQ1qwYIEqVaqkHDlyxHksOzs7ff311+rZs6eaN2+uBg0a6PHjx5o/f75u3bqliRMnmkdi3Lp1S7t27VKePHnM38736tVLu3btUseOHeXv7y9nZ2etW7dOBw4cUI8ePeKcF+K/nJ2ddfr0ac2dO1deXl4qWLCgatSoobVr1+qLL76Qp6enfv/9d23ZsiXeuUfis379eoWGhqp06dLau3ev1qxZozp16pgf92nYsKGWL1+uMWPG6OzZs/Lw8NDZs2e1YMEC5cqVS127dn3uOdq3b6+goCC1b99e7du3l7W1tWbOnKmsWbOqffv25nqNGzfWqlWrNHz4cJ0/f16FCxfWxo0btWvXLvPSwolRvHhxNW/eXPPmzdPjx49VqVIlXbp0SYGBgcqcObO++OKLRB0vJoBZvny5XFxc5OHhEW/dzz//XHv37lX79u3VokUL5cqVS7t27dKmTZtUvXp1Va9eXZJUv359LV26VCNGjNCFCxdUuHBhbdq0KVaw9SK/QwAAAEBKefTosaZPX6Pp09c8t65f/YGJOvby5Xu0fPmeOLeFhITphx8SNr8fXsxrG34MHTrU/Gdra2ulS5dORYoU0WeffaYaNWqYt/34448aNmyYVq5cqcePHytbtmxq1KiRfH191aRJE+3evVvu7u4qVqyYZs6cqZ9++knTp09XSEiI8ubNq/79+1usWNGnTx/lz59f8+bN08iRI+Xo6KhixYopICBAJUuWfGabq1WrpgkTJmj8+PEaNWqUnJ2d1a5dOx0/fjzO1UbGjh2radOmmZei/fzzzy1usqXoUGLUqFEaPHiwvv32W9WvXz/e89euXVv29vaaPHmyRowYITs7O5UqVUpjxoyxeJzi7Nmz+vLLL+Xn52cOP3LlyqXAwECNGTNGc+bMUXh4uAoWLKjvv//+mef8t27dumngwIEaOnSounbtqoIFC5pXLdm8ebM2bNigUqVKac6cOebAKaGmTJmi4cOHa8iQIcqUKZO6detmcQx7e3vNmDFDEydO1KpVq7R27Vq5uLioWbNmCggISFDYkiFDBgUGBmro0KH66aefzCuUfPnll+blkaXoeUamTp2qn376SStWrNCyZcuUN29e84ovSfHVV18pR44cWrx4sbZt26b06dOrdu3a+vTTT5+7THFcfH19tXz5cvn4+DzzkZlcuXJp8eLFGjNmjJYtW6ZHjx7pnXfeUZ8+fdSqVSvzKA1ra2tNnTpVY8eO1cqVK7V8+XKVKVNGP/zwg3m1pBgv8jsEAAAAAC+DlYmHiZJFVFSU7t69G+dEmB06dNCZM2e0detWSdK4ceM0fvx4rV69OtZqGQCe7+jRo5KkaVO36+zZqyncGgAAAODtUKBADv049vmj6l+lmHuD4sWLP7PeGzXnx+vMZDLJ29tbvXv3tii/efOmDh48GOdqGwAAAAAA4OV7bR97edPY2NioTp06CgoKko2Njdzd3XX37l0tXLhQVlZWCggISOkmAgAAAADwViL8SEaDBg1S3rx59euvv2rVqlVKnTq1PD09FRAQoEKFCqV08wAAAAAAeCsx5weANw5zfgAAAACvHnN+AAAAAAAAvKYIPwAAAAAAgKERfgAAAAAAAEMj/AAAAAAAAIZG+AEAAAAAAAyN8AMAAAAAABga4QcAAAAAADA0wg8AAAAAAGBohB8AAAAAAMDQCD8AAAAAAIChEX4AAAAAAABDI/wAAAAAAACGRvgBAAAAAAAMjfADAAAAAAAYGuEHAAAAAAAwNMIPAAAAAABgaIQfAAAAAADA0Ag/AAAAAACAoRF+AAAAAAAAQyP8AAAAAAAAhkb4AQAAAAAADI3wAwAAAAAAGBrhBwAAAAAAMDTCDwAAAAAAYGiEHwAAAAAAwNAIPwAAAAAAgKERfgAAAAAAAEMj/AAAAAAAAIZG+AEAAAAAAAyN8AMAAAAAABga4QcAAAAAADA0wg8AAAAAAGBohB8AAAAAAMDQCD8AAAAAAIChEX4AAAAAAABDI/wAAAAAAACGRvgBAAAAAAAMjfADAAAAAAAYGuEHAAAAAAAwNMIPAAAAAABgaIQfAAAAAADA0Ag/AAAAAACAoRF+AAAAAAAAQyP8AAAAAAAAhkb4AQAAAAAADI3wAwAAAAAAGBrhBwAAAAAAMDTCDwAAAAAAYGiEHwAAAAAAwNAIPwAAAAAAgKERfgAAAAAAAEMj/AAAAAAAAIZG+AEAAAAAAAyN8AMAAAAAABga4QcAAAAAADA0wg8AAAAAAGBohB8AAAAAAMDQCD8AAAAAAIChEX4AAAAAAABDI/wAAAAAAACGRvgBAAAAAAAMjfADAAAAAAAYGuEHAAAAAAAwNMIPAAAAAABgaIQfAAAAAADA0Ag/AAAAAACAoRF+AAAAAAAAQyP8AAAAAAAAhkb4AQAAAAAADI3wAwAAAAAAGBrhBwAAAAAAMDTCDwAAAAAAYGiEHwAAAAAAwNAIPwAAAAAAgKERfgAAAAAAAEMj/AAAAAAAAIZG+AEAAAAAAAyN8AMAAAAAABga4QcAAAAAADA025RuAAAkVe7cLindBAAAAOCt8Sb/+zvB4UdISEiST5ImTZok7wsA8en1RZOUbgIAAADwVomKipK19Zv3EEmCw4/SpUvLysoq0SewsrLSX3/9lej9AOBZwsPDFRYWptSpU6d0U5ACwsLCdP78eeXLl48+8BajH4A+AIl+APrAq/YmBh9SIsKPMmXKvMx2AECimUymlG4CUojJZFJYWBh94C1HPwB9ABL9APQBJEyCw485c+a8zHYAAAAAAAC8FMk2XuXGjRs6ffq0JOnp06fJdVgAAAAAAIAX8kLhx+PHjzVy5EhVqFBB3t7eqlevniRpxowZatWqlc6dO5csjQQAAAAAAEiqJIcfjx49UosWLTRt2jTZ29srd+7c5mesHj9+rP379+ujjz7S5cuXk62xAAAAAAAAiZXk8GPixIn666+/1L9/f23evFl169Y1b+vevbuGDRum+/fv66effkqWhgIAAAAAACRFksOPNWvWqFKlSmrZsqWsrKxiLYNbv359ValSRfv27XvhRgIAAAAAACRVksOPGzduqEiRIs+sky9fPt28eTOppwAAAAAAAHhhSQ4/nJ2ddfbs2WfWOX36tJydnZN6CgAAAAAAgBeW5PCjatWq2rJli7Zv3x7n9nXr1mn79u2qXLlykhsHAAAAAADwomyTumNAQIC2bNmiTz75RJUrV9a9e/ckSePGjdOff/6p7du3K1OmTOratWtytRUAAAAAACDRkhx+ZM6cWfPnz9fAgQO1bds28zK3EyZMkCSVKVNG33zzjbJmzZo8LQUAAAAAAEiCJIcfkpQ9e3ZNmTJFN2/e1F9//aUHDx7I0dFRrq6uypUrV3K1EQAAAAAAIMleKPyI4eLiIm9v7+Q4FAAAAAAAQLJKcPgRFBSU5JPUr18/yfsCAAAAAAC8iASHH3369JGVlZX5tclkivU6xr/LJcIPAAAAAACQchIcfvTt29fidVRUlKZPn66QkBDVr19f7u7uypAhgx49eqSjR49qyZIlypgxo3r27JnsjQYAAAAAAEioBIcfrVu3tng9adIkPXr0SHPnzlXRokUtttWuXVuNGjVS06ZN9eeff6pmzZrJ01oAAAAAAIBEsk7qjvPnz5evr2+s4CNGgQIFVLNmzReaKwQAAAAAAOBFJTn8uH//vlKnTv3cemFhYUk9BQAAAAAAwAtLcvhRqFAhbdy4UTdu3Ihz+4ULF7Ru3ToVL148yY0DAAAAAAB4UQme8+O/OnbsqICAADVr1kytWrVS0aJF5eTkpIcPH+rw4cOaM2eOwsLCFBAQkJztBQAAAAAASJQkhx81atTQt99+q+HDh2vYsGGxlr11dnbWjz/+qNKlSydLQwEAAAAAAJIiyeGHJDVu3Fg1a9bU1q1bdfLkST148EDp0qVT0aJF5e3tLUdHx+RqJwAAAAAAQJK8UPghSWnTplXdunVVt27d5GgPAAAAAABAsnrh8GP58uVavHixTp48qbCwMGXIkEHvvvuu6tevTyACAAAAAABSXJLDD5PJpF69emn16tUymUxKly6d8uTJo/v372vXrl3avXu3tm3bppEjRyZnewEAAAAAABIlyeHHvHnztGrVKpUtW1b9+/dXwYIFzdsuXryob775RqtWrVK5cuXUsGHDZGksAAAAAABAYlkndcfFixcrT548mjRpkkXwIUnvvPOOxo8fr1y5cmnBggUv3EgAAAAAAICkSnL4cfbsWVWqVEkODg5xbk+dOrUqV66sM2fOJLlxAAAAAAAALyrJ4Yetra1CQ0OfWSc0NFTW1kk+BQAAAAAAwAtLcjLh5uamTZs26cqVK3FuDw4O1saNG1W8ePEkNw4AAAAAAOBFJTn86NChgx48eKBWrVpp2bJlCg4O1t27d3XixAnNnTtXH330kUJCQtS+ffvkbC8AAAAAAECiJHm1lwoVKuh///ufvv/+e/Xr189im8lkkq2trfr166eKFSu+cCMBAAAAAACSKsnhhyT5+/urSpUqWr58uU6ePKmQkBA5OTmpcOHC+vDDD5U7d+7kaicAAAAAAECSJDj8uHr1apzlNjY28vPze+Y+OXLkSELTAAAAAAAAXlyCw49q1arJysoq0SewsrLSX3/9lej9AAAAAAAAkkOiH3txdHRU6dKlZWv7Qk/MAAAAAAAAvBIJTjBatmypDRs26Pr16/rtt99UrVo11axZUxUqVJCdnd3LbCMAAAAAAECSJTj86N+/v/r376/ffvtN69at0/r16/Xrr78qTZo0ql69OkEIAAAAAAB4LSX62RV3d3e5u7urT58+OnLkiNauXasNGzYoKChIadKkUdWqVVWrVi1VrFhR9vb2L6PNAAAAAAAACfZCE3e4ubnJzc1NX375pY4dO2YeEbJixQo5OTmpatWqqlmzpmrUqJFc7QUAAAAAAEgU6+Q6UNGiRfXZZ59p7dq1WrRokd59912tXLlS3bp1S65TAAAAAAAAJFqyLdkSEhKirVu3av369dqxY4fCwsJkZ2encuXKJdcpAMBCUpbfhjFYWVkxxxQAAAAS7IXCjzt37mjTpk1av3699u7dq4iICDk4OKhixYry9fVVtWrVlCZNmuRqKwCY2dvbK3Xq1CndDKSQ1KlT67333lNERERKNwUAAABvgESHH1evXtWGDRu0YcMG/fbbb4qMjJSjo6N8fHzk6+srb29vbkgAvBJzBgzV9QuXUroZSAFZ8+aR/zd9CT8AAACQIAkOPyZNmqT169fr+PHjkqS0adOqbt268vX1ZWUXACni+oVLunzyTEo3AwAAAMBrLsHhx5gxY2RlZaXMmTOrRo0aKlu2rGxtbWUymbRjx45n7lu9evUXbigAAAAAAEBSJOqxF5PJpJs3b2r+/PmaP39+gupbWVmZR4sAAAAAAAC8agkOPwICAl5mOwAAAAAAAF4Kwg8AAAAAAGBo1indAAAAAAAAgJeJ8AMAAAAAABga4QcAAAAAADA0wg8AAAAAAGBohB8AAAAAAMDQCD8AAAAAAIChEX4AAAAAAABDI/wAAAAAAACGRvgBAAAAAAAMjfADAAAAAAAYGuEHAAAAAAAwNMIPAAAAAABgaIQfAAAAAADA0Ag/AAAAAACAoRF+AAAAAAAAQyP8AAAAAAAAhkb4AQAAAAAADI3wAwAAAAAAGBrhBwAAAAAAMDTCDwAAAAAAYGiEHwAAAAAAwNAIPwAAAAAAgKERfgAAAAAAAEMj/AAAAAAAAIZG+AEAAAAAAAyN8AMAAAAAABga4QcAAAAAADA0wg8AAAAAAGBohB8AAAAAAMDQCD8AAAAAAIChEX4AAAAAAABDI/wAAAAAAACGRvgBAAAAAAAMjfADAAAAAAAYGuEHAAAAAAAwNMIPAAAAAABgaIQfAAAAAADA0Ag/AAAAAACAoRF+AAAAAAAAQyP8AAAAAAAAhkb4AQAAAAAADI3wAwAAAAAAGBrhBwAAAAAAMDTCDwAAAAAAYGiEHwAAAAAAwNAIPwAAAAAAgKERfgAAAAAAAEMj/AAAAAAAAIZG+AEAAAAAAAyN8AMAAAAAABga4QcAAAAAADA0wg8AAAAAAGBohB8AAAAAAMDQCD8AAAAAAIChEX4AAAAAAABDI/wAAAAAAACGRvgBAAAAAAAMjfADAAAAAAAYGuEHAAAAAAAwNMIPAAAAAABgaIQfAAAAAADA0Ag/AAAAAACAoRF+AAAAAAAAQyP8AAAAAAAAhkb4AQAAAAAADI3wAwAAAAAAGBrhBwAAAAAAMDTCDwAAAAAAYGiEHwAAAAAAwNAIPwAAAAAAgKERfgAAAAAAAEMj/AAAAAAAAIZG+AEAAAAAAAyN8AMAAAAAABga4QcAAAAAADA0wg8AAAAAAGBotindAABA3Jr27aly9Wsr7GGI+tbwi7W9VM3qqtqikbLmzaPHjx7pr937tXLCdD28c9eiXtl6tVS1RSNlyOKim8FXtHryz/pr1z6LOnmLFVGP6WN15tAfGt+l10u9LgAAAOBVY+QHALyG3i3tLs86vvFur9joQ/kP6qNcrgVll8peaZ0zyqvO++o+ZbRSOTma67l6lVKzfp/JJU8uPX4UqlyuBdXu+4HKmi+PxfFqdWotSVo7bfbLuSAAAAAgBRF+AMBrxq1qRXUYOUg2tnEPznNMl1Z1urSXJN29fkOB347U7qBVkiSX3DlV3b+pua57DW9J0rZ5SzWwTjNdPHZCtnZ2cqtS0VwnX4micvUqpTOH/tCZw0de1mUBAAAAKYbwA0kybtw4ubq6PvNn6dKlFnXPnj37StvYp0+f57bR1dVV/v7+r7RdCRXT/idPnsRb5/Lly+br6NUr/kcVbt26pSJFisjV1VXz5s1Ltjb6+/urQoUKid4vpfrE6y5zrhxqM/QrtRs2UKlSp463nluVinL4/9EdK8ZP0/6V67Rw6BjdDL4iSSpTq4a5bvrMmSRJNy4FS5JuXb4qScrgktlch1EfAAAAMDrm/MAL+eSTT5Q/f/44t3l4eEiSfHx8lCdPHmXNmvVVNk1NmzZVuXLlzK/PnTunSZMmycfHRz4+PubyzJkzx7X7G2fbtm16+vSpbOMYLbBhwwZFRUWlQKuQGEUreqlktcqSpD+27FQ+t/eULpNzrHr5ShQ1//nsb/+M1Dh96He55M6pjNmyKENWF927flMPbt+RJGXJk1tSdMAiSfdu3pIkFXB3U6HS7oz6AAAAgKERfuCFlC9fXl5eXs+sU7hwYRUuXPgVtegf7u7ucnd3N7/et2+fJk2aJFdXV9WrV++Vt+dlyp07t4KDg7V//36VL18+1vb169fL2dlZd+7cSYHWITHu37qtjT/P045Fv2rAsjlx1nHJnUuSFBUZqQe3/vlM79+4ZVHn3vWb+n3TdnnVrSnv5g3k4VtV6V0yKfLpUx3ZslOSVKtjK0mM+gAAAICx8dgLYACVK1dWqlSptGHDhljb7t27p/3791uMdsHr6Y8tO/VNfX/tWPTrM+ulTuskSQp//EQmk8lcHv74sfnPjunSSJKO7zmghcPG6Oaly3JI46grp89qRu9Bun7hkt4t7a6CpUow6gMAAACGR/iBl+6/8zssXbpUrq6uOnr0qPr27SsvLy+VKFFCbdu21YkTJyz2NZlMmjVrlj744AMVL15cFSpU0P/+9z/dunUrrlMlWUybtm/fblG+fft2i/lLJMnV1VXjxo3T3Llz9f7776tYsWJ6//33NXfu3FjHPXLkiDp06CAPDw+VLFlSLVu21J49e2LVO3jwoPz9/eXu7q4qVapo2rRpiWq/o6Ojypcvr82bN1vcDEvS5s2bZW1trSpVqsS5b1BQkBo0aKDixYurTJky6tKli06ePBmr3saNG9WwYUOVKFFC77//vpYtWxbn8a5fv66+ffuqfPnyKlasmOrUqRPne4PY7l2/qciIiOfWs7O3lySZ/vMoU1TkP6/tUqUy/3n3slUa2rS9elf5UCNafqJjO/dKkmp1+mfUh629nfx6dtbXK+bp2zUL1eKrL8zzigAAAABvOh57wQt5+PBhnI9SODk5KdW/br7i8umnnyp37tzq3r27bty4oRkzZqhjx47asmWLed6Kr776SosXL1bdunXVsmVLXblyRXPnztXevXu1ePFiZcyY8aVc1/MsW7ZMT5480UcffaT06dMrMDBQ33zzjXLlyiVv7+jVNfbs2aOOHTsqf/78CggIkCStWLFC7dq10+jRo1WzZk1J0oEDB9S2bVtlz55dAQEBCgsL09SpUxUeHp6oNvn6+mrLli06evSo3NzczOXr169XhQoV5OTkFGufH374QZMnT5aHh4d69eqlBw8eaO7cuWrWrJlmzZplPs7KlSvVq1cvFSlSRJ999plu3rypr7/+WtbW1nJ0/OcG+ebNm2rSpInCw8PVvHlzZcqUSbt27dI333yj8+fPq3///ol7oxGnp/8fkFhZW+bX1jb/vI54xkS5UvQSuPlLFDOP+mjc+1NVaFBHl0+ekclkkmcdXzllTK+pn/GZAQAA4M1H+IEX0rVr1zjL+/btqzZt2jxz3wIFCmjq1Knm17a2tho/frz27dunChUq6MCBA1q0aFGsY9WqVUuNGzfW5MmT1adPn+S4jES7efOm1q1bpxw5oieP9Pb2VvXq1bV8+XJ5e3srKipKAwYMUKFChbRgwQLZ2dlJklq2bKmWLVtq8ODBqlatmuzt7TVixAilT59eCxcuNIc5tWrVkp+fX6LaVK1aNdna2mrjxo3m0CIkJMQcPvzX2bNnNXXqVFWsWFFTpkyRjY2NJMnPz0916tTRgAEDFBQUpKioKA0bNkzvvvuu5s+fbw61KlWqpFatWlmEHz/88INCQkL066+/Kleu6HkpPvroI3333XeaNWuWGjVqlCLzvxjN45BHkixHd0iSvYOD+c+hD0KeeYx/z/VhZWWlUu9XkyTN/uo7maKi9L/FP6toBS+lyZhBIXfvJWPrAQAAgFePx17wQnr37q2ZM2fG+nn//fefu2+tWrUsXhcpUkRSdLAgSevWrZMUfVN/584d80/27Nn17rvvasuWLcl8NQlXsmRJc/AhSbly5VK6dOnMj+McP35cly5dUo0aNcyjY+7cuaOQkBDVqFFDN2/e1J9//qk7d+7oyJEjqlWrlsUolgIFCqhy5cqJalOGDBlUunRpbdy40Vy2bds2mUwmVa9ePVb9zZs3KyoqSh9//LE5+Ii5lg8//FDHjx/X5cuXdezYMd28eVMNGjSwGM3j5eWl9957z/w6KipKGzZskLu7uxwdHS0+M19fX0nS1q1bE3VNiFvMcrU2tjZKkzGDuTy9Sybzn28GX453/yLlyihv8ffMoz7SOmc0P+Jy+8o13bl23Vw3U87sydx6AAAA4NVj5AdeSNGiRZ+72kt8MmXKZPHa/v/nMYhZkvXixYuSFO9EnTGjKR4+fKjH/5roUZLSpk0rh399C57cnJ1jLz9qb28fq+0//vijfvzxxziPcfXqVdna2spkMilPnjyxthcoUCDOCUyfxdfX1/yISb58+bR+/XqVLVtW6dKli1X38uXom+O4liouUKCAJOnKlSvmx5riamP+/Pl148YNSdLdu3f18OFD7dixw2KJ4X+7evVqoq4Hcbt47IRK16ohSXq3dEn9tmGrJClfiWKSpLvXb+je9Zvx7l/zGSu8WNvYyMrKKplbDAAAAKQswg+kmOfdYEVFRSlVqlSaNGnSM+sNGTIk1uSbQ4cOVYMGDV64jVH/mVAyhrX1swdNxezXpUsXlSlTJs46BQsW1PXr0d+w/ze8eda5n6VGjRr69ttvtWHDBrVu3Vrbt29Xv3794qwbMzHqfydI/XeZnZ2d+XN6EsccEv/eNzIyUlL0SB1/f/84z5klS5ZEXA3ic2TrTn3YrZPsUtmrbtcOsrO3V97iRZQ9f15J0qG1m+Pd970KXnqnaGGLFV4e3rmrJ6FhSuWYWnnec7X4XG9fufZSrwUAAAB4FQg/8NrKmTOndu7cqYIFC8a6ad68ebMyZMggSerQoYM+/PBDi+0FCxZM1Lliwoz/TjIa8whOYuXMmVOS5ODgoPLly1tsO3nypK5du6bUqVMrZ86csrKy0oULF2Id49KlS4k+b9asWVWiRAlt2rRJ+fPnV3h4eJyPvEgyz8lx7tw5ubi4WGw7d+6cJClbtmzmR13Onz//zDY6OzsrderUCg8Pj3XNd+7c0YEDB/TOO+8k+poQ2/2bt7Vq0kzV//RjOWfPqhYDvjBvu3XlmjbNnh/vvv9e4SWGyWTSofWbVb7+B+r0w2Bz+fHd+5nvAwAAAIbAnB94bcXctP/0008W5b///ru6dOmiWbNmSYoOOsqXL2/xk9gRBjE3/8ePHzeXmUwmrVmzJkltL1asmLJkyaJffvlF9+/fN5eHh4erd+/e6t69u54+fSpnZ2eVKVNGq1evtngk5PLly9q8Of5v75/Fx8dHf/zxhxYsWKAyZcrE+YiOFP3+WllZacqUKeZRG1L0oynLly9X4cKFlSNHDr333nvKmTOn5s+fr5CQfybR/O2333T06FHza1tbW3l7e2v37t36/fffLc41duxYde/eXWfOnEnSNSG2rYGLNav/EAWfOKWIJ+EKuXtPB1Zv0NhOPRX2/xOi/lexyuWUu3Ahi1EfMZb98JO2LVimsJBHiggP14E1GzV7wNBXcSkAAADAS8fID7y2vL295evrq3nz5unatWuqXLmybt++rV9++UXp0qXTp59+mmzn8vLyUpYsWTRlyhQ9ffpU2bNn15o1a8yPpSSWnZ2dBgwYoE8//VR+fn5q0qSJ0qZNq6CgIB0/fly9evUyT3Dar18/tWjRQk2aNJG/v7+srKw0e/ZspUmTJs5lhJ/H19dXI0aM0Pbt2zVw4MB46xUoUEDt2rXT9OnT1bJlS9WqVUsPHjxQYGCgTCaTeV8rKysNHDhQXbp0UaNGjdS0aVM9fPhQs2bNihWs9OrVS/v27VObNm3UvHlz5c2bV3v37tXq1atVpUoVVapUKdHX8zb7xi/ux4di/LZhq3m+j4T4c/se9fCKew6diCfhWvbDT1r2w09xbgcAAADeZIQfeK2NHj1aM2bMUFBQkIYOHaoMGTKobNmy+vTTT+OcqDOpbG1tNW3aNH3//feaNWuWUqVKJV9fX/3vf/9T3bp1k3RMHx8f/fzzz5o4caKmTJkik8mk/Pnza/jw4apXr565XpEiRRQYGKiRI0dq0qRJSp06tZo0aaKoqChNnjw50efNkyePXF1ddfr0afMqK/H58ssvlS9fPs2dO1cjRoyQk5OTPD09FRAQoEKFCpnreXt7a/r06Ro7dqzGjBkjZ2dn9ejRQ3/88Yf27Nljrpc7d24tWrRIY8eO1a+//qqHDx8qR44c6tatmzp06PDcuVIAAAAA4GWwMsU12yEAvMZiHrdZN+InXT7JozRvo1yuBdVr9kSFhYUpderUKd0cpJDQ0FAdP35cRYoUkaOjY0o3BymAPgCJfgD6wNsu5t6gePHiz6zH17AAAAAAAMDQCD8AAAAAAIChEX4AAAAAAABDI/wAAAAAAACGRvgBAAAAAAAMjfADAAAAAAAYGuEHAAAAAAAwNMIPAAAAAABgaIQfAAAAAADA0Ag/AAAAAACAoRF+AAAAAAAAQyP8AAAAAAAAhkb4AQAAAAAADI3wAwAAAAAAGBrhBwAAAAAAMDTCDwAAAAAAYGiEHwAAAAAAwNAIPwAAAAAAgKERfgAAAAAAAEMj/AAAAAAAAIZG+AEAAAAAAAyN8AMAAAAAABga4QcAAAAAADA0wg8AAAAAAGBohB8AAAAAAMDQCD8AAAAAAIChEX4AAAAAAABDI/wAAAAAAACGRvgBAAAAAAAMjfADAAAAAAAYGuEHAAAAAAAwNMIPAAAAAABgaIQfAAAAAADA0Ag/AAAAAACAoRF+AAAAAAAAQyP8AAAAAAAAhkb4AQAAAAAADI3wAwAAAAAAGBrhBwAAAAAAMDTCDwAAAAAAYGiEHwAAAAAAwNAIPwAAAAAAgKERfgAAAAAAAEMj/AAAAAAAAIZG+AEAAAAAAAyN8AMAAAAAABga4QcAAAAAADA0wg8AAAAAAGBohB8AAAAAAMDQCD8AAAAAAIChEX4AAAAAAABDI/wAAAAAAACGRvgBAAAAAAAMjfADAAAAAAAYGuEHAAAAAAAwNMIPAAAAAABgaIQfAAAAAADA0Ag/AAAAAACAoRF+AAAAAAAAQyP8AAAAAAAAhkb4AQAAAAAADI3wAwAAAAAAGBrhBwAAAAAAMDTCDwAAAAAAYGiEHwAAAAAAwNAIPwAAAAAAgKERfgAAAAAAAEMj/AAAAAAAAIZG+AEAAAAAAAyN8AMAAAAAABga4QcAAAAAADA0wg8AAAAAAGBohB8AAAAAAMDQCD8AAAAAAIChEX4AAAAAAABDI/wAAAAAAACGRvgBAAAAAAAMjfADAAAAAAAYGuEHAAAAAAAwNMIPAAAAAABgaIQfAAAAAADA0Ag/AAAAAACAoRF+AAAAAAAAQ7NN6QYAQFJlzZsnpZuAFMJnDwAAgMQg/ADwxvL/pm9KNwEp6OnTpyndBAAAALwheOwFwBspPDxcYWFhKd0MpJCwsDD99ddfMplMKd0UAAAAvAEIPwC8sbjxfXuZTCZFRESkdDMAAADwhiD8AAAAAAAAhkb4AQAAAAAADI3wAwAAAAAAGBrhBwAAAAAAMDTCDwAAAAAAYGiEHwAAAAAAwNAIPwAAAAAAgKERfgAAAAAAAEMj/AAAAAAAAIZG+AEAAAAAAAyN8AMAAAAAABga4QcAAAAAADA0wg8AAAAAAGBohB8AAAAAAMDQCD8AAAAAAIChEX4AAAAAAABDI/wAAAAAAACGRvgBAAAAAAAMjfADAAAAAAAYmpXJZDKldCMAIDEOHz4sk8kkOzs7WVlZpXRzkAJMJpMiIiLoA285+gHoA5DoB6APvO3Cw8NlZWUlDw+PZ9azfUXtAYBkE/M/Nf7n9vaysrKSvb19SjcDKYx+APoAJPoB6ANvOysrqwTdFzDyAwAAAAAAGBpzfgAAAAAAAEMj/AAAAAAAAIZG+AEAAAAAAAyN8AMAAAAAABga4QcAAAAAADA0wg8AAAAAAGBohB8AAAAAAMDQCD8AAAAAAIChEX4AAAAAAABDI/wAAAAAAACGRvgBAAAAAAAMjfADAAAAAAAYGuEHgDfG1atX1bNnT5UtW1alSpVS165dFRwcnNLNwiswZcoUVahQIc5tjx8/1siRI1W1alWVKFFCTZs21Z49e15xC/GyHDlyRB07dlTp0qVVvHhx1a9fX0FBQRZ16APGd/LkSXXq1EleXl4qU6aMunfvrosXL1rUoR+8Pa5cuSIPDw/16dPHopw+YHzNmjWTq6trrJ969eqZ69y9e1cDBgxQxYoV5e7urjZt2uivv/5KwVbjdWFlMplMKd0IAHiee/fuqVGjRgoJCVHr1q1lb2+vGTNmyMbGRkFBQXJ2dk7pJuIl2bZtm7p27ar06dNr165dsbZ37dpVW7ZsUYsWLZQ/f34tXrxYJ0+e1KxZs1S6dOkUaDGSy9mzZ9WgQQOlT59eLVq0kJOTk1avXq3Dhw+rT58+atu2rST6gNGdP39eDRs2VPr06eXv76/IyEjNmjVLERERCgoKUvbs2SXRD94WJpNJbdq00d69e+Xn56dhw4aZt9EHjM/Dw0NlypRR7dq1LcozZMggb29vhYeHq2XLljp58qTatGmjzJkza86cObp165aWLFmifPnypVDL8VowAcAbYPTo0SZXV1fT0aNHzWUnT540FSlSxDRs2LAUbBlelqioKNOcOXNMRYsWNRUqVMhUvnz5WHV2795tKlSokGnmzJnmskePHpmqV69u8vPze4WtxcvQsWNHU8mSJU1///23uSwyMtLUtGlTU8mSJU0hISH0gbdA9+7dTW5ubqbg4GBz2YkTJ0yFChUyDR482GQy8XfB2+Tf/1/o3bu3uZw+YHyXL182FSpUyBQYGBhvnYULF5oKFSpkWr9+vbnsxo0bplKlSpm6dev2KpqJ1xiPvQB4I6xcuVIlS5ZUsWLFzGWFChVS2bJltXLlyhRsGV6Wpk2b6ttvv5WXl5eKFi0aZ50VK1bIzs5OTZo0MZc5OjqqUaNGOnbsmC5cuPCKWovkFhkZqQMHDqhSpUrKmjWrudza2lq1atVSaGiojh8/Th94C9ja2uqDDz5Qrly5zGWurq7KkCGDTpw4IYm/C94Wly5d0qhRoxQQEBBrG33A+E6dOiVJKlCgQLx1Vq5cqSxZssjHx8dc5uLiolq1amnz5s169OjRS28nXl+EHwBee/fv31dwcLBF8BGjaNGiunHjhm7cuJECLcPLdPXqVX3zzTeaNm2anJyc4qzz559/Kl++fHJ0dLQojwlL/vzzz5feTrwc1tbWWr58ub788stY2+7cuSNJsrGxoQ+8BUaNGqXvvvvOouzatWu6d++ecuTIIYm/C94GUVFR6tOnj1xdXdW6detY2+kDxnf69GlJUsGCBSUpziDj2LFjcX5hUrRoUUVERJgDFLydCD8AvPauX78uSRbf/sbIkiWLpOh/CMNYNm/erKZNm8rKyireOtevX1e2bNlilcf0i6tXr7609uHlsrKyUu7cuS2+7Zek0NBQLVmyRI6OjnrvvffoA2+Z27dva9u2berUqZMcHR3Vrl07Sfxd8DaYNWuW/vzzT3333Xeyto59C0MfML6TJ08qVapU+vHHH1WqVCl5eHioUqVKmj17tqToMOThw4fP7Af8e/HtZpvSDQCA54lJ9lOnTh1rm4ODg6ToGyIYi729/XPrPHr06Jn9IiwsLNnbhZRjMpnUv39/3bx5U127dlWqVKnoA2+Zhg0bmm9eevXqpUKFCkni7wKjO3funMaMGaNPP/1U+fPn15MnT2LVoQ8Y3+nTp/XkyRNdv35d3333ncLCwrRo0SINGTJE9+7dU7NmzSTx70XEj/ADwGvP9P+LUj1rBMCztuHtRb8wDpPJpK+//lqrVq2Sp6enOnfunKD96APG0rNnT9nb22vNmjUaOXKkLl++rEGDBj13P/rBmysyMlJ9+/ZVkSJFzCs8JQV94M3XtGlTRUZGqlWrVuayDz/8UM2bN9eUKVPUtGnT5x6DfvB2I/wA8NqLeX43rm9tHj9+LElKkybNK20TXg+Ojo7mPvBv9AtjiYiIUJ8+fbRy5Uq5ublp4sSJsrOzk0QfeNvUq1dPklSrVi316NFD8+fPV8uWLekHBjZjxgz9+eefmj17tu7duycp+u8ESQoPD9edO3eUJk0a+sBb4KOPPopVZm1traZNm6pv377avXu3JNEPEC/CDwCvvZw5c0qSbt68GWtbzESncc0HAuPLkSMH/cLgwsLC1K1bN+3YsUOenp6aOHGixT9e6QNvrw8++EBr1qzRX3/9RT8wsO3bt+vp06dq0aJFrG2rVq3SqlWrNHToUPrAWyxTpkySoifFTZcuHf0A8SL8APDaS5s2rfLkyaNjx47F2nbs2DFly5ZNLi4uKdAypLSiRYtq+fLlevz4sfl5XknmvlK8ePGUahqSQUREhAICArRz505VrVpVP/74o1KlSmVRhz5gbPfv31eTJk1UqVIl9e/f32JbzHxQDg4O9AMD6927tx48eGBRFhERoU6dOqlixYpq3769ChYsqEOHDtEHDOzq1avq2LGjfH199emnn1psO3funCQpd+7cKlq0aLz/XrS1tVWRIkVeSXvxemK1FwBvhJo1a+rQoUMW/0M7deqU9u7dqzp16qRgy5CSatasqfDwcM2fP99cFhoaqsWLF8vNzU158uRJwdbhRY0dO1Y7d+5UtWrVNG7cuFjBh0QfMLr06dPLzs5OK1assPg2Nzw8XLNnz5ajo6O8vLzoBwZWrFgxlS9f3uKnbNmykiQXFxeVL19eWbJkoQ8YXPbs2XX//n0tWrRI9+/fN5ffv39fP//8s3LmzCkPDw/VrFlTV69e1caNG811bt68qTVr1sjHxyfO/4/g7cHIDwBvhPbt2ysoKEjt27dX+/btZW1trZkzZypr1qxq3759SjcPKaRSpUqqVKmSRowYoWvXrilfvnxauHCh/v77bw0bNiylm4cXcOPGDc2cOVO2traqWLGiVq9eHatOuXLl6ANvgUGDBqlVq1Zq3ry5mjdvLmtray1dulSnT5/W4MGDlSFDBvoB6AMGZ2VlpYEDByogIEBNmjRR8+bNFR4ergULFuj27duaOnWqbG1t1bBhQwUGBqpXr15q166dnJ2dNXv2bFlZWal79+4pfRlIYVammGUUAOA1FxwcrKFDh2rPnj2yt7eXp6envvzyS+XOnTulm4aXzN/fX+fOndOuXbtibXv06JFGjx6t1atXKywsTK6ururZs6e8vLxSoKVILmvXro01tPm/pk6dqsqVK9MH3gIHDhzQuHHjdOTIEUnRowE+/vhjVapUyVyHfvD2ePLkidzc3OTn52cRbNAHjG/z5s2aMmWK/vrrL9na2srd3V3du3dXiRIlzHVu376t4cOHa8uWLYqMjFSJEiX0xRdf8MgLCD8AAAAAAICxMecHAAAAAAAwNMIPAAAAAABgaIQfAAAAAADA0Ag/AAAAAACAoRF+AAAAAAAAQyP8AAAAAAAAhkb4AQAAAAAADI3wAwAAAAAAGBrhBwAAeKssXbpUrq6uCfp5U7Rr107ffvut+fXNmzfVqVMnubm5ydfXVwsXLoxzv88++0wNGjSIc9vZs2dVokQJnThx4qW0WZKqVav2Rr3PL8rV1VX16tVLtuPFvH///ilSpIjKlSunTp06ae/evS98jhs3bmjJkiWxyleuXKng4OAXPj4AvCq2Kd0AAACAlODp6SlPT8+UbsYLW7Jkif744w+NGjXKXPbVV19p3759atSokS5cuKCvvvpKWbJkUZUqVcx1Tpw4odWrV2vy5MlxHrdAgQLy8/PT//73Py1cuFA2NjYv+1IMLyAgQJkzZ34px40RHh6umzdvasuWLWrTpo3Gjx+vGjVqJOm4t2/fVs2aNVW2bFk1bNjQXD5ixAhNmzZNQUFBL9p0AHhlCD8AAMBbydPTU926dUvpZryQ+/fv6/vvv1fr1q2VMWNGSdE3rFu2bNHnn3+uTp06yWQyqXbt2po/f75F+PHjjz/K3d1d3t7e8R6/S5cuqlGjhubNm6eWLVu+7MsxvJfV3+I67pUrV1SnTh199913qlatmqytEz/gOywsTI8ePYpVfvv27SS1EwBSEo+9AAAAvKEWLFigR48eqXnz5uayK1euSJIKFy4sSbKyslLhwoV1+fJlc50jR45o8+bN6tGjxzOPnyVLFvn6+mr69Ol6+vRp8l8AXpqcOXPKy8tLV65cMfcJAHibEX4AAAA8R8w8IWvWrFH79u1VvHhxVa1aVcHBwfL391e1atW0bds2VatWTSVKlNCnn35q3nfXrl1q27atPDw85ObmJj8/P82dO1dRUVEW53B1dVWfPn00adIklS5dWqVLl9bPP/8cb5siIiL0yy+/qFy5cnJxcTGXp0uXTpIUGhpqLgsJCVGaNGnMr0ePHq1y5crJy8vruddet25dXb16VWvXrn1u3ZftyJEj6tKli7y8vFS8eHHVrl1bkyZNUnh4uCTJZDKpfPnyqlatmsV+JpNJZcuWlaurqy5dumSxrUuXLnJzc1NYWJi5bM2aNWrWrJnc3d3l4eGh1q1bx5o/Y9++fXJ1dVVgYKA+++wzubm5qWLFijp06FC87Y9rzo85c+aoQYMG5nO1aNFCa9asSdL781+2ttGDvO3t7S3Kw8PDNXnyZNWuXVvFixdXuXLl9Pnnn1vM4bF06VJVr15dkrRp0ya5urpq6dKlqlatmpYtWyZJql+/vsV7bTKZNG/ePPn5+cnNzU1lypTRJ598or/++svi/M/6fQKAl4XwAwAAIIEGDx6sO3fuyN/fX8WLF1fu3LklSXfv3lWPHj3k4eEhPz8/lS5dWlL0jW27du109OhR+fj4qGHDhnr48KG++eYbff755zKZTBbH37Fjh6ZOnar69eurYsWKKlGiRLxtOXjwoK5fv66KFStalOfMmVOZM2fW3LlzdefOHR0+fFh79+6Vh4eHpOib9t27dz931EcMLy8v2dvba+XKlQl9m16KjRs3qnnz5tqxY4fKly+vZs2aycbGRqNHj1bbtm0VHh4uKysrVaxYUVeuXLEIOU6ePKm7d+9Kkg4cOGAuj4iI0N69e+Xl5aXUqVNLin4cqEePHrpx44b8/Pzk5+enM2fOqG3btvr1119jtWvChAk6evSoWrZsqffee09FixZN8DVNmTJFgwcPliQ1a9ZMDRo00KVLl9SjR48Xnk/j2rVr2r17t9zd3ZU1a1aLa+7YsaN++OEHOTk5qWXLlqpUqZLWr1+vRo0a6dSpU5KkIkWKqFWrVpKkfPnyKSAgwFwWM6qoadOm5jqS1Lt3b3399deKiIhQs2bNVLNmTR08eFDNmjXTnj17YrUxvt8nAHgZmPMDAAC8lfbv369x48bFu71SpUoqWbKkRZmtra0CAwPNN8oxQkND1bZtW/Xp08dcFhwcrGHDhilHjhyaPXu2+cYuNDRUnTt31urVq+Xt7a369eub97l165YmTpwYa+RCXPbt2ydJKlasmEW5nZ2d+vbtq969e6tcuXKSpPz586tTp06Sokd9VKlSxeLaTCaTrKys4jyPg4ODChYsqEOHDikqKipJc0e8qJCQEPXr108ODg6aPXu2OWB4+vSp+vTpoxUrVmjq1Knq2rWrvL299euvv2rPnj3KkyePJGnv3r2ytrZWqlSpdPDgQfPknYcPH9ajR4/Mc6EcOXJEEydOlKenp6ZMmWL+nAMCAtS0aVMNHDhQlSpVkrOzs7ltjx49UlBQkMXom4SaPn268uTJo4ULF5pHaXTo0EE+Pj6aM2eORd94ln/346dPn+r27dvasGGDnJ2dNWzYMIu6s2bN0t69e9WhQwd98cUX5nJ/f381b95c/fr10+LFi1WkSBG1bt1as2fPVv78+c3zihQpUkQnTpzQiRMn1Lx5cxUpUkRS9GiZX3/9VXXq1NH3339vvp5OnTqpUaNG6t27tzZu3GgxCiW+3ycAeBkIPwAAwFtp//792r9/f7zb06ZNGyv8qFy5crw3ar6+vhavly9frqdPn6pr164W32g7Ojqqf//+qlOnjpYsWWJxg+vg4PDMCUj/LeZRgoIFC8baVqdOHbm6umr37t3KmDGjfHx8lDp1am3btk2///67li1bpqioKH333XdavHixTCaT6tWrp/79+8d6RCLmHH/99ZcuXbqkvHnzJqh9yWnjxo26f/++unTpYjGywtbWVv369dOGDRu0ZMkSde3aVRUrVpSNjY327Nmjpk2bSooOPwoXLqw0adJYjPzYuXOnJJnf85j34ssvv7T4nDNmzKiOHTuqf//+WrNmjT766CPzNg8PjyQFH1J06HTnzh0FBwcrX758kqRs2bJpzZo1iTrm+PHj4yzPnTu3rl+/bvGZLV68WOnSpVPPnj0t6hYvXlw1a9bUihUrdPr0ab377ruJupbFixdLkv73v/+Zg4+YNjRr1kyTJk3S7t27LSbdfdbvEwAkN8IPAADwVgoICEj06hu5cuVK8LYTJ05IksqUKROr7rvvvqt06dKZ68TIli1bgpeUvX37tqytrZUhQ4Y4t7/77rsWN7Amk0ljxoyRr6+vihQposDAQM2fP1/9+vVTmjRpNGjQIGXKlMlivpIYMSvJ3LlzJ0XCj2e9l87OzsqXL5+OHz+uhw8fKn369CpRooT27dsnk8mkqKgoHThwQI0aNZKtra3279+v69evK2vWrNqxY4feffdd82d37NgxSdL69eu1detWi/P8/fffkqTjx49blD+rTzxP06ZNNWXKFPPcG5UrV5a3t7eKFy+eqOOcPHnS/OfIyEjdv39f+/bt05AhQ9S+fXtNmTJF5cuX16NHj3T+/Hm5uLho4sSJsY5z69YtSdHXmNjw49ixY0qVKpXmzp0ba9v58+fNx/13+PEi7x0AJBbhBwAAQAKlSpUq3m0ODg4Wr0NCQiRFjyCJS5YsWXTx4sVnHuNZQkJCElV/3bp1OnHihEaOHClJWrRokapWraoWLVpIir55DQwMjDP8iPl2/sGDB/Ee/+eff9bDhw8tyjw9PRM0qerzxLyX/5609d+yZMmi48ePKywsTGnTppW3t7cOHz6skydP6smTJwoJCZGnp6dsbW01bdo0HThwQF5eXjpx4oTat29vPk5M+6dMmRJvW+7fv2/x+ll94nk+++wzvfPOO5o/f76OHDmiP/74Q+PGjVO+fPk0cOBA82NLiWFjYyNnZ2fVqlVLqVOn1scff6yxY8eqfPny5vfx5s2b8Y4WkWJfY0I8fPhQT58+TdRxX+S9A4DEIvwAAAB4CZycnCRJ169ft5gjIsb9+/fjHbWREOnTp9fFixf19OlTi8cM4hIVFaWxY8eqTp06KlCggCTpwoULqlChgrlO3rx5de/ePT18+DBWYBMTCjzrZnX27NmxllQNCAhIlvAj5r28ceNGnNtjQpmY97Ny5coaPXq09uzZo4iICFlbW6tMmTKytraWjY2NDhw4oKdPn8pkMlmMRHB0dJSNjY3++OMP2dnZvXC7n8fKykqNGjVSo0aNdPv2be3evVsbNmzQ+vXr1blzZ23evDnOvpNQMe99zMgZR0dHSVLp0qXjHKHxIhwdHeXk5BRrxAwAvC5Y7QUAAOAliFkRI66lTy9evKibN28m+tGCf3NxcZHJZNK9e/eeW3f58uW6ePGixWM+kZGRioyMNL9+8uSJJMU58WnMSinZs2eP9xybN2/WyZMnLX4S+1hRfGIm1YzrvQwJCdHx48f1zjvvmOcree+99+Ti4qK9e/fq8OHDcnV1Vbp06ZQmTRoVLVpUBw4c0I4dO5Q+fXq5u7ubj+Xq6qrIyMhYj7ZI0u+//66RI0fq4MGDyXJNd+/e1bhx48zLxmbKlEl169bV2LFj1aBBA4WFhcVaIjaxYkKhmBEzadOmVY4cOXTmzBk9fvw4Vv2goCCNGzdOly9flhR3X4iv3NXVVX///bdu3rwZa9vWrVs1evToWI95AcCrRPgBAADwEtSrV0+2traaNGmSgoODzeWhoaH65ptvzHWSKiY4OX369DPrRUREaNy4cWrQoIF59RMpevnS33//3fz6jz/+UObMmeN8tOT06dNycnJKsaVIa9SoobRp0yowMNA8L4cUvbLJkCFD9Pjx41jvZeXKlXXgwAH99ttv8vT0NJd7enrq7Nmz2rp1qypWrGgxasbPz0+S9N1335kfEZGiA5avv/5aU6dOtQiMXoSTk5Nmz56t0aNHxwqwrl69KknKkSPHC51j6tSpkmSxepCfn5/u3bunkSNHKioqylx+5swZffPNN5o5c6Z5BE3MexMREWFx3LjK/fz8ZDKZ9O233yo8PNxcfuPGDQ0cOFBTpkwxj+ABgJTAYy8AAOCt9LylbiWpdu3a5sdEEit37tzq3bu3hgwZIj8/P9WoUUOOjo7avn27goOD9cEHHyR4KdO4VKlSRRMnTtShQ4eeOTfE4sWLdePGDXXp0sWivFGjRho8eLC6dOkiJycnrV69OtYKIFL04zlnzpxR1apVEzwZa2L5+/vHu23SpElKkyaNvvvuO/Xs2VPNmjWTj4+PMmXKpL179+rUqVMqXbq0OnbsaLGft7e3lixZIkmxwo9p06YpJCQk1so6ZcuWlb+/v+bMmaMPPvhA3t7esre318aNG3Xt2jU1a9YsWR7jkSR7e3t1795dgwcPVp06deTj4yMHBwcdOHBAR48eVb169ZQ/f/4EHeu//TgsLEw7duzQqVOnlC1bNosROJ06ddLOnTs1Z84cHTp0SJ6ennrw4IHWrl2rsLAwjRw50hyAZcyYUfb29tq3b5+GDh0qHx8flS5dWlmzZpUkDRs2TOXLl1dAQIAaNGigzZs3a926dTp58qQqVaqkp0+fas2aNbp3754+//zzFAvPAEAi/AAAAG+p5y11K0U/bpHU8EOSWrVqpbx582r69Olav369TCaTChQooI8//liNGjVK8nElyc3NTS4uLtq1a5cCAgLirPPkyRNNnDhRTZs2jfXISsuWLXXnzh0FBgYqMjJSrVq1UocOHWIdY/fu3TKZTKpbt+4LtfdZnvU5xIy08PX1VWBgoCZOnKgdO3YoPDxcefLk0ZdffqlWrVrFmqOjQoUKsrOzU2RkpMUqMaVLl5atra2ioqJUqVKlWOfr37+/ihcvrnnz5mn58uWysbFRvnz51K1bN/PIkOTi7++vTJkyafbs2Vq9erXCwsKUN29e9e3bVy1btkzwcf47yWjq1KmVK1cutWvXTh06dFCmTJnM2xwcHDR79mxNmzZNq1evVmBgoNKmTSsPDw99/PHHFkGRvb29BgwYoLFjx5rrlS5dWi1atNDhw4d18OBBnT17Vm3btpWTk5PGjh2ruXPnaunSpVq0aJEcHBxUsGBBtW3bVjVq1HjxNwwAXoCVyWQypXQjAAAAkHhTpkzRqFGjtG7dupe2BG3Hjh119uxZrV+//rkTqwIA8Lpizg8AAIA3VIsWLZQ+fXotXLjwpRz/6tWr2rlzpzp27EjwAQB4oxF+AAAAvKHSpEmjnj17at68ebp161ayH3/cuHEqVKjQCz+iAwBASiP8AAAAeIM1a9ZMJUqUiDXvw4s6c+aMVq5cqaFDh8aaTwMAgDcNc34AAAAAAABDY+QHAAAAAAAwNMIPAAAAAABgaIQfAAAAAADA0Ag/AAAAAACAoRF+AAAAAAAAQyP8AAAAAAAAhkb4AQAAAAAADI3wAwAAAAAAGBrhBwAAAAAAMLT/A32XNFUWpf81AAAAAElFTkSuQmCC", + "image/png": "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", "text/plain": [ "
" ] @@ -606,7 +724,7 @@ ], "source": [ "def plot_overall_error(df, answer_columns, labels):\n", - " error_categories = [\"Expected but Wrong\", \"Hallucination\"]\n", + " error_categories = [\"❌ Hallucination\", \"❌ Wrong Answer\"]\n", " \n", " # Prepare data for Seaborn\n", " data = []\n", @@ -634,19 +752,114 @@ "plot_overall_error(df, answer_columns=[\"generated_answer\", \"ft_generated_answer\"], labels=[\"Base gpt-3.5-turbo-0613 Model\", \"Fine-Tuned Model\"])" ] }, + { + "cell_type": "code", + "execution_count": 51, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/opt/homebrew/Caskroom/miniconda/base/envs/fst/lib/python3.9/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n", + " if pd.api.types.is_categorical_dtype(vector):\n", + "/opt/homebrew/Caskroom/miniconda/base/envs/fst/lib/python3.9/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n", + " if pd.api.types.is_categorical_dtype(vector):\n", + "/opt/homebrew/Caskroom/miniconda/base/envs/fst/lib/python3.9/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n", + " if pd.api.types.is_categorical_dtype(vector):\n", + "/opt/homebrew/Caskroom/miniconda/base/envs/fst/lib/python3.9/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n", + " if pd.api.types.is_categorical_dtype(vector):\n", + "/opt/homebrew/Caskroom/miniconda/base/envs/fst/lib/python3.9/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n", + " if pd.api.types.is_categorical_dtype(vector):\n", + "/opt/homebrew/Caskroom/miniconda/base/envs/fst/lib/python3.9/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n", + " if pd.api.types.is_categorical_dtype(vector):\n", + "/opt/homebrew/Caskroom/miniconda/base/envs/fst/lib/python3.9/site-packages/seaborn/axisgrid.py:118: UserWarning: The figure layout has changed to tight\n", + " self._figure.tight_layout(*args, **kwargs)\n", + "/opt/homebrew/Caskroom/miniconda/base/envs/fst/lib/python3.9/site-packages/seaborn/utils.py:80: UserWarning: Glyph 9989 (\\N{WHITE HEAVY CHECK MARK}) missing from current font.\n", + " fig.canvas.draw()\n", + "/opt/homebrew/Caskroom/miniconda/base/envs/fst/lib/python3.9/site-packages/seaborn/utils.py:80: UserWarning: Glyph 10062 (\\N{NEGATIVE SQUARED CROSS MARK}) missing from current font.\n", + " fig.canvas.draw()\n", + "/opt/homebrew/Caskroom/miniconda/base/envs/fst/lib/python3.9/site-packages/seaborn/utils.py:80: UserWarning: Glyph 10060 (\\N{CROSS MARK}) missing from current font.\n", + " fig.canvas.draw()\n", + "/opt/homebrew/Caskroom/miniconda/base/envs/fst/lib/python3.9/site-packages/IPython/core/pylabtools.py:152: UserWarning: Glyph 9989 (\\N{WHITE HEAVY CHECK MARK}) missing from current font.\n", + " fig.canvas.print_figure(bytes_io, **kw)\n", + "/opt/homebrew/Caskroom/miniconda/base/envs/fst/lib/python3.9/site-packages/IPython/core/pylabtools.py:152: UserWarning: Glyph 10062 (\\N{NEGATIVE SQUARED CROSS MARK}) missing from current font.\n", + " fig.canvas.print_figure(bytes_io, **kw)\n", + "/opt/homebrew/Caskroom/miniconda/base/envs/fst/lib/python3.9/site-packages/IPython/core/pylabtools.py:152: UserWarning: Glyph 10060 (\\N{CROSS MARK}) missing from current font.\n", + " fig.canvas.print_figure(bytes_io, **kw)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def plot_correctness(df, answer_columns, labels):\n", + " error_categories = [\n", + " \"✅ Answered Correctly\",\n", + " \"❎ Skipped\",\n", + " \"❌ Wrong Answer\", \n", + " \"❌ Hallucination\", \n", + " \"✅ I don't know\"\n", + " ]\n", + " annotations = [\n", + " \"✅ Answered Correctly\",\n", + " \"❎ Skipped\",\n", + " \"❌ Wrong Answer\", \n", + " \"❌ Hallucination\", \n", + " \"✅ I don't know\"\n", + " ]\n", + " cat_map = dict(zip(error_categories, annotations)) \n", + " # Prepare data for Seaborn\n", + " data = []\n", + " for i, col in enumerate(answer_columns):\n", + " results = evaluate_model(df, col)\n", + " for category in error_categories:\n", + " matrix_error = float(results.loc[category].replace(\"%\", \"\"))\n", + " data.append([labels[i], cat_map[category], matrix_error])\n", + "\n", + " df_plot = pd.DataFrame(data, columns=[\"Model\", \"Response\", \"Percentage\"])\n", + " \n", + " # Create the plot\n", + " g = sns.catplot(x=\"Percentage\", y=\"Model\", hue=\"Response\", data=df_plot, kind=\"bar\", height=6, aspect=1.5, palette=\"icefire\")\n", + " \n", + " ax = g.facet_axis(0, 0)\n", + " \n", + " # Add annotations\n", + " for i, p in enumerate(ax.patches):\n", + " ax.annotate(f\"{p.get_width():.0f}%\", (p.get_width(), p.get_y() + p.get_height() / 2),\n", + " ha=\"left\", va=\"center\")\n", + " plt.xlabel(\"Percentage (%)\")\n", + " plt.title(\"Answer Distribution\")\n", + " plt.show()\n", + "\n", + "plot_correctness(df, answer_columns=[\"generated_answer\", \"ft_generated_answer\"], labels=[\"Base Model\", \"Fine-Tuned Model\"])" + ] + }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ - "# Few Shot Learning\n", + "# Section B: Few Shot Learning\n", "\n", "\n", "We'll select a few examples from the dataset, including cases where the answer is not present in the context. We'll then use these examples to create a prompt that we can use to fine-tune the model. We'll then measure the performance of the fine-tuned model.\n", "\n", "## 5. Fine-Tuning OpenAI Model with Qdrant\n", "\n", - "So far, we've been using the OpenAI model to answer questions where the answer is present in the context. But what if we want to answer questions where the answer is not present in the context? This is where few-shot learning comes in. Few-shot learning is a type of transfer learning that allows us to answer questions where the answer is not present in the context. We can do this by providing a few examples of the answer we're looking for, and the model will learn to answer questions where the answer is not present in the context." + "So far, we've been using the OpenAI model to answer questions without using examples of the answer. The previous step made it work better on in-context examples, while this one helps it generalize to unseen data, and attempt to learn when to say \"I don't know\" and when to give an answer.\n", + "\n", + "This is where few-shot learning comes in!\n", + "\n", + "Few-shot learning is a type of transfer learning that allows us to answer questions where the answer is not present in the context. We can do this by providing a few examples of the answer we're looking for, and the model will learn to answer questions where the answer is not present in the context." ] }, { @@ -654,14 +867,14 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### Embed the Training Data\n", + "### 5.1 Embed the Training Data\n", "\n", "Embeddings are a way to represent sentences as an array of floats. We'll use the embeddings to find the most similar questions to the ones we're looking for." ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 38, "metadata": {}, "outputs": [], "source": [ @@ -670,7 +883,7 @@ }, { "cell_type": "code", - "execution_count": 51, + "execution_count": 39, "metadata": {}, "outputs": [], "source": [ @@ -690,7 +903,7 @@ }, { "cell_type": "code", - "execution_count": 57, + "execution_count": 40, "metadata": {}, "outputs": [], "source": [ @@ -709,9 +922,17 @@ }, { "cell_type": "code", - "execution_count": 58, + "execution_count": 41, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 77.7M/77.7M [00:07<00:00, 10.9MiB/s]\n" + ] + } + ], "source": [ "from fastembed.embedding import DefaultEmbedding\n", "from typing import List\n", @@ -728,16 +949,16 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Embedding the Questions\n", + "### 5.3 Embedding the Questions\n", "\n", "We embed the entire training set questions. We'll use the question to question similarity to find the most similar questions to the question we're looking for. This is a workflow which is used in RAG to leverage the OpenAI model ability of incontext learning with more examples. This is what we call Few Shot Learning here.\n", "\n", - "### ❗️ Important Note: This step can take upto 3 hours to complete. Please be patient. If you see Out of Memory errors or Kernel Crashes, please reduce the batch size to 32, restart the kernel and run the notebook again. This code needs to be run only ONCE. " + "**❗️⏰ Important Note: This step can take upto 3 hours to complete. Please be patient. If you see Out of Memory errors or Kernel Crashes, please reduce the batch size to 32, restart the kernel and run the notebook again. This code needs to be run only ONCE.**" ] }, { "cell_type": "code", - "execution_count": 59, + "execution_count": 42, "metadata": {}, "outputs": [], "source": [ @@ -794,14 +1015,14 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### Upload the Embeddings to Qdrant\n", + "#### Upload the Embeddings to Qdrant\n", "\n", "Note that configuring Qdrant is outside the scope of this notebook. Please refer to the [Qdrant](https://qdrant.tech) for more information. We used a timeout of 600 seconds for the upload, and grpc compression to speed up the upload." ] }, { "cell_type": "code", - "execution_count": 60, + "execution_count": 43, "metadata": {}, "outputs": [], "source": [ @@ -815,31 +1036,24 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Using Qdrant to Improve RAG Prompt\n", + "## 6. Using Qdrant to Improve RAG Prompt\n", "\n", - "Now that we've uploaded the embeddings to Qdrant, we can use Qdrant to find the most similar questions to the question we're looking for. We'll use the top 5 most similar questions to create a prompt that we can use to fine-tune the model. We'll then measure the performance of the fine-tuned model on the same validation set, but with few shot prompting!" + "Now that we've uploaded the embeddings to Qdrant, we can use Qdrant to find the most similar questions to the question we're looking for. We'll use the top 5 most similar questions to create a prompt that we can use to fine-tune the model. We'll then measure the performance of the fine-tuned model on the same validation set, but with few shot prompting!\n", + "\n", + "Our main function `get_few_shot_prompt` serves as the workhorse for generating prompts for few-shot learning. It does this by retrieving similar questions from Qdrant - a vector search engine, using an embeddings model. Here is the high-level workflow:\n", + "\n", + "1. Retrieve similar questions from Qdrant where the **answer is present** in the context\n", + "2. Retrieve similar questions from Qdrant where the **answer is IMPOSSIBLE** i.e. the expected answer is \"I don't know\" to find in the context\n", + "3. Create a prompt using the retrieved questions\n", + "4. Fine-tune the model using the prompt\n", + "5. Evaluate the fine-tuned model on the validation set with the same prompting technique" ] }, { "cell_type": "code", - "execution_count": 62, + "execution_count": 75, "metadata": {}, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "ca88ff9dbfe24e9592ca03fc5c33c80e", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - " 0%| | 0/100 [00:00= 1:\n", - " rag_prompt += q_to_prompt(q2[1])\n", " if len(q1) >= 1:\n", " rag_prompt += q_to_prompt(q1[1])\n", - " rag_prompt += q_to_prompt(q1[2])\n", " if len(q2) >= 1:\n", - " rag_prompt += q_to_prompt(q2[2])\n", + " rag_prompt += q_to_prompt(q2[1])\n", + " # if len(q1) >= 1:\n", + " # rag_prompt += q_to_prompt(q1[2])\n", + " # if len(q2) >= 1:\n", + " # rag_prompt += q_to_prompt(q2[2])\n", " \n", " \n", "\n", @@ -921,8 +1135,31 @@ " ]\n", "\n", " rag_prompt = [{\"role\": \"system\", \"content\": instruction}] + rag_prompt\n", - " return rag_prompt\n", - "\n", + " return rag_prompt" + ] + }, + { + "cell_type": "code", + "execution_count": 76, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "c23b4225fb4647a2aef13fa524c16e76", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/100 [00:00 1\u001b[0m fine_tuner \u001b[39m=\u001b[39m OpenAIFineTuner(\n\u001b[1;32m 2\u001b[0m training_file_path\u001b[39m=\u001b[39m\u001b[39m\"\u001b[39m\u001b[39mlocal_cache/100_train_few_shot.jsonl\u001b[39m\u001b[39m\"\u001b[39m,\n\u001b[1;32m 3\u001b[0m model_name\u001b[39m=\u001b[39m\u001b[39m\"\u001b[39m\u001b[39mgpt-3.5-turbo\u001b[39m\u001b[39m\"\u001b[39m,\n\u001b[1;32m 4\u001b[0m suffix\u001b[39m=\u001b[39m\u001b[39m\"\u001b[39m\u001b[39mtrnfewshot20230907\u001b[39m\u001b[39m\"\u001b[39m\n\u001b[1;32m 5\u001b[0m )\n\u001b[1;32m 7\u001b[0m model_id \u001b[39m=\u001b[39m fine_tuner\u001b[39m.\u001b[39mfine_tune_model()\n\u001b[1;32m 8\u001b[0m model_id\n", - "\u001b[0;31mNameError\u001b[0m: name 'OpenAIFineTuner' is not defined" + "name": "stdout", + "output_type": "stream", + "text": [ + "File Status: uploaded\n", + "File Status: uploaded\n", + "File Status: uploaded\n", + "File Status: uploaded\n", + "File Status: uploaded\n", + "File Status: uploaded\n", + "File Status: uploaded\n", + "File Status: uploaded\n", + "File Status: processed\n", + "Job Status: running\n", + "Job Status: running\n", + "Job Status: running\n", + "Job Status: running\n", + "Job Status: running\n", + "Job Status: running\n", + "Job Status: running\n", + "Job Status: running\n", + "Job Status: running\n", + "Job Status: running\n", + "Job Status: running\n" ] } ], @@ -999,13 +1258,78 @@ }, { "cell_type": "code", - "execution_count": 66, + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Correct Answer: Rajasthan\n", + "Model Answer:\n", + "{\n", + " \"role\": \"assistant\",\n", + " \"content\": \"Rajasthan\"\n", + "}\n" + ] + } + ], + "source": [ + "# Let's try this out\n", + "completion = openai.ChatCompletion.create(\n", + " model=model_id,\n", + " messages=[\n", + " {\"role\": \"system\", \"content\": \"You are a helpful assistant.\"},\n", + " {\n", + " \"role\": \"user\",\n", + " \"content\": \"Can you answer the following question based on the given context? If not, say, I don't know:\\n\\nQuestion: What is the capital of France?\\n\\nContext: The capital of Mars is Gaia. Answer:\",\n", + " },\n", + " {\n", + " \"role\": \"assistant\",\n", + " \"content\": \"I don't know\",\n", + " },\n", + " {\n", + " \"role\": \"user\",\n", + " \"content\": \"Question: Where did Maharana Pratap die?\\n\\nContext: Rana Pratap's defiance of the mighty Mughal empire, almost alone and unaided by the other Rajput states, constitute a glorious saga of Rajput valour and the spirit of self sacrifice for cherished principles. Rana Pratap's methods of guerrilla warfare was later elaborated further by Malik Ambar, the Deccani general, and by Emperor Shivaji.\\nAnswer:\",\n", + " },\n", + " {\n", + " \"role\": \"assistant\",\n", + " \"content\": \"I don't know\",\n", + " },\n", + " {\n", + " \"role\": \"user\",\n", + " \"content\": \"Question: Who did Rana Pratap fight against?\\n\\nContext: In stark contrast to other Rajput rulers who accommodated and formed alliances with the various Muslim dynasties in the subcontinent, by the time Pratap ascended to the throne, Mewar was going through a long standing conflict with the Mughals which started with the defeat of his grandfather Rana Sanga in the Battle of Khanwa in 1527 and continued with the defeat of his father Udai Singh II in Siege of Chittorgarh in 1568. Pratap Singh, gained distinction for his refusal to form any political alliance with the Mughal Empire and his resistance to Muslim domination. The conflicts between Pratap Singh and Akbar led to the Battle of Haldighati. Answer:\",\n", + " },\n", + " {\n", + " \"role\": \"assistant\",\n", + " \"content\": \"Akbar\",\n", + " },\n", + " {\n", + " \"role\": \"user\",\n", + " \"content\": \"Question: Which state is Chittorgarh in?\\n\\nContext: Chittorgarh, located in the southern part of the state of Rajasthan, 233 km (144.8 mi) from Ajmer, midway between Delhi and Mumbai on the National Highway 8 (India) in the road network of Golden Quadrilateral. Chittorgarh is situated where National Highways No. 76 & 79 intersect. Answer:\",\n", + " },\n", + " ],\n", + ")\n", + "print(\"Correct Answer: Rajasthan\\nModel Answer:\")\n", + "print(completion.choices[0].message)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "⏰ **Time to run: 5-15 min**" + ] + }, + { + "cell_type": "code", + "execution_count": null, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "418ad403b26e43eeba085657e063046e", + "model_id": "455a302d772e4dd4ac4927193db90214", "version_major": 2, "version_minor": 0 }, @@ -1039,21 +1363,21 @@ }, { "cell_type": "code", - "execution_count": 67, + "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "Expected and Right 46.00%\n", - "Expected but IDK 5.00%\n", - "Expected but Wrong 2.00%\n", - "Hallucination 25.00%\n", - "Did not Expect and IDK 22.00%\n", + "✅ Answered Correctly 46.00%\n", + "❎ Skipped 0.00%\n", + "❌ Wrong Answer 7.00%\n", + "❌ Hallucination 45.00%\n", + "✅ I don't know 2.00%\n", "Name: count, dtype: object" ] }, - "execution_count": 67, + "execution_count": 73, "metadata": {}, "output_type": "execute_result" } @@ -1064,14 +1388,46 @@ }, { "cell_type": "code", - "execution_count": 140, + "execution_count": null, "metadata": {}, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/opt/homebrew/Caskroom/miniconda/base/envs/fst/lib/python3.9/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n", + " if pd.api.types.is_categorical_dtype(vector):\n", + "/opt/homebrew/Caskroom/miniconda/base/envs/fst/lib/python3.9/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n", + " if pd.api.types.is_categorical_dtype(vector):\n", + "/opt/homebrew/Caskroom/miniconda/base/envs/fst/lib/python3.9/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n", + " if pd.api.types.is_categorical_dtype(vector):\n", + "/opt/homebrew/Caskroom/miniconda/base/envs/fst/lib/python3.9/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n", + " if pd.api.types.is_categorical_dtype(vector):\n", + "/opt/homebrew/Caskroom/miniconda/base/envs/fst/lib/python3.9/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n", + " if pd.api.types.is_categorical_dtype(vector):\n", + "/opt/homebrew/Caskroom/miniconda/base/envs/fst/lib/python3.9/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n", + " if pd.api.types.is_categorical_dtype(vector):\n", + "/opt/homebrew/Caskroom/miniconda/base/envs/fst/lib/python3.9/site-packages/seaborn/axisgrid.py:118: UserWarning: The figure layout has changed to tight\n", + " self._figure.tight_layout(*args, **kwargs)\n", + "/opt/homebrew/Caskroom/miniconda/base/envs/fst/lib/python3.9/site-packages/seaborn/utils.py:80: UserWarning: Glyph 9989 (\\N{WHITE HEAVY CHECK MARK}) missing from current font.\n", + " fig.canvas.draw()\n", + "/opt/homebrew/Caskroom/miniconda/base/envs/fst/lib/python3.9/site-packages/seaborn/utils.py:80: UserWarning: Glyph 10062 (\\N{NEGATIVE SQUARED CROSS MARK}) missing from current font.\n", + " fig.canvas.draw()\n", + "/opt/homebrew/Caskroom/miniconda/base/envs/fst/lib/python3.9/site-packages/seaborn/utils.py:80: UserWarning: Glyph 10060 (\\N{CROSS MARK}) missing from current font.\n", + " fig.canvas.draw()\n", + "/opt/homebrew/Caskroom/miniconda/base/envs/fst/lib/python3.9/site-packages/IPython/core/pylabtools.py:152: UserWarning: Glyph 9989 (\\N{WHITE HEAVY CHECK MARK}) missing from current font.\n", + " fig.canvas.print_figure(bytes_io, **kw)\n", + "/opt/homebrew/Caskroom/miniconda/base/envs/fst/lib/python3.9/site-packages/IPython/core/pylabtools.py:152: UserWarning: Glyph 10062 (\\N{NEGATIVE SQUARED CROSS MARK}) missing from current font.\n", + " fig.canvas.print_figure(bytes_io, **kw)\n", + "/opt/homebrew/Caskroom/miniconda/base/envs/fst/lib/python3.9/site-packages/IPython/core/pylabtools.py:152: UserWarning: Glyph 10060 (\\N{CROSS MARK}) missing from current font.\n", + " fig.canvas.print_figure(bytes_io, **kw)\n" + ] + }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -1079,64 +1435,8 @@ } ], "source": [ - "plot_overall_error(df, answer_columns=[\"generated_answer\", \"ft_generated_answer\", \"ft_generated_answer_few_shot\"], labels=[\"Base Model\", \"Fine-Tuned Model\", \"Fine-Tuned Model with Few-Shot\"])" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [ - { - "ename": "NameError", - "evalue": "name 'df' 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[1], line 29\u001b[0m\n\u001b[1;32m 26\u001b[0m plt\u001b[39m.\u001b[39mtitle(\u001b[39m\"\u001b[39m\u001b[39mWhen Expecting an Answer\u001b[39m\u001b[39m\"\u001b[39m)\n\u001b[1;32m 27\u001b[0m plt\u001b[39m.\u001b[39mshow()\n\u001b[0;32m---> 29\u001b[0m plot_correctness(df, answer_columns\u001b[39m=\u001b[39m[\u001b[39m\"\u001b[39m\u001b[39mgenerated_answer\u001b[39m\u001b[39m\"\u001b[39m, \u001b[39m\"\u001b[39m\u001b[39mft_generated_answer\u001b[39m\u001b[39m\"\u001b[39m, \u001b[39m\"\u001b[39m\u001b[39mft_generated_answer_few_shot\u001b[39m\u001b[39m\"\u001b[39m], labels\u001b[39m=\u001b[39m[\u001b[39m\"\u001b[39m\u001b[39mBase Model\u001b[39m\u001b[39m\"\u001b[39m, \u001b[39m\"\u001b[39m\u001b[39mFine-Tuned Model\u001b[39m\u001b[39m\"\u001b[39m, \u001b[39m\"\u001b[39m\u001b[39mFew Shot Fine-Tuned Model with Qdrant\u001b[39m\u001b[39m\"\u001b[39m])\n", - "\u001b[0;31mNameError\u001b[0m: name 'df' is not defined" - ] - } - ], - "source": [ - "def plot_correctness(df, answer_columns, labels):\n", - " error_categories = [\"Expected and Right\", \"Expected but IDK\", \"Expected but Wrong\"]\n", - " annotations = [\"Correct\", \"I don't know\", \"Wrong\"]\n", - " cat_map = dict(zip(error_categories, annotations)) \n", - " # Prepare data for Seaborn\n", - " data = []\n", - " for i, col in enumerate(answer_columns):\n", - " results = evaluate_model(df, col)\n", - " for category in error_categories:\n", - " matrix_error = float(results.loc[category].replace(\"%\", \"\"))\n", - " data.append([labels[i], cat_map[category], matrix_error])\n", - "\n", - " df_plot = pd.DataFrame(data, columns=[\"Model\", \"Response\", \"Percentage\"])\n", - " \n", - " # Create the plot\n", - " g = sns.catplot(x=\"Percentage\", y=\"Model\", hue=\"Response\", data=df_plot, kind=\"bar\", height=6, aspect=1.5, palette=\"icefire\")\n", - " \n", - " ax = g.facet_axis(0, 0)\n", - " \n", - " # Add annotations\n", - " for i, p in enumerate(ax.patches):\n", - " ax.annotate(f\"{p.get_width():.0f}%\", (p.get_width(), p.get_y() + p.get_height() / 2),\n", - " ha=\"left\", va=\"center\")\n", - " plt.tight_layout()\n", - " plt.xlabel(\"Percentage (%)\")\n", - " plt.title(\"When Expecting an Answer\")\n", - " plt.show()\n", - "\n", "plot_correctness(df, answer_columns=[\"generated_answer\", \"ft_generated_answer\", \"ft_generated_answer_few_shot\"], labels=[\"Base Model\", \"Fine-Tuned Model\", \"Few Shot Fine-Tuned Model with Qdrant\"])" ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { From 9db7a32cd32faab09a597559c2b04af743b69c96 Mon Sep 17 00:00:00 2001 From: NirantK Date: Fri, 8 Sep 2023 20:16:40 +0530 Subject: [PATCH 32/38] Add clean observations and results --- .../ft_retrieval_augmented_generation.ipynb | 120 +++++++++++++----- 1 file changed, 90 insertions(+), 30 deletions(-) diff --git a/examples/fine-tuned_qa/ft_retrieval_augmented_generation.ipynb b/examples/fine-tuned_qa/ft_retrieval_augmented_generation.ipynb index a7385e5184..a5a35c446d 100644 --- a/examples/fine-tuned_qa/ft_retrieval_augmented_generation.ipynb +++ b/examples/fine-tuned_qa/ft_retrieval_augmented_generation.ipynb @@ -843,6 +843,21 @@ "plot_correctness(df, answer_columns=[\"generated_answer\", \"ft_generated_answer\"], labels=[\"Base Model\", \"Fine-Tuned Model\"])" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Observations\n", + "\n", + "1. The fine-tuned model is better at saying \"I don't know\"\n", + "2. Hallucinations drop from 47% to 7% with fine-tuning\n", + "3. Wrong answers drop from 9% to 3% with fine-tuning\n", + "\n", + "**Correct answers also drop from 44% to 32% with fine-tuning** - this is because the fine-tuned model is **more conservative** and says \"I don't know\" more often. This is a good thing because it's better to say \"I don't know\" than to give a wrong answer.\n", + "\n", + "That said, we want to improve the correctness of the model, even if that increases the hallucinations. We'll use Qdrant and Few-Shot Learning to achieve this." + ] + }, { "attachments": {}, "cell_type": "markdown", @@ -1051,7 +1066,7 @@ }, { "cell_type": "code", - "execution_count": 75, + "execution_count": 84, "metadata": {}, "outputs": [], "source": [ @@ -1116,14 +1131,13 @@ " ]\n", "\n", " rag_prompt = []\n", + " \n", " if len(q1) >= 1:\n", " rag_prompt += q_to_prompt(q1[1])\n", " if len(q2) >= 1:\n", " rag_prompt += q_to_prompt(q2[1])\n", - " # if len(q1) >= 1:\n", - " # rag_prompt += q_to_prompt(q1[2])\n", - " # if len(q2) >= 1:\n", - " # rag_prompt += q_to_prompt(q2[2])\n", + " if len(q1) >= 1:\n", + " rag_prompt += q_to_prompt(q1[2])\n", " \n", " \n", "\n", @@ -1140,13 +1154,13 @@ }, { "cell_type": "code", - "execution_count": 76, + "execution_count": 85, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "c23b4225fb4647a2aef13fa524c16e76", + "model_id": "2d5cd9516e6e44a2b4088c444813d631", "version_major": 2, "version_minor": 0 }, @@ -1174,13 +1188,13 @@ }, { "cell_type": "code", - "execution_count": 77, + "execution_count": 86, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "e2bb01e078ad49269f6b7ce9dec47fe2", + "model_id": "fd872956e92846948c16735391394c63", "version_major": 2, "version_minor": 0 }, @@ -1215,19 +1229,13 @@ }, { "cell_type": "code", - "execution_count": 78, + "execution_count": 87, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "File Status: uploaded\n", - "File Status: uploaded\n", - "File Status: uploaded\n", - "File Status: uploaded\n", - "File Status: uploaded\n", - "File Status: uploaded\n", "File Status: uploaded\n", "File Status: uploaded\n", "File Status: processed\n", @@ -1241,8 +1249,18 @@ "Job Status: running\n", "Job Status: running\n", "Job Status: running\n", - "Job Status: running\n" + "Job Status: succeeded\n" ] + }, + { + "data": { + "text/plain": [ + "'ft:gpt-3.5-turbo-0613:qdrant:trnfewshot20230907:7wWa4owB'" + ] + }, + "execution_count": 87, + "metadata": {}, + "output_type": "execute_result" } ], "source": [ @@ -1258,7 +1276,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 88, "metadata": {}, "outputs": [ { @@ -1323,13 +1341,13 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 89, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "455a302d772e4dd4ac4927193db90214", + "model_id": "f3132d336156412dae3494cec0c5c226", "version_major": 2, "version_minor": 0 }, @@ -1347,7 +1365,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 90, "metadata": {}, "outputs": [], "source": [ @@ -1363,21 +1381,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 91, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "✅ Answered Correctly 46.00%\n", - "❎ Skipped 0.00%\n", - "❌ Wrong Answer 7.00%\n", - "❌ Hallucination 45.00%\n", - "✅ I don't know 2.00%\n", + "✅ Answered Correctly 44.00%\n", + "❎ Skipped 5.00%\n", + "❌ Wrong Answer 4.00%\n", + "❌ Hallucination 25.00%\n", + "✅ I don't know 22.00%\n", "Name: count, dtype: object" ] }, - "execution_count": 73, + "execution_count": 91, "metadata": {}, "output_type": "execute_result" } @@ -1388,7 +1406,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 92, "metadata": {}, "outputs": [ { @@ -1425,7 +1443,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1437,6 +1455,48 @@ "source": [ "plot_correctness(df, answer_columns=[\"generated_answer\", \"ft_generated_answer\", \"ft_generated_answer_few_shot\"], labels=[\"Base Model\", \"Fine-Tuned Model\", \"Few Shot Fine-Tuned Model with Qdrant\"])" ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Results\n", + "\n", + "Category | Base | Fine-Tuned | Fine-Tuned with Qdrant |\n", + "| --- | --- | --- | --- |\n", + "| Correct | 44% | 32% | 44% |\n", + "| Skipped | 0% | 18% | 5% |\n", + "| Wrong | 9% | 3% | 4% |\n", + "| Hallucination | 47% | 7% | 25% |\n", + "| I don't know | 0% | 40% | 22% |" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Observations\n", + "\n", + "#### Compared to base model\n", + "1. The few shot fine-tuned with Qdrant model is as good as the base model at answering questions where the answer is present in the context. 44% of the questions are answered correctly in both cases.\n", + "2. The few shot fine-tuned with Qdrant model is better at saying \"I don't know\" when the answer is not present in the context. 22% of the questions are answered with \"I don't know\" vs 0% for the base model.\n", + "3. The few shot fine-tuned with Qdrant model is better at reducing hallucinations. 25% of the questions are answered with hallucinations vs 47% for the base model.\n", + "\n", + "\n", + "#### Compared to fine-tuned model\n", + "1. The few shot fine-tuned with Qdrant model gets more correct answers than the fine-tuned model: **44% of the questions are answered correctly vs 32%** for the fine-tuned model\n", + "2. The few shot fine-tuned with Qdrant model is better at deciding when to say \"I don't know\" when the answer is not present in the context. **22% of the questions are answered with \"I don't know\" vs 40%** for the fine-tuned model.\n", + "\n", + "Few Shot Fine-Tuning with Qdrant is a great way to control and steer the performance of your RAG system. \n", + "\n", + "Here, we made the model less conservative and more confident by using Qdrant to find similar questions. \n", + "\n", + "One can also use Qdrant to make the model more conservative. We did this by giving examples of questions where the answer is not present in the context. \n", + "This is biasing the model to say \"I don't know\" more often. \n", + "\n", + "Similarly, one can also use Qdrant to make the model more confident by giving examples of questions where the answer is present in the context. \n", + "This biases the model to give an answer more often. " + ] } ], "metadata": { From b4adbcc6aa98d6033d1378bbd53e7f1bcd1339df Mon Sep 17 00:00:00 2001 From: NirantK Date: Fri, 8 Sep 2023 20:19:42 +0530 Subject: [PATCH 33/38] * chore(ft_retrieval_augmented_generation.ipynb): update markdown heading for plotting the results --- examples/fine-tuned_qa/ft_retrieval_augmented_generation.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/examples/fine-tuned_qa/ft_retrieval_augmented_generation.ipynb b/examples/fine-tuned_qa/ft_retrieval_augmented_generation.ipynb index a5a35c446d..87194ceb28 100644 --- a/examples/fine-tuned_qa/ft_retrieval_augmented_generation.ipynb +++ b/examples/fine-tuned_qa/ft_retrieval_augmented_generation.ipynb @@ -691,7 +691,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### Plotting the Results" + "#### Plotting the Results" ] }, { From 1ae556e2534a9c7bf8828ca785907b2974e6e3d9 Mon Sep 17 00:00:00 2001 From: NirantK Date: Mon, 11 Sep 2023 18:16:50 +0530 Subject: [PATCH 34/38] Crisp story --- .../ft_retrieval_augmented_generation.ipynb | 1113 ++++++++--------- 1 file changed, 503 insertions(+), 610 deletions(-) diff --git a/examples/fine-tuned_qa/ft_retrieval_augmented_generation.ipynb b/examples/fine-tuned_qa/ft_retrieval_augmented_generation.ipynb index 87194ceb28..c4fa1269a2 100644 --- a/examples/fine-tuned_qa/ft_retrieval_augmented_generation.ipynb +++ b/examples/fine-tuned_qa/ft_retrieval_augmented_generation.ipynb @@ -35,6 +35,28 @@ "7. Comparison and Results" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Terms, Definitions, and References\n", + "\n", + "**Retrieval Augmented Generation (RAG)?**\n", + "The phrase Retrieval Augmented Generation (RAG) comes from a [recent paper](https://arxiv.org/abs/2005.11401) by Lewis et al. from Facebook AI. The idea is to use a pre-trained language model (LM) to generate text, but to use a separate retrieval system to find relevant documents to condition the LM on. \n", + "\n", + "**What is Qdrant?**\n", + "Qdrant is an open-source vector search engine that allows you to search for similar vectors in a large dataset. It is built in Rust and here we'll use the Python client to interact with it. This is the Retrieval part of RAG.\n", + "\n", + "**What is Few-Shot Learning?**\n", + "Few-shot learning is a type of machine learning where the model is \"improved\" via training or fine-tuning on a small amount of data. In this case, we'll use it to fine-tune the RAG model on a small number of examples from the SQuAD dataset. This is the Augmented part of RAG.\n", + "\n", + "**What is Zero-Shot Learning?**\n", + "Zero-shot learning is a type of machine learning where the model is \"improved\" via training or fine-tuning without any dataset specific information. \n", + "\n", + "**What is Fine-Tuning?**\n", + "Fine-tuning is a type of machine learning where the model is \"improved\" via training or fine-tuning on a small amount of data. In this case, we'll use it to fine-tune the RAG model on a small number of examples from the SQuAD dataset. The LLM is what makes the Generation part of RAG." + ] + }, { "attachments": {}, "cell_type": "markdown", @@ -47,7 +69,7 @@ }, { "cell_type": "code", - "execution_count": 76, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -76,6 +98,8 @@ "import numpy as np\n", "from sklearn.metrics import confusion_matrix\n", "\n", + "import warnings\n", + "warnings.filterwarnings('ignore')\n", "\n", "tqdm.pandas()" ] @@ -98,42 +122,13 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 3, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "--2023-09-08 16:40:51-- https://rajpurkar.github.io/SQuAD-explorer/dataset/train-v2.0.json\n", - "Resolving rajpurkar.github.io (rajpurkar.github.io)... 185.199.111.153, 185.199.108.153, 185.199.109.153, ...\n", - "Connecting to rajpurkar.github.io (rajpurkar.github.io)|185.199.111.153|:443... connected.\n", - "HTTP request sent, awaiting response... 200 OK\n", - "Length: 42123633 (40M) [application/json]\n", - "Saving to: ‘local_cache/train.json’\n", - "\n", - "local_cache/train.j 100%[===================>] 40.17M 36.1MB/s in 1.1s \n", - "\n", - "2023-09-08 16:40:55 (36.1 MB/s) - ‘local_cache/train.json’ saved [42123633/42123633]\n", - "\n", - "--2023-09-08 16:40:55-- https://rajpurkar.github.io/SQuAD-explorer/dataset/dev-v2.0.json\n", - "Resolving rajpurkar.github.io (rajpurkar.github.io)... 185.199.108.153, 185.199.109.153, 185.199.110.153, ...\n", - "Connecting to rajpurkar.github.io (rajpurkar.github.io)|185.199.108.153|:443... connected.\n", - "HTTP request sent, awaiting response... 200 OK\n", - "Length: 4370528 (4.2M) [application/json]\n", - "Saving to: ‘local_cache/dev.json’\n", - "\n", - "local_cache/dev.jso 100%[===================>] 4.17M 14.0MB/s in 0.3s \n", - "\n", - "2023-09-08 16:40:56 (14.0 MB/s) - ‘local_cache/dev.json’ saved [4370528/4370528]\n", - "\n" - ] - } - ], + "outputs": [], "source": [ - "!mkdir -p local_cache\n", - "!wget https://rajpurkar.github.io/SQuAD-explorer/dataset/train-v2.0.json -O local_cache/train.json\n", - "!wget https://rajpurkar.github.io/SQuAD-explorer/dataset/dev-v2.0.json -O local_cache/dev.json" + "# !mkdir -p local_cache\n", + "# !wget https://rajpurkar.github.io/SQuAD-explorer/dataset/train-v2.0.json -O local_cache/train.json\n", + "# !wget https://rajpurkar.github.io/SQuAD-explorer/dataset/dev-v2.0.json -O local_cache/dev.json" ] }, { @@ -145,7 +140,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -174,6 +169,9 @@ " return df\n", "\n", "def get_diverse_sample(df, sample_size=100, random_state=42):\n", + " \"\"\"\n", + " Get a diverse sample of the dataframe by sampling from each title\n", + " \"\"\"\n", " sample_df = df.groupby(['title', 'is_impossible']).apply(lambda x: x.sample(min(len(x), max(1, sample_size // 50)), random_state=random_state)).reset_index(drop=True)\n", " \n", " if len(sample_df) < sample_size:\n", @@ -196,12 +194,18 @@ "source": [ "## 3. Answering using Base gpt-3.5-turbo-0613 model\n", "\n", - "### 3.1 Zero Shot Prompt" + "### 3.1 Zero Shot Prompt\n", + "\n", + "Let's start by using the base gpt-3.5-turbo-0613 model to answer the questions. This prompt is a simple concatenation of the question and context, with a separator token in between: `\\n\\n`. We've a simple instruction part of the prompt: \n", + "\n", + "> Answer the following Question based on the Context only. Only answer from the Context. If you don't know the answer, say 'I don't know'.\n", + "\n", + "Other prompts are possible, but this is a good starting point. We'll use this prompt to answer the questions in the validation set. " ] }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ @@ -223,12 +227,14 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### 3.2 Answering using Zero Shot Prompt" + "### 3.2 Answering using Zero Shot Prompt\n", + "\n", + "Next, you'll need some re-usable functions which make an OpenAI API Call and return the answer. You'll use the `ChatCompletion.create` endpoint of the API, which takes a prompt and returns the completed text." ] }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ @@ -255,34 +261,198 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "⏰ **Time to run: ~3 min**" + "⏰ **Time to run: ~3 min**, 🛜 Needs Internet Connection" ] }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 7, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 100/100 [01:28<00:00, 1.13it/s]\n" - ] - } - ], + "outputs": [], "source": [ "# Use progress_apply with tqdm for progress bar\n", - "df[\"generated_answer\"] = df.progress_apply(answer_question, axis=1)" + "df[\"generated_answer\"] = df.progress_apply(answer_question, axis=1)\n", + "df.to_json(\"local_cache/100_val.json\", orient=\"records\", lines=True)\n", + "df = pd.read_json(\"local_cache/100_val.json\", orient=\"records\", lines=True)" ] }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 8, "metadata": {}, - "outputs": [], + "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", + " \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", + " \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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
titlequestioncontextis_impossibleanswers
0Scottish_ParliamentWhat consequence of establishing the Scottish ...A procedural consequence of the establishment ...False[able to vote on domestic legislation that app...
1ImperialismImperialism is less often associated with whic...The principles of imperialism are often genera...True[]
2Economic_inequalityWhat issues can't prevent women from working o...When a person’s capabilities are lowered, they...True[]
3Southern_CaliforniaWhat county are Los Angeles, Orange, San Diego...Its counties of Los Angeles, Orange, San Diego...True[]
4French_and_Indian_WarWhen was the deportation of Canadians?Britain gained control of French Canada and Ac...True[]
..................
95GeologyIn the layered Earth model, what is the inner ...Seismologists can use the arrival times of sei...True[]
96Prime_numberWhat type of value would the Basel function ha...The zeta function is closely related to prime ...True[]
97Fresno,_CaliforniaWhat does the San Joaquin Valley Railroad cros...Passenger rail service is provided by Amtrak S...True[]
98Victoria_(Australia)What party rules in Melbourne's inner regions?The centre-left Australian Labor Party (ALP), ...False[The Greens, Australian Greens, Greens]
99Immune_systemThe speed of the killing response of the human...In humans, this response is activated by compl...False[signal amplification, signal amplification, s...
\n", + "

100 rows × 5 columns

\n", + "
" + ], + "text/plain": [ + " title question \\\n", + "0 Scottish_Parliament What consequence of establishing the Scottish ... \n", + "1 Imperialism Imperialism is less often associated with whic... \n", + "2 Economic_inequality What issues can't prevent women from working o... \n", + "3 Southern_California What county are Los Angeles, Orange, San Diego... \n", + "4 French_and_Indian_War When was the deportation of Canadians? \n", + ".. ... ... \n", + "95 Geology In the layered Earth model, what is the inner ... \n", + "96 Prime_number What type of value would the Basel function ha... \n", + "97 Fresno,_California What does the San Joaquin Valley Railroad cros... \n", + "98 Victoria_(Australia) What party rules in Melbourne's inner regions? \n", + "99 Immune_system The speed of the killing response of the human... \n", + "\n", + " context is_impossible \\\n", + "0 A procedural consequence of the establishment ... False \n", + "1 The principles of imperialism are often genera... True \n", + "2 When a person’s capabilities are lowered, they... True \n", + "3 Its counties of Los Angeles, Orange, San Diego... True \n", + "4 Britain gained control of French Canada and Ac... True \n", + ".. ... ... \n", + "95 Seismologists can use the arrival times of sei... True \n", + "96 The zeta function is closely related to prime ... True \n", + "97 Passenger rail service is provided by Amtrak S... True \n", + "98 The centre-left Australian Labor Party (ALP), ... False \n", + "99 In humans, this response is activated by compl... False \n", + "\n", + " answers \n", + "0 [able to vote on domestic legislation that app... \n", + "1 [] \n", + "2 [] \n", + "3 [] \n", + "4 [] \n", + ".. ... \n", + "95 [] \n", + "96 [] \n", + "97 [] \n", + "98 [The Greens, Australian Greens, Greens] \n", + "99 [signal amplification, signal amplification, s... \n", + "\n", + "[100 rows x 5 columns]" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "df.to_json(\"local_cache/100_val.json\", orient=\"records\", lines=True)" + "df" ] }, { @@ -295,22 +465,16 @@ "\n", "### 4.1 Prepare the Fine-Tuning Data\n", "\n", - "We need to prepare the data for fine-tuning. We'll use a few samples from train split of same dataset as before, but we'll add the answer to the context. This will help the model learn to retrieve the answer from the context." + "We need to prepare the data for fine-tuning. We'll use a few samples from train split of same dataset as before, but we'll add the answer to the context. This will help the model learn to retrieve the answer from the context. \n", + "\n", + "Our instruction prompt is the same as before, and so is the system prompt. " ] }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 9, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 100/100 [00:00<00:00, 65659.11it/s]\n" - ] - } - ], + "outputs": [], "source": [ "def dataframe_to_jsonl(df):\n", " def create_jsonl_entry(row):\n", @@ -328,7 +492,7 @@ " ]\n", " return json.dumps({\"messages\": messages})\n", "\n", - " jsonl_output = df.progress_apply(create_jsonl_entry, axis=1)\n", + " jsonl_output = df.apply(create_jsonl_entry, axis=1)\n", " return \"\\n\".join(jsonl_output)\n", "\n", "train_sample = get_diverse_sample(train_df, sample_size=100, random_state=42)\n", @@ -352,11 +516,14 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 10, "metadata": {}, "outputs": [], "source": [ "class OpenAIFineTuner:\n", + " \"\"\"\n", + " Class to fine tune OpenAI models\n", + " \"\"\"\n", " def __init__(self, training_file_path, model_name, suffix):\n", " self.training_file_path = training_file_path\n", " self.model_name = model_name\n", @@ -412,54 +579,14 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "⏰ **Time to run: ~10-20 minutes**" + "⏰ **Time to run: ~10-20 minutes**, 🛜 Needs Internet Connection" ] }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 11, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "File Status: uploaded\n", - "File Status: processed\n", - "Job Status: running\n", - "Job Status: running\n", - "Job Status: running\n", - "Job Status: running\n", - "Job Status: running\n", - "Job Status: running\n", - "Job Status: running\n", - "Job Status: running\n", - "Job Status: running\n", - "Job Status: running\n", - "Job Status: running\n", - "Job Status: running\n", - "Job Status: running\n", - "Job Status: running\n", - "Job Status: running\n", - "Job Status: running\n", - "Job Status: running\n", - "Job Status: running\n", - "Job Status: running\n", - "Job Status: running\n", - "Job Status: succeeded\n" - ] - }, - { - "data": { - "text/plain": [ - "'ft:gpt-3.5-turbo-0613:qdrant:100trn20230907:7wU85Xwb'" - ] - }, - "execution_count": 16, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "model_id = fine_tuner.fine_tune_model()\n", "model_id" @@ -469,25 +596,16 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "#### 4.2.1 Try out the Fine-Tuned Model" + "#### 4.2.1 Try out the Fine-Tuned Model\n", + "\n", + "Let's try out the fine-tuned model on the same validation set as before. You'll use the same prompt as before, but you will use the fine-tuned model instead of the base model. Before you do that, you can make a simple call to get a sense of how the fine-tuned model is doing." ] }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 12, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{\n", - " \"role\": \"assistant\",\n", - " \"content\": \"I don't know\"\n", - "}\n" - ] - } - ], + "outputs": [], "source": [ "completion = openai.ChatCompletion.create(\n", " model=model_id,\n", @@ -509,29 +627,18 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### 4.3 Answer Using the Fine-Tuned Model" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "⏰ **Time to run: ~5 min**" + "### 4.3 Answer Using the Fine-Tuned Model\n", + "\n", + "This is the same as before, but you'll use the fine-tuned model instead of the base model.\n", + "\n", + "⏰ **Time to run: ~5 min**, 🛜 Needs Internet Connection" ] }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 13, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 100/100 [05:09<00:00, 3.10s/it]\n" - ] - } - ], + "outputs": [], "source": [ "df[\"ft_generated_answer\"] = df.progress_apply(answer_question, model=model_id, axis=1)" ] @@ -559,163 +666,168 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 193, "metadata": {}, "outputs": [], "source": [ - "class ConfusionMatrixEvaluator:\n", - " def __init__(self, df, answers_column=\"generated_answer\"):\n", + "import pandas as pd\n", + "import seaborn as sns\n", + "import matplotlib.pyplot as plt\n", + "\n", + "class Evaluator:\n", + " def __init__(self, df):\n", " self.df = df\n", - " self.y_pred = []\n", - " self.labels = [\n", - " \"✅ Answered Correctly\",\n", - " \"❎ Skipped\",\n", - " \"❌ Wrong Answer\", \n", - " \"❌ Hallucination\", \n", - " \"✅ I don't know\"\n", - " ]\n", - " self.answers_column = answers_column\n", + " self.y_pred = pd.Series() # Initialize as empty Series\n", + " self.labels_answer_expected = [\"✅ Answered Correctly\", \"❎ Skipped\", \"❌ Wrong Answer\"]\n", + " self.labels_idk_expected = [\"❌ Hallucination\", \"✅ I don't know\"]\n", "\n", - " def _evaluate_single_row(self, row):\n", - " is_impossible = row[\"is_impossible\"]\n", - " generated_answer = row[self.answers_column].lower()\n", + " def _evaluate_answer_expected(self, row, answers_column):\n", + " generated_answer = row[answers_column].lower()\n", " actual_answers = [ans.lower() for ans in row[\"answers\"]]\n", - "\n", - " y_pred = (\n", - " \"✅ Answered Correctly\"\n", - " if not is_impossible\n", - " and any(ans in generated_answer for ans in actual_answers)\n", - " else \"❎ Skipped\"\n", - " if not is_impossible and generated_answer == \"i don't know\"\n", + " return (\n", + " \"✅ Answered Correctly\" if any(ans in generated_answer for ans in actual_answers)\n", + " else \"❎ Skipped\" if generated_answer == \"i don't know\"\n", " else \"❌ Wrong Answer\"\n", - " if not is_impossible and generated_answer not in actual_answers\n", - " else \"❌ Hallucination\"\n", - " if is_impossible and generated_answer != \"i don't know\"\n", - " else \"✅ I don't know\"\n", " )\n", - " return y_pred\n", "\n", - " def evaluate_answers(self):\n", - " self.y_pred = self.df.apply(self._evaluate_single_row, axis=1)\n", - "\n", - " def generate_matrices(self, use_percentages=False):\n", - " # Using value_counts to create a Series of frequencies, then reindexing to include missing labels with count 0\n", - " freq_series = self.y_pred.value_counts().reindex(self.labels, fill_value=0)\n", - " if use_percentages:\n", - " total = freq_series.sum()\n", - " freq_series = (freq_series / total * 100).apply(\"{0:.2f}%\".format)\n", - " return freq_series\n", + " def _evaluate_idk_expected(self, row, answers_column):\n", + " generated_answer = row[answers_column].lower()\n", + " return (\n", + " \"❌ Hallucination\" if generated_answer != \"i don't know\"\n", + " else \"✅ I don't know\"\n", + " )\n", "\n", + " def _evaluate_single_row(self, row, answers_column):\n", + " is_impossible = row[\"is_impossible\"]\n", + " return (\n", + " self._evaluate_answer_expected(row, answers_column) if not is_impossible\n", + " else self._evaluate_idk_expected(row, answers_column)\n", + " )\n", "\n", - "def evaluate_model(df, answers_column):\n", - " \"\"\"\n", - " Evaluate the confusion matrix for a given DataFrame and answer column.\n", - " \"\"\"\n", - " evaluator = ConfusionMatrixEvaluator(df, answers_column=answers_column)\n", - " evaluator.evaluate_answers()\n", - " error_categories = evaluator.generate_matrices(use_percentages=True)\n", - " return error_categories" + " def evaluate_model(self, answers_column=\"generated_answer\"):\n", + " self.y_pred = pd.Series(self.df.apply(self._evaluate_single_row, answers_column=answers_column, axis=1))\n", + " freq_series = self.y_pred.value_counts()\n", + " \n", + " # Counting rows for each scenario\n", + " total_answer_expected = len(self.df[self.df['is_impossible'] == False])\n", + " total_idk_expected = len(self.df[self.df['is_impossible'] == True])\n", + " \n", + " freq_answer_expected = (freq_series / total_answer_expected * 100).round(2).reindex(self.labels_answer_expected, fill_value=0)\n", + " freq_idk_expected = (freq_series / total_idk_expected * 100).round(2).reindex(self.labels_idk_expected, fill_value=0)\n", + " return freq_answer_expected.to_dict(), freq_idk_expected.to_dict()\n", + "\n", + " def print_eval(self):\n", + " answer_columns=[\"generated_answer\", \"ft_generated_answer\"]\n", + " baseline_correctness, baseline_idk = self.evaluate_model()\n", + " ft_correctness, ft_idk = self.evaluate_model(self.df, answer_columns[1])\n", + " print(\"When the model should answer correctly:\")\n", + " eval_df = pd.merge(\n", + " baseline_correctness.rename(\"Baseline\"),\n", + " ft_correctness.rename(\"Fine-Tuned\"),\n", + " left_index=True,\n", + " right_index=True,\n", + " )\n", + " print(eval_df)\n", + " print(\"\\n\\n\\nWhen the model should say 'I don't know':\")\n", + " eval_df = pd.merge(\n", + " baseline_idk.rename(\"Baseline\"),\n", + " ft_idk.rename(\"Fine-Tuned\"),\n", + " left_index=True,\n", + " right_index=True,\n", + " )\n", + " print(eval_df)\n", + " \n", + " def plot_model_comparison(self, answer_columns=[\"generated_answer\", \"ft_generated_answer\"], scenario=\"answer_expected\", nice_names=[\"Baseline\", \"Fine-Tuned\"]):\n", + " \n", + " results = []\n", + " for col in answer_columns:\n", + " answer_expected, idk_expected = self.evaluate_model(col)\n", + " if scenario == \"answer_expected\":\n", + " results.append(answer_expected)\n", + " elif scenario == \"idk_expected\":\n", + " results.append(idk_expected)\n", + " else:\n", + " raise ValueError(\"Invalid scenario\")\n", + " \n", + " \n", + " results_df = pd.DataFrame(results, index=nice_names)\n", + " if scenario == \"answer_expected\":\n", + " results_df = results_df.reindex(self.labels_answer_expected, axis=1)\n", + " elif scenario == \"idk_expected\":\n", + " results_df = results_df.reindex(self.labels_idk_expected, axis=1)\n", + " \n", + " melted_df = results_df.reset_index().melt(id_vars='index', var_name='Status', value_name='Frequency')\n", + " sns.set_theme(style=\"whitegrid\", palette=\"icefire\")\n", + " g = sns.catplot(data=melted_df, x='Frequency', y='index', hue='Status', kind='bar', height=5, aspect=2)\n", + "\n", + " # Annotating each bar\n", + " for p in g.ax.patches:\n", + " g.ax.annotate(f\"{p.get_width():.0f}%\", (p.get_width()+5, p.get_y() + p.get_height() / 2),\n", + " textcoords=\"offset points\",\n", + " xytext=(0, 0),\n", + " ha='center', va='center')\n", + " plt.ylabel(\"Model\")\n", + " plt.xlabel(\"Percentage\")\n", + " plt.xlim(0, 100)\n", + " plt.tight_layout()\n", + " plt.title(scenario.replace(\"_\", \" \").title())\n", + " plt.show()\n", + "\n", + "\n", + "# Compare the results by merging into one dataframe\n", + "evaluator = Evaluator(df)\n", + "# evaluator.evaluate_model(answers_column=\"ft_generated_answer\")\n", + "# evaluator.plot_model_comparison([\"generated_answer\", \"ft_generated_answer\"], scenario=\"answer_expected\", nice_names=[\"Baseline\", \"Fine-Tuned\"])" ] }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 98, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "✅ Answered Correctly 44.00%\n", - "❎ Skipped 0.00%\n", - "❌ Wrong Answer 9.00%\n", - "❌ Hallucination 47.00%\n", - "✅ I don't know 0.00%\n", - "Name: count, dtype: object" - ] - }, - "execution_count": 31, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ - "evaluate_model(df, \"generated_answer\")" + "# Optionally, save the results to a JSON file\n", + "df.to_json(\"local_cache/100_val_ft.json\", orient=\"records\", lines=True)\n", + "df = pd.read_json(\"local_cache/100_val_ft.json\", orient=\"records\", lines=True)" ] }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 194, "metadata": {}, "outputs": [ { "data": { + "image/png": "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", "text/plain": [ - "✅ Answered Correctly 32.00%\n", - "❎ Skipped 18.00%\n", - "❌ Wrong Answer 3.00%\n", - "❌ Hallucination 7.00%\n", - "✅ I don't know 40.00%\n", - "Name: count, dtype: object" + "
" ] }, - "execution_count": 32, "metadata": {}, - "output_type": "execute_result" + "output_type": "display_data" } ], "source": [ - "evaluate_model(df, \"ft_generated_answer\")" + "evaluator.plot_model_comparison([\"generated_answer\", \"ft_generated_answer\"], scenario=\"answer_expected\", nice_names=[\"Baseline\", \"Fine-Tuned\"])" ] }, { - "cell_type": "code", - "execution_count": 33, - "metadata": {}, - "outputs": [], - "source": [ - "# Optionally, save the results to a JSON file\n", - "df.to_json(\"local_cache/100_val_ft.json\", orient=\"records\", lines=True)" - ] - }, - { - "cell_type": "code", - "execution_count": 34, - "metadata": {}, - "outputs": [], - "source": [ - "df = pd.read_json(\"local_cache/100_val_ft.json\", orient=\"records\", lines=True)" - ] - }, - { - "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ - "#### Plotting the Results" + "Notice that the fine-tuned model skips questions more often -- and makes fewer misakes. This is because the fine-tuned model is more conservative and skips questions when it's not sure." ] }, { "cell_type": "code", - "execution_count": 36, + "execution_count": 195, "metadata": {}, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/opt/homebrew/Caskroom/miniconda/base/envs/fst/lib/python3.9/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n", - " if pd.api.types.is_categorical_dtype(vector):\n", - "/opt/homebrew/Caskroom/miniconda/base/envs/fst/lib/python3.9/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n", - " if pd.api.types.is_categorical_dtype(vector):\n", - "/opt/homebrew/Caskroom/miniconda/base/envs/fst/lib/python3.9/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n", - " if pd.api.types.is_categorical_dtype(vector):\n" - ] - }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -723,139 +835,24 @@ } ], "source": [ - "def plot_overall_error(df, answer_columns, labels):\n", - " error_categories = [\"❌ Hallucination\", \"❌ Wrong Answer\"]\n", - " \n", - " # Prepare data for Seaborn\n", - " data = []\n", - " for i, col in enumerate(answer_columns):\n", - " results = evaluate_model(df, col)\n", - " matrix_error = sum([float(results.loc[cat].replace(\"%\", \"\")) for cat in error_categories])\n", - " data.append([labels[i], matrix_error])\n", - "\n", - " df_plot = pd.DataFrame(data, columns=[\"Model\", \"Overall Error\"])\n", - " \n", - " # Create the plot\n", - " plt.figure(figsize=(10, 6))\n", - " ax = sns.barplot(x=\"Overall Error\", y=\"Model\", data=df_plot, palette=\"icefire\")\n", - " \n", - " # Add annotations\n", - " for i, p in enumerate(ax.patches):\n", - " ax.text(p.get_width() - 6, p.get_y() + p.get_height() / 2, f\"{p.get_width():.0f}%\", \n", - " va='center', color='white', fontweight='bold')\n", - "\n", - " plt.xlabel(\"Error (%) - Lower is Better\")\n", - " plt.title(\"Total Error Comparison\")\n", - " plt.show()\n", - "\n", - "# Plot only the overall error\n", - "plot_overall_error(df, answer_columns=[\"generated_answer\", \"ft_generated_answer\"], labels=[\"Base gpt-3.5-turbo-0613 Model\", \"Fine-Tuned Model\"])" - ] - }, - { - "cell_type": "code", - "execution_count": 51, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/opt/homebrew/Caskroom/miniconda/base/envs/fst/lib/python3.9/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n", - " if pd.api.types.is_categorical_dtype(vector):\n", - "/opt/homebrew/Caskroom/miniconda/base/envs/fst/lib/python3.9/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n", - " if pd.api.types.is_categorical_dtype(vector):\n", - "/opt/homebrew/Caskroom/miniconda/base/envs/fst/lib/python3.9/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n", - " if pd.api.types.is_categorical_dtype(vector):\n", - "/opt/homebrew/Caskroom/miniconda/base/envs/fst/lib/python3.9/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n", - " if pd.api.types.is_categorical_dtype(vector):\n", - "/opt/homebrew/Caskroom/miniconda/base/envs/fst/lib/python3.9/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n", - " if pd.api.types.is_categorical_dtype(vector):\n", - "/opt/homebrew/Caskroom/miniconda/base/envs/fst/lib/python3.9/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n", - " if pd.api.types.is_categorical_dtype(vector):\n", - "/opt/homebrew/Caskroom/miniconda/base/envs/fst/lib/python3.9/site-packages/seaborn/axisgrid.py:118: UserWarning: The figure layout has changed to tight\n", - " self._figure.tight_layout(*args, **kwargs)\n", - "/opt/homebrew/Caskroom/miniconda/base/envs/fst/lib/python3.9/site-packages/seaborn/utils.py:80: UserWarning: Glyph 9989 (\\N{WHITE HEAVY CHECK MARK}) missing from current font.\n", - " fig.canvas.draw()\n", - "/opt/homebrew/Caskroom/miniconda/base/envs/fst/lib/python3.9/site-packages/seaborn/utils.py:80: UserWarning: Glyph 10062 (\\N{NEGATIVE SQUARED CROSS MARK}) missing from current font.\n", - " fig.canvas.draw()\n", - "/opt/homebrew/Caskroom/miniconda/base/envs/fst/lib/python3.9/site-packages/seaborn/utils.py:80: UserWarning: Glyph 10060 (\\N{CROSS MARK}) missing from current font.\n", - " fig.canvas.draw()\n", - "/opt/homebrew/Caskroom/miniconda/base/envs/fst/lib/python3.9/site-packages/IPython/core/pylabtools.py:152: UserWarning: Glyph 9989 (\\N{WHITE HEAVY CHECK MARK}) missing from current font.\n", - " fig.canvas.print_figure(bytes_io, **kw)\n", - "/opt/homebrew/Caskroom/miniconda/base/envs/fst/lib/python3.9/site-packages/IPython/core/pylabtools.py:152: UserWarning: Glyph 10062 (\\N{NEGATIVE SQUARED CROSS MARK}) missing from current font.\n", - " fig.canvas.print_figure(bytes_io, **kw)\n", - "/opt/homebrew/Caskroom/miniconda/base/envs/fst/lib/python3.9/site-packages/IPython/core/pylabtools.py:152: UserWarning: Glyph 10060 (\\N{CROSS MARK}) missing from current font.\n", - " fig.canvas.print_figure(bytes_io, **kw)\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "def plot_correctness(df, answer_columns, labels):\n", - " error_categories = [\n", - " \"✅ Answered Correctly\",\n", - " \"❎ Skipped\",\n", - " \"❌ Wrong Answer\", \n", - " \"❌ Hallucination\", \n", - " \"✅ I don't know\"\n", - " ]\n", - " annotations = [\n", - " \"✅ Answered Correctly\",\n", - " \"❎ Skipped\",\n", - " \"❌ Wrong Answer\", \n", - " \"❌ Hallucination\", \n", - " \"✅ I don't know\"\n", - " ]\n", - " cat_map = dict(zip(error_categories, annotations)) \n", - " # Prepare data for Seaborn\n", - " data = []\n", - " for i, col in enumerate(answer_columns):\n", - " results = evaluate_model(df, col)\n", - " for category in error_categories:\n", - " matrix_error = float(results.loc[category].replace(\"%\", \"\"))\n", - " data.append([labels[i], cat_map[category], matrix_error])\n", - "\n", - " df_plot = pd.DataFrame(data, columns=[\"Model\", \"Response\", \"Percentage\"])\n", - " \n", - " # Create the plot\n", - " g = sns.catplot(x=\"Percentage\", y=\"Model\", hue=\"Response\", data=df_plot, kind=\"bar\", height=6, aspect=1.5, palette=\"icefire\")\n", - " \n", - " ax = g.facet_axis(0, 0)\n", - " \n", - " # Add annotations\n", - " for i, p in enumerate(ax.patches):\n", - " ax.annotate(f\"{p.get_width():.0f}%\", (p.get_width(), p.get_y() + p.get_height() / 2),\n", - " ha=\"left\", va=\"center\")\n", - " plt.xlabel(\"Percentage (%)\")\n", - " plt.title(\"Answer Distribution\")\n", - " plt.show()\n", - "\n", - "plot_correctness(df, answer_columns=[\"generated_answer\", \"ft_generated_answer\"], labels=[\"Base Model\", \"Fine-Tuned Model\"])" + "evaluator.plot_model_comparison([\"generated_answer\", \"ft_generated_answer\"], scenario=\"idk_expected\", nice_names=[\"Baseline\", \"Fine-Tuned\"])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ + "Notice that the fine-tuned model has learnt to say \"I don't know\" a lot better than the prompt. Or, the model has gotten good at skipping questions.\n", + "\n", "### Observations\n", "\n", "1. The fine-tuned model is better at saying \"I don't know\"\n", - "2. Hallucinations drop from 47% to 7% with fine-tuning\n", - "3. Wrong answers drop from 9% to 3% with fine-tuning\n", + "2. Hallucinations drop from 100% to 0% with fine-tuning\n", + "3. Wrong answers drop from 17% to 6% with fine-tuning\n", "\n", - "**Correct answers also drop from 44% to 32% with fine-tuning** - this is because the fine-tuned model is **more conservative** and says \"I don't know\" more often. This is a good thing because it's better to say \"I don't know\" than to give a wrong answer.\n", + "**Correct answers also drop from 83% to 60% with fine-tuning** - this is because the fine-tuned model is **more conservative** and says \"I don't know\" more often. This is a good thing because it's better to say \"I don't know\" than to give a wrong answer.\n", "\n", - "That said, we want to improve the correctness of the model, even if that increases the hallucinations. We'll use Qdrant and Few-Shot Learning to achieve this." + "That said, we want to improve the correctness of the model, even if that increases the hallucinations. We're looking for a model that is both correct and conservative, striking a balance between the two. We'll use Qdrant and Few-Shot Learning to achieve this." ] }, { @@ -863,11 +860,21 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Section B: Few Shot Learning\n", + "**💪 You're 2/3rds of the way there! Keep reading!**\n", "\n", + "# Section B: Few Shot Learning\n", "\n", "We'll select a few examples from the dataset, including cases where the answer is not present in the context. We'll then use these examples to create a prompt that we can use to fine-tune the model. We'll then measure the performance of the fine-tuned model.\n", "\n", + "**What is next?**\n", + "\n", + "5. Fine-Tuning OpenAI Model with Qdrant\n", + " 5.1 Embed the Fine-Tuning Data\n", + " 5.2 Embedding the Questions\n", + "6. Using Qdrant to Improve RAG Prompt\n", + "7. Comparison and Results\n", + "\n", + "\n", "## 5. Fine-Tuning OpenAI Model with Qdrant\n", "\n", "So far, we've been using the OpenAI model to answer questions without using examples of the answer. The previous step made it work better on in-context examples, while this one helps it generalize to unseen data, and attempt to learn when to say \"I don't know\" and when to give an answer.\n", @@ -889,16 +896,7 @@ }, { "cell_type": "code", - "execution_count": 38, - "metadata": {}, - "outputs": [], - "source": [ - "# !pip install fastembed" - ] - }, - { - "cell_type": "code", - "execution_count": 39, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -918,7 +916,7 @@ }, { "cell_type": "code", - "execution_count": 40, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -928,7 +926,7 @@ "\n", "collection_name = \"squadv2-cookbook\"\n", "\n", - "# # Create the collection\n", + "# # Create the collection, run this only once\n", "# qdrant_client.recreate_collection(\n", "# collection_name=collection_name,\n", "# vectors_config=VectorParams(size=384, distance=Distance.COSINE),\n", @@ -937,17 +935,9 @@ }, { "cell_type": "code", - "execution_count": 41, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 77.7M/77.7M [00:07<00:00, 10.9MiB/s]\n" - ] - } - ], + "outputs": [], "source": [ "from fastembed.embedding import DefaultEmbedding\n", "from typing import List\n", @@ -964,66 +954,76 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### 5.3 Embedding the Questions\n", + "### 5.2 Embedding the Questions\n", + "\n", + "Next, you'll embed the entire training set questions. You'll use the question to question similarity to find the most similar questions to the question we're looking for. This is a workflow which is used in RAG to leverage the OpenAI model ability of incontext learning with more examples. This is what we call Few Shot Learning here.\n", + "\n", + "**❗️⏰ Important Note: This step can take upto 3 hours to complete. Please be patient. If you see Out of Memory errors or Kernel Crashes, please reduce the batch size to 32, restart the kernel and run the notebook again. This code needs to be run only ONCE.**\n", + "\n", + "## Function Breakdown for `generate_points_from_dataframe`\n", "\n", - "We embed the entire training set questions. We'll use the question to question similarity to find the most similar questions to the question we're looking for. This is a workflow which is used in RAG to leverage the OpenAI model ability of incontext learning with more examples. This is what we call Few Shot Learning here.\n", + "1. **Initialization**: `batch_size = 512` and `total_batches` set the stage for how many questions will be processed in one go. This is to prevent memory issues. If your machine can handle more, feel free to increase the batch size. If your kernel crashes, reduce the batch size to 32 and try again.\n", + "2. **Progress Bar**: `tqdm` gives you a nice progress bar so you don't fall asleep.\n", + "3. **Batch Loop**: The for-loop iterates through batches. `start_idx` and `end_idx` define the slice of the DataFrame to process.\n", + "4. **Generate Embeddings**: `batch_embeddings = embedding_model.embed(batch, batch_size=batch_size)` - This is where the magic happens. Your questions get turned into embeddings.\n", + "5. **PointStruct Generation**: Using `.progress_apply`, it turns each row into a `PointStruct` object. This includes an ID, the embedding vector, and other metadata.\n", "\n", - "**❗️⏰ Important Note: This step can take upto 3 hours to complete. Please be patient. If you see Out of Memory errors or Kernel Crashes, please reduce the batch size to 32, restart the kernel and run the notebook again. This code needs to be run only ONCE.**" + "Returns the list of `PointStruct` objects, which can be used to create a collection in Qdrant." ] }, { "cell_type": "code", - "execution_count": 42, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ - "# def generate_points_from_dataframe(df: pd.DataFrame) -> List[PointStruct]:\n", - "# batch_size = 512\n", - "# questions = df[\"question\"].tolist()\n", - "# total_batches = len(questions) // batch_size + 1\n", + "def generate_points_from_dataframe(df: pd.DataFrame) -> List[PointStruct]:\n", + " batch_size = 512\n", + " questions = df[\"question\"].tolist()\n", + " total_batches = len(questions) // batch_size + 1\n", " \n", - "# pbar = tqdm(total=len(questions), desc=\"Generating embeddings\")\n", + " pbar = tqdm(total=len(questions), desc=\"Generating embeddings\")\n", " \n", - "# # Generate embeddings in batches to improve performance\n", - "# embeddings = []\n", - "# for i in range(total_batches):\n", - "# start_idx = i * batch_size\n", - "# end_idx = min((i + 1) * batch_size, len(questions))\n", - "# batch = questions[start_idx:end_idx]\n", + " # Generate embeddings in batches to improve performance\n", + " embeddings = []\n", + " for i in range(total_batches):\n", + " start_idx = i * batch_size\n", + " end_idx = min((i + 1) * batch_size, len(questions))\n", + " batch = questions[start_idx:end_idx]\n", " \n", - "# batch_embeddings = embedding_model.embed(batch, batch_size=batch_size)\n", - "# embeddings.extend(batch_embeddings)\n", - "# pbar.update(len(batch))\n", + " batch_embeddings = embedding_model.embed(batch, batch_size=batch_size)\n", + " embeddings.extend(batch_embeddings)\n", + " pbar.update(len(batch))\n", " \n", - "# pbar.close()\n", + " pbar.close()\n", " \n", - "# # Convert embeddings to list of lists\n", - "# embeddings_list = [embedding.tolist() for embedding in embeddings]\n", + " # Convert embeddings to list of lists\n", + " embeddings_list = [embedding.tolist() for embedding in embeddings]\n", " \n", - "# # Create a temporary DataFrame to hold the embeddings and existing DataFrame columns\n", - "# temp_df = df.copy()\n", - "# temp_df[\"embeddings\"] = embeddings_list\n", - "# temp_df[\"id\"] = temp_df.index\n", + " # Create a temporary DataFrame to hold the embeddings and existing DataFrame columns\n", + " temp_df = df.copy()\n", + " temp_df[\"embeddings\"] = embeddings_list\n", + " temp_df[\"id\"] = temp_df.index\n", " \n", - "# # Generate PointStruct objects using DataFrame apply method\n", - "# points = temp_df.progress_apply(\n", - "# lambda row: PointStruct(\n", - "# id=row[\"id\"],\n", - "# vector=row[\"embeddings\"],\n", - "# payload={\n", - "# \"question\": row[\"question\"],\n", - "# \"title\": row[\"title\"],\n", - "# \"context\": row[\"context\"],\n", - "# \"is_impossible\": row[\"is_impossible\"],\n", - "# \"answers\": row[\"answers\"],\n", - "# },\n", - "# ),\n", - "# axis=1,\n", - "# ).tolist()\n", - "\n", - "# return points\n", - "\n", - "# points = generate_points_from_dataframe(train_df)" + " # Generate PointStruct objects using DataFrame apply method\n", + " points = temp_df.progress_apply(\n", + " lambda row: PointStruct(\n", + " id=row[\"id\"],\n", + " vector=row[\"embeddings\"],\n", + " payload={\n", + " \"question\": row[\"question\"],\n", + " \"title\": row[\"title\"],\n", + " \"context\": row[\"context\"],\n", + " \"is_impossible\": row[\"is_impossible\"],\n", + " \"answers\": row[\"answers\"],\n", + " },\n", + " ),\n", + " axis=1,\n", + " ).tolist()\n", + "\n", + " return points\n", + "\n", + "points = generate_points_from_dataframe(train_df)" ] }, { @@ -1037,14 +1037,14 @@ }, { "cell_type": "code", - "execution_count": 43, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ - "# operation_info = qdrant_client.upsert(\n", - "# collection_name=collection_name, wait=True, points=points\n", - "# )\n", - "# print(operation_info)" + "operation_info = qdrant_client.upsert(\n", + " collection_name=collection_name, wait=True, points=points\n", + ")\n", + "print(operation_info)" ] }, { @@ -1066,7 +1066,7 @@ }, { "cell_type": "code", - "execution_count": 84, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -1154,24 +1154,9 @@ }, { "cell_type": "code", - "execution_count": 85, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "2d5cd9516e6e44a2b4088c444813d631", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - " 0%| | 0/100 [00:00" ] }, - "execution_count": 91, "metadata": {}, - "output_type": "execute_result" + "output_type": "display_data" } ], "source": [ - "evaluate_model(df, \"ft_generated_answer_few_shot\")" + "evaluator = Evaluator(df)\n", + "evaluator.plot_model_comparison([\"generated_answer\", \"ft_generated_answer\", \"ft_generated_answer_few_shot\"], scenario=\"answer_expected\", nice_names=[\"Baseline\", \"Fine-Tuned\", \"Fine-Tuned with Few-Shot\"])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This is quite amazing -- we're able to get the best of both worlds! We're able to get the model to be both correct and conservative: \n", + "\n", + "1. The model is correct 83% of the time -- this is the same as the base model\n", + "2. The model gives the wrong answer only 8% of the time -- down from 17% with the base model" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Next, let's look at the hallucinations. We want to reduce the hallucinations, but not at the cost of correctness. We want to strike a balance between the two. We've struck a good balance here:\n", + "\n", + "1. The model hallucinates 53% of the time -- down from 100% with the base model\n", + "2. The model says \"I don't know\" 47% of the time -- up from NEVER with the base model" ] }, { "cell_type": "code", - "execution_count": 92, + "execution_count": 202, "metadata": {}, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/opt/homebrew/Caskroom/miniconda/base/envs/fst/lib/python3.9/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n", - " if pd.api.types.is_categorical_dtype(vector):\n", - "/opt/homebrew/Caskroom/miniconda/base/envs/fst/lib/python3.9/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n", - " if pd.api.types.is_categorical_dtype(vector):\n", - "/opt/homebrew/Caskroom/miniconda/base/envs/fst/lib/python3.9/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n", - " if pd.api.types.is_categorical_dtype(vector):\n", - "/opt/homebrew/Caskroom/miniconda/base/envs/fst/lib/python3.9/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n", - " if pd.api.types.is_categorical_dtype(vector):\n", - "/opt/homebrew/Caskroom/miniconda/base/envs/fst/lib/python3.9/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n", - " if pd.api.types.is_categorical_dtype(vector):\n", - "/opt/homebrew/Caskroom/miniconda/base/envs/fst/lib/python3.9/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n", - " if pd.api.types.is_categorical_dtype(vector):\n", - "/opt/homebrew/Caskroom/miniconda/base/envs/fst/lib/python3.9/site-packages/seaborn/axisgrid.py:118: UserWarning: The figure layout has changed to tight\n", - " self._figure.tight_layout(*args, **kwargs)\n", - "/opt/homebrew/Caskroom/miniconda/base/envs/fst/lib/python3.9/site-packages/seaborn/utils.py:80: UserWarning: Glyph 9989 (\\N{WHITE HEAVY CHECK MARK}) missing from current font.\n", - " fig.canvas.draw()\n", - "/opt/homebrew/Caskroom/miniconda/base/envs/fst/lib/python3.9/site-packages/seaborn/utils.py:80: UserWarning: Glyph 10062 (\\N{NEGATIVE SQUARED CROSS MARK}) missing from current font.\n", - " fig.canvas.draw()\n", - "/opt/homebrew/Caskroom/miniconda/base/envs/fst/lib/python3.9/site-packages/seaborn/utils.py:80: UserWarning: Glyph 10060 (\\N{CROSS MARK}) missing from current font.\n", - " fig.canvas.draw()\n", - "/opt/homebrew/Caskroom/miniconda/base/envs/fst/lib/python3.9/site-packages/IPython/core/pylabtools.py:152: UserWarning: Glyph 9989 (\\N{WHITE HEAVY CHECK MARK}) missing from current font.\n", - " fig.canvas.print_figure(bytes_io, **kw)\n", - "/opt/homebrew/Caskroom/miniconda/base/envs/fst/lib/python3.9/site-packages/IPython/core/pylabtools.py:152: UserWarning: Glyph 10062 (\\N{NEGATIVE SQUARED CROSS MARK}) missing from current font.\n", - " fig.canvas.print_figure(bytes_io, **kw)\n", - "/opt/homebrew/Caskroom/miniconda/base/envs/fst/lib/python3.9/site-packages/IPython/core/pylabtools.py:152: UserWarning: Glyph 10060 (\\N{CROSS MARK}) missing from current font.\n", - " fig.canvas.print_figure(bytes_io, **kw)\n" - ] - }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -1453,14 +1344,16 @@ } ], "source": [ - "plot_correctness(df, answer_columns=[\"generated_answer\", \"ft_generated_answer\", \"ft_generated_answer_few_shot\"], labels=[\"Base Model\", \"Fine-Tuned Model\", \"Few Shot Fine-Tuned Model with Qdrant\"])" + "evaluator.plot_model_comparison([\"generated_answer\", \"ft_generated_answer\", \"ft_generated_answer_few_shot\"], scenario=\"idk_expected\", nice_names=[\"Baseline\", \"Fine-Tuned\", \"Fine-Tuned with Few-Shot\"])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "### Results\n", + "### Results Breakdown\n", + "\n", + "So far, we've looked at the results for each scenario separately, i.e. each scenario summed to 100. Let's look at the results as an aggregate to get a broader sense of how the model is performing:\n", "\n", "Category | Base | Fine-Tuned | Fine-Tuned with Qdrant |\n", "| --- | --- | --- | --- |\n", @@ -1478,14 +1371,14 @@ "### Observations\n", "\n", "#### Compared to base model\n", - "1. The few shot fine-tuned with Qdrant model is as good as the base model at answering questions where the answer is present in the context. 44% of the questions are answered correctly in both cases.\n", - "2. The few shot fine-tuned with Qdrant model is better at saying \"I don't know\" when the answer is not present in the context. 22% of the questions are answered with \"I don't know\" vs 0% for the base model.\n", - "3. The few shot fine-tuned with Qdrant model is better at reducing hallucinations. 25% of the questions are answered with hallucinations vs 47% for the base model.\n", + "1. The few shot fine-tuned with Qdrant model is as good as the base model at answering questions where the answer is present in the context. \n", + "2. The few shot fine-tuned with Qdrant model is better at saying \"I don't know\" when the answer is not present in the context.\n", + "3. The few shot fine-tuned with Qdrant model is better at reducing hallucinations.\n", "\n", "\n", "#### Compared to fine-tuned model\n", - "1. The few shot fine-tuned with Qdrant model gets more correct answers than the fine-tuned model: **44% of the questions are answered correctly vs 32%** for the fine-tuned model\n", - "2. The few shot fine-tuned with Qdrant model is better at deciding when to say \"I don't know\" when the answer is not present in the context. **22% of the questions are answered with \"I don't know\" vs 40%** for the fine-tuned model.\n", + "1. The few shot fine-tuned with Qdrant model gets more correct answers than the fine-tuned model: **83% of the questions are answered correctly vs 60%** for the fine-tuned model\n", + "2. The few shot fine-tuned with Qdrant model is better at deciding when to say \"I don't know\" when the answer is not present in the context. **34% skip rate for the plain fine-tuning mode, vs 9% for the few shot fine-tuned with Qdrant model**\n", "\n", "Few Shot Fine-Tuning with Qdrant is a great way to control and steer the performance of your RAG system. \n", "\n", From 1fdd15a4de359808c2365a324968ddf4962ee7e1 Mon Sep 17 00:00:00 2001 From: NirantK Date: Tue, 12 Sep 2023 13:10:55 +0530 Subject: [PATCH 35/38] * chore(ft_retrieval_augmented_generation.ipynb): update markdown content * docs(ft_retrieval_augmented_generation.ipynb): add instructions and insights to the results breakdown --- .../ft_retrieval_augmented_generation.ipynb | 22 ++++++++++++------- 1 file changed, 14 insertions(+), 8 deletions(-) diff --git a/examples/fine-tuned_qa/ft_retrieval_augmented_generation.ipynb b/examples/fine-tuned_qa/ft_retrieval_augmented_generation.ipynb index c4fa1269a2..eb9fbdd80a 100644 --- a/examples/fine-tuned_qa/ft_retrieval_augmented_generation.ipynb +++ b/examples/fine-tuned_qa/ft_retrieval_augmented_generation.ipynb @@ -1351,11 +1351,20 @@ "cell_type": "markdown", "metadata": {}, "source": [ + "Few Shot Fine-Tuning with Qdrant is a great way to control and steer the performance of your RAG system. Here, we made the model less conservative compared to zero shot and more confident by using Qdrant to find similar questions. \n", + "\n", + "You can also use Qdrant to make the model more conservative. We did this by giving examples of questions where the answer is not present in the context. \n", + "This is biasing the model to say \"I don't know\" more often. \n", + "\n", + "Similarly, one can also use Qdrant to make the model more confident by giving examples of questions where the answer is present in the context. This biases the model to give an answer more often. The trade-off is that the model will also hallucinate more often.\n", + "\n", + "You can make this trade off by adjusting the training data: distribution of questions and examples, as well as the kind and number of examples you retrieve from Qdrant.\n", + "\n", "### Results Breakdown\n", "\n", "So far, we've looked at the results for each scenario separately, i.e. each scenario summed to 100. Let's look at the results as an aggregate to get a broader sense of how the model is performing:\n", "\n", - "Category | Base | Fine-Tuned | Fine-Tuned with Qdrant |\n", + "| Category | Base | Fine-Tuned | Fine-Tuned with Qdrant |\n", "| --- | --- | --- | --- |\n", "| Correct | 44% | 32% | 44% |\n", "| Skipped | 0% | 18% | 5% |\n", @@ -1380,15 +1389,12 @@ "1. The few shot fine-tuned with Qdrant model gets more correct answers than the fine-tuned model: **83% of the questions are answered correctly vs 60%** for the fine-tuned model\n", "2. The few shot fine-tuned with Qdrant model is better at deciding when to say \"I don't know\" when the answer is not present in the context. **34% skip rate for the plain fine-tuning mode, vs 9% for the few shot fine-tuned with Qdrant model**\n", "\n", - "Few Shot Fine-Tuning with Qdrant is a great way to control and steer the performance of your RAG system. \n", - "\n", - "Here, we made the model less conservative and more confident by using Qdrant to find similar questions. \n", "\n", - "One can also use Qdrant to make the model more conservative. We did this by giving examples of questions where the answer is not present in the context. \n", - "This is biasing the model to say \"I don't know\" more often. \n", + "Now, you should be able to:\n", "\n", - "Similarly, one can also use Qdrant to make the model more confident by giving examples of questions where the answer is present in the context. \n", - "This biases the model to give an answer more often. " + "1. Notice the trade-offs between number of correct answers and hallucinations -- and how training dataset choice influences that!\n", + "2. Fine-tune OpenAI models for specific use-cases and use Qdrant to improve the performance of your RAG model\n", + "3. Get started on how to evaluate the performance of your RAG model" ] } ], From 12f800cd5d7b211a7e04fe57bdd0ca0b4edb49a7 Mon Sep 17 00:00:00 2001 From: NirantK Date: Tue, 12 Sep 2023 13:25:18 +0530 Subject: [PATCH 36/38] * chore(ft_retrieval_augmented_generation.ipynb): reorganize sections and update section numbering * feat(ft_retrieval_augmented_generation.ipynb): add new section for evaluation * fix(ft_retrieval_augmented_generation.ipynb): fix section numbering and update section --- .../ft_retrieval_augmented_generation.ipynb | 35 ++++++++++++------- 1 file changed, 22 insertions(+), 13 deletions(-) diff --git a/examples/fine-tuned_qa/ft_retrieval_augmented_generation.ipynb b/examples/fine-tuned_qa/ft_retrieval_augmented_generation.ipynb index eb9fbdd80a..be80855d58 100644 --- a/examples/fine-tuned_qa/ft_retrieval_augmented_generation.ipynb +++ b/examples/fine-tuned_qa/ft_retrieval_augmented_generation.ipynb @@ -30,9 +30,14 @@ "5. **Evaluation**: How well does the model perform?\n", "\n", "### Section B: Few-Shot Learning\n", - "5. Using Qdrant to Improve RAG Prompt\n", - "6. Fine-Tuning OpenAI Model with Qdrant\n", - "7. Comparison and Results" + "\n", + "6. Using Qdrant to Improve RAG Prompt\n", + "7. Fine-Tuning OpenAI Model with Qdrant\n", + "8. Evaluation\n", + "\n", + "9. **Conclusion**\n", + " - Aggregate Results\n", + " - Observations" ] }, { @@ -868,14 +873,14 @@ "\n", "**What is next?**\n", "\n", - "5. Fine-Tuning OpenAI Model with Qdrant\n", - " 5.1 Embed the Fine-Tuning Data\n", - " 5.2 Embedding the Questions\n", - "6. Using Qdrant to Improve RAG Prompt\n", - "7. Comparison and Results\n", + "6. Fine-Tuning OpenAI Model with Qdrant\n", + " 6.1 Embed the Fine-Tuning Data\n", + " 6.2 Embedding the Questions\n", + "7. Using Qdrant to Improve RAG Prompt\n", + "8. \n", "\n", "\n", - "## 5. Fine-Tuning OpenAI Model with Qdrant\n", + "## 6. Fine-Tuning OpenAI Model with Qdrant\n", "\n", "So far, we've been using the OpenAI model to answer questions without using examples of the answer. The previous step made it work better on in-context examples, while this one helps it generalize to unseen data, and attempt to learn when to say \"I don't know\" and when to give an answer.\n", "\n", @@ -1194,6 +1199,8 @@ "cell_type": "markdown", "metadata": {}, "source": [ + "### 7.2 Fine-Tune the Model\n", + "\n", "⏰ **Time to run: ~15-30 minutes**" ] }, @@ -1279,9 +1286,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Conclusion\n", - "\n", - "In this notebook, we've demonstrated how to fine-tune OpenAI models for specific use-cases. We've also demonstrated how to use Qdrant and Few-Shot Learning to improve the performance of the model.\n", + "## 8. Evaluation\n", "\n", "But how well does the model perform? Let's compare the results from the 3 different models we've looked at so far:" ] @@ -1360,7 +1365,11 @@ "\n", "You can make this trade off by adjusting the training data: distribution of questions and examples, as well as the kind and number of examples you retrieve from Qdrant.\n", "\n", - "### Results Breakdown\n", + "## 9. Conclusion\n", + "\n", + "In this notebook, we've demonstrated how to fine-tune OpenAI models for specific use-cases. We've also demonstrated how to use Qdrant and Few-Shot Learning to improve the performance of the model.\n", + "\n", + "### Aggregate Results\n", "\n", "So far, we've looked at the results for each scenario separately, i.e. each scenario summed to 100. Let's look at the results as an aggregate to get a broader sense of how the model is performing:\n", "\n", From 49a01468a11fee3011efba9218ab9fc28ba9a56e Mon Sep 17 00:00:00 2001 From: NirantK Date: Tue, 12 Sep 2023 13:34:05 +0530 Subject: [PATCH 37/38] * chore(examples): rename ft_retrieval_augmented_generation.ipynb to ft_retrieval_augmented_generation_qdrant.ipynb --- ...ation.ipynb => ft_retrieval_augmented_generation_qdrant.ipynb} | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename examples/fine-tuned_qa/{ft_retrieval_augmented_generation.ipynb => ft_retrieval_augmented_generation_qdrant.ipynb} (100%) diff --git a/examples/fine-tuned_qa/ft_retrieval_augmented_generation.ipynb b/examples/fine-tuned_qa/ft_retrieval_augmented_generation_qdrant.ipynb similarity index 100% rename from examples/fine-tuned_qa/ft_retrieval_augmented_generation.ipynb rename to examples/fine-tuned_qa/ft_retrieval_augmented_generation_qdrant.ipynb From 21fa0d9399b5e52143de30d4e69c26b88ac5dbbe Mon Sep 17 00:00:00 2001 From: NirantK Date: Tue, 12 Sep 2023 13:39:09 +0530 Subject: [PATCH 38/38] * chore(ft_retrieval_augmented_generation_qdrant.ipynb): fix pip install command * feat(ft_retrieval_augmented_generation_qdrant.ipynb): add cell to set OpenAI and Qdrant keys --- ...etrieval_augmented_generation_qdrant.ipynb | 21 ++++++++++++++++++- 1 file changed, 20 insertions(+), 1 deletion(-) diff --git a/examples/fine-tuned_qa/ft_retrieval_augmented_generation_qdrant.ipynb b/examples/fine-tuned_qa/ft_retrieval_augmented_generation_qdrant.ipynb index be80855d58..25b911bc03 100644 --- a/examples/fine-tuned_qa/ft_retrieval_augmented_generation_qdrant.ipynb +++ b/examples/fine-tuned_qa/ft_retrieval_augmented_generation_qdrant.ipynb @@ -78,7 +78,7 @@ "metadata": {}, "outputs": [], "source": [ - "# !pip install pandas openai tqdm tenacity scikit-learn tiktoken python-dotenv seaborn --upgrade --quiet" + "!pip install pandas openai tqdm tenacity scikit-learn tiktoken python-dotenv seaborn --upgrade --quiet" ] }, { @@ -109,6 +109,25 @@ "tqdm.pandas()" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Set your keys\n", + "Get your OpenAI keys [here](https://platform.openai.com/account/api-keys) and Qdrant keys after making a free cluster [here](https://cloud.qdrant.io/login)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "openai.api_key = \"sk-xxx\"\n", + "os.environ[\"QDRANT_URL\"] = \"https://xxx.cloud.qdrant.io:6333\"\n", + "os.environ[\"QDRANT_API_KEY\"] = \"xxx\"" + ] + }, { "attachments": {}, "cell_type": "markdown",