From 0c080d3af1130f1e05cfd1b0d955495fb3d23c0a Mon Sep 17 00:00:00 2001 From: Justin Cechmanek Date: Wed, 29 Jan 2025 17:43:21 -0800 Subject: [PATCH 01/10] adds initial finetuning notebook --- .../finetuning/text_finetuning.ipynb | 582 ++++++++++++++++++ 1 file changed, 582 insertions(+) create mode 100644 python-recipes/finetuning/text_finetuning.ipynb diff --git a/python-recipes/finetuning/text_finetuning.ipynb b/python-recipes/finetuning/text_finetuning.ipynb new file mode 100644 index 00000000..a22dfc1d --- /dev/null +++ b/python-recipes/finetuning/text_finetuning.ipynb @@ -0,0 +1,582 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Fine tuning text embedding models using sentence_transformers\n", + "\n", + "If you're building an LLM application your system will likely include a semantic cache to store previous LLM responses and return those cached answers instead of hitting your LLM again to generate the same answer as before.\n", + "\n", + "Semantic caching improves response time, cost, and user experience, but introduces a new measure of cache performance beyond hit rate - the notions of true and false cache hits.\n", + "\n", + "Because semantic caches are not performing exact key-value cache lookups, but instead doing vector similarity search on text embeddings, we're not guaranteed that every cache hit will be a relevant result, or that every cache miss means our cache doesn't hold the answer we're looking for. This is why using the correct text embedding model is critical.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This notebook uses the [sentence_transformers](https://sbert.net/) library to fine tune a text embedding model on a custom dataset.\n", + "\n", + "The training method used is contrastive fine tuning, where two statements are assigned a label as either being similar {label=1.0} or dissimilar {label=0.0}.\n", + "Training then proceeds to minimize the cosine distance between similar statements, and maximize the cosine distance between dissimilar statements.\n", + "\n", + "This contrastive loss function is well suited to semantic cache applications where we care about the metrics true positive, true negative, false positive, and false negative." + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "zsh:1: no matches found: transformers[torch]\n" + ] + } + ], + "source": [ + "!pip install --quiet torch datasets sentence_transformers transformers[torch] redisvl" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Select our starting model and dataset to fine tune on\n", + "To perform finetuning you'll need a dataset that ideally is specific to your use case. For the type of training we'll be doing - contrastive fine tuning - you'll need to structure your dataset as a set of pairs of questions or statements and coresponding label indicating if they're similar or not.\n", + "\n", + "An example of what this looks like is in `sample_dataset.csv`\n", + "\n", + "| question_1 | question_2 | label |\n", + "|------------|------------|-------|\n", + "| What is AI? | What is artificial intelligence? | 1.0 |\n", + "| How to bake a cake? | How to make a sandwich? | 0.0 |\n", + "| Define machine learning. | Explain machine learning. | 1.0 |" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [], + "source": [ + "# select the datasets to train and test on\n", + "# must be one of 'medical', 'finance', 'gpt', 'quora', 'combined', but you can mix and match\n", + "\n", + "train_data = 'finance'\n", + "test_data = 'finance'" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "outputs": [], + "source": [ + "from datasets import load_dataset\n", + "from sentence_transformers import SentenceTransformer\n", + "from sentence_transformers.losses import ContrastiveLoss\n", + "import copy\n", + "\n", + "# load a model to train/finetune\n", + "model_name = 'sentence-transformers/all-mpnet-base-v2'\n", + "model = SentenceTransformer(model_name)\n", + "\n", + "# make a copy of the weights before training if we want to compare how much they've changed\n", + "before_training = copy.deepcopy(model.state_dict())\n", + "\n", + "# this loss requires pairs of text and a floating point similarity score as a label\n", + "# we'll use 'hard labels' of 1.0 or 0.0 as that is shown to lead to the best separation\n", + "loss = ContrastiveLoss(model)\n", + "\n", + "# Load an example training dataset that works with our loss function:\n", + "train_dataset = load_dataset(\"csv\", data_files=f\"../datasets/processed/{train_data}_train.csv\", split='train')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Define our training arguments" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": {}, + "outputs": [], + "source": [ + "from sentence_transformers.training_args import SentenceTransformerTrainingArguments\n", + "from sentence_transformers.training_args import BatchSamplers\n", + "\n", + "args = SentenceTransformerTrainingArguments(\n", + " # required parameters\n", + " output_dir=f\"models/mpnet-trained_on_{train_data}\",\n", + " # optional training parameters\n", + " num_train_epochs=1,\n", + " per_device_train_batch_size=16,\n", + " per_device_eval_batch_size=16,\n", + " warmup_ratio=0.1,\n", + " fp16=False, # set to False if your GPU can't handle FP16\n", + " bf16=False, # set to True if your GPU supports BF16\n", + " batch_sampler=BatchSamplers.NO_DUPLICATES, # losses using \"in-batch negatives\" benefit from no duplicates\n", + " # optional tracking/debugging parameters\n", + " eval_strategy=\"steps\",\n", + " eval_steps=100,\n", + " save_strategy=\"steps\",\n", + " save_steps=100,\n", + " save_total_limit=2,\n", + " logging_steps=100,\n", + " run_name=f\"mpnet-base-{train_data}\", # used in Weights & Biases if `wandb` is installed\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## choose a dataset to perform training validation on\n", + "While our model is training both the training loss and validation loss will be recorded. These are printed to std_out, and also logged in\n", + "`models/mpnet-base-all/checkpoint-/trainer_state.json`.\n", + "\n", + "sentence_transformers uses the term 'evaluation' rather than 'validation'." + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "train Dataset({\n", + " features: ['question_1', 'question_2', 'label'],\n", + " num_rows: 195\n", + "})\n", + "validation Dataset({\n", + " features: ['question_1', 'question_2', 'label'],\n", + " num_rows: 49\n", + "})\n" + ] + } + ], + "source": [ + "from sentence_transformers.evaluation import EmbeddingSimilarityEvaluator, SimilarityFunction\n", + "from datasets import DatasetDict\n", + "\n", + "# split the dataset into training and validation sets\n", + "train_dataset = train_dataset.train_test_split(train_size=0.8, seed=42)\n", + "\n", + "validation_dataset = train_dataset['test']\n", + "train_dataset = train_dataset['train']\n", + "\n", + "print('train', train_dataset)\n", + "print('validation', validation_dataset)\n", + "\n", + "# initialize the evaluator\n", + "dev_evaluator = EmbeddingSimilarityEvaluator(\n", + " sentences1=validation_dataset[\"question_1\"],\n", + " sentences2=validation_dataset[\"question_2\"],\n", + " scores=validation_dataset[\"label\"],\n", + " main_similarity=SimilarityFunction.COSINE,\n", + " name=f\"{train_data}-dev\",\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Train our model\n", + "This cell performs the full training for the number of epochs defined in our `SentenceTransformerTrainingArguments`, `args`. Losses are periodically printed out." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 13/13 [00:07<00:00, 1.74it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'train_runtime': 7.4775, 'train_samples_per_second': 26.078, 'train_steps_per_second': 1.739, 'train_loss': 0.011066918189709004, 'epoch': 1.0}\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "from sentence_transformers import SentenceTransformerTrainer\n", + "\n", + "trainer = SentenceTransformerTrainer(\n", + " model=model,\n", + " args=args,\n", + " train_dataset=train_dataset,\n", + " eval_dataset=validation_dataset,\n", + " loss=loss,\n", + " evaluator=dev_evaluator,\n", + ")\n", + "trainer.train()\n", + "\n", + "# make a copy of the weights after training\n", + "after_training = copy.deepcopy(model.state_dict())" + ] + }, + { + "cell_type": "code", + "execution_count": 81, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "generating vector embeddings\n", + "computing distances between embeddings\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "\n", + "def evaluate_model(model, test_dataset):\n", + " print('generating vector embeddings')\n", + "\n", + " q1_embeddings = [model.encode(pair['question_1']) for pair in test_dataset]\n", + " q2_embeddings = [model.encode(pair['question_2']) for pair in test_dataset]\n", + " labels = [pair['label'] for pair in test_dataset]\n", + "\n", + " # compute all the distances between all the vectors for quicker reference later\n", + " print('computing distances between embeddings')\n", + " distances = np.empty(shape=(len(q1_embeddings), len(q2_embeddings)), dtype=np.float32, order='C')\n", + " for index_1, embedding_1 in enumerate(q1_embeddings):\n", + " for index_2, embedding_2 in enumerate(q2_embeddings):\n", + " # compute cosine distance between embeddings\n", + " cosine_distance = 1 - np.dot(embedding_1, embedding_2) / (np.linalg.norm(embedding_1) * np.linalg.norm(embedding_2))\n", + " distances[index_1, index_2] = cosine_distance\n", + "\n", + " # for our range of thresholds see which embeddings fall within our threshold and so would be returned from a cache\n", + " metrics = {}\n", + " thresholds = [t/1000 for t in range(30, 500, 30)]\n", + " for threshold in thresholds:\n", + " TP = 0\n", + " FP = 0\n", + " TN = 0\n", + " FN = 0\n", + " for index, label in enumerate(labels):\n", + " # for question N find the most similar embedding, aka the one with the lowest distance\n", + " distance_of_nearest = np.min(distances[index, :])\n", + " index_of_nearest = np.argmin(distances[index, :])\n", + " if distances[index, :][index_of_nearest] <= threshold: # if the distance is below our threshold it's a cache hit\n", + " if label == 1: # check the label to see if it should have been a hit (label == 1) or if there shouldn't be a hit (label == 0)\n", + " if index_of_nearest == index: # verify that we hit the correct matched pair, and not some other question\n", + " TP += 1 # we correctly found a matching cache entry\n", + " else:\n", + " FP += 1 # we hit the cache, but returned a wrong result\n", + " else:\n", + " FP += 1 # we hit the cache, but shouldn't have\n", + " else: # it's a cache miss\n", + " if label == 1: # check it should be a miss\n", + " FN += 1 # we failed to find a matching pair\n", + " else:\n", + " TN += 1 # correctly did not match any other embeddings\n", + "\n", + " accuracy = (TP + TN) / len(test_dataset)\n", + " metrics[threshold] = {\"TP\": TP, \"TN\": TN, \"FP\": FP, \"FN\": FN, \"accuracy\": accuracy}\n", + "\n", + " return metrics\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Evaluate the trained model with our Semantic Cache\n", + "As the ultimate goal of fine tuning is to improve performance for semantic caching we'll run an evaluation with our trained model to simulate a series of cache checks.\n", + "\n", + "Here we can also evaluate on different datasets we haven't trained on. For example, we can train on our healthcare dataset and run evaluations on our finance dataset to if performance improves for topics not in our training scope." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Perform our final comparison on our models " + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "metadata": {}, + "outputs": [], + "source": [ + "# load the test dataset\n", + "test_dataset = load_dataset(\"csv\", data_files=f\"../datasets/processed/{test_data}_test.csv\", split='train')" + ] + }, + { + "cell_type": "code", + "execution_count": 82, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "generating vector embeddings\n", + "computing distances between embeddings\n" + ] + } + ], + "source": [ + "model.load_state_dict(before_training)\n", + "metrics_before_training = evaluate_model(model, test_dataset)" + ] + }, + { + "cell_type": "code", + "execution_count": 83, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "generating vector embeddings\n", + "computing distances between embeddings\n" + ] + } + ], + "source": [ + "model.load_state_dict(after_training)\n", + "metrics_after_training = evaluate_model(model, test_dataset)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Visualize metrics\n", + "Since we're tracking multiple metrics - true and false positives and negatives, accuracy - we want a way to quickly visually compare all of these" + ] + }, + { + "cell_type": "code", + "execution_count": 85, + "metadata": {}, + "outputs": [], + "source": [ + "from matplotlib import pyplot as plt\n", + "\n", + "def display_AUC(metrics_before, metrics_after):\n", + " precision_before = [m['TP'] / (m['TP'] + m['FP']) if (m['TP'] + m['FP']) > 0 else 0 for thresh, m in metrics_before.items()]\n", + " precision_after = [m['TP'] / (m['TP'] + m['FP']) if (m['TP'] + m['FP']) > 0 else 0 for thresh, m in metrics_after.items()]\n", + "\n", + " recall_before = [m['TP'] / (m['TP'] + m['FN']) if (m['TP'] + m['FN']) > 0 else 0 for thresh, m in metrics_before.items()]\n", + " recall_after = [m['TP'] / (m['TP'] + m['FN']) if (m['TP'] + m['FN']) > 0 else 0 for thresh, m in metrics_after.items()]\n", + "\n", + " from sklearn.metrics import roc_auc_score\n", + "\n", + " y_true_before = []\n", + " y_score_before = []\n", + " y_true_after = []\n", + " y_score_after = []\n", + "\n", + " for thresh, m in metrics_before.items():\n", + " y_true_before.extend([1] * m['TP'] + [0] * m['FN'] + [0] * m['TN'] + [1] * m['FP'])\n", + " y_score_before.extend([1] * m['TP'] + [1] * m['FN'] + [0] * m['TN'] + [0] * m['FP'])\n", + "\n", + " for thresh, m in metrics_after.items():\n", + " y_true_after.extend([1] * m['TP'] + [0] * m['FN'] + [0] * m['TN'] + [1] * m['FP'])\n", + " y_score_after.extend([1] * m['TP'] + [1] * m['FN'] + [0] * m['TN'] + [0] * m['FP'])\n", + "\n", + " auc_before = roc_auc_score(y_true_before, y_score_before)\n", + " auc_after = roc_auc_score(y_true_after, y_score_after)\n", + "\n", + " plt.figure()\n", + " plt.plot(recall_before, precision_before, scalex=False, scaley=False)\n", + " plt.plot(recall_after, precision_after, scalex=False, scaley=False)\n", + " plt.title(f'trained on {train_data}, test on {test_data}\\n Precision Recall curves with finetuning')\n", + " plt.xlabel('Recall')\n", + " plt.ylabel('Precision')\n", + " plt.legend([f'before finetuning auc={auc_before :.4f}', f'after finetuning auc={auc_after :.4f}'])\n", + " plt.show()\n", + "\n", + "\n", + "def display_accuracy(metrics_before, metrics_after):\n", + " accuracy_before = [m['accuracy'] for thresh, m in metrics_before.items()]\n", + " accuracy_after = [m['accuracy'] for thresh, m in metrics_after.items()]\n", + " plt.figure()\n", + " plt.plot(list(metrics_before.keys()), accuracy_before)\n", + " plt.plot(list(metrics_after.keys()), accuracy_after)\n", + " plt.title(f'trained on {train_data}, test on {test_data}\\n Accuracy with training')\n", + " plt.xlabel('Threshold')\n", + " plt.ylabel('Accuracy')\n", + " plt.legend(['before finetuning', 'after finetuning'])\n", + " plt.show()\n", + "\n", + "\n", + "def display_f1_score(metrics_before, metrics_after):\n", + " f1_before = [2 * (m['TP'] / (m['TP'] + m['FP']) * m['TP'] / (m['TP'] + m['FN'])) / (m['TP'] / (m['TP'] + m['FP']) + m['TP'] / (m['TP'] + m['FN'])) if (m['TP'] + m['FP']) > 0 and (m['TP'] + m['FN']) > 0 else 0 for thresh, m in metrics_before.items()]\n", + " f1_after = [2 * (m['TP'] / (m['TP'] + m['FP']) * m['TP'] / (m['TP'] + m['FN'])) / (m['TP'] / (m['TP'] + m['FP']) + m['TP'] / (m['TP'] + m['FN'])) if (m['TP'] + m['FP']) > 0 and (m['TP'] + m['FN']) > 0 else 0 for thresh, m in metrics_after.items()]\n", + "\n", + " plt.figure()\n", + " plt.plot(list(metrics_before.keys()), f1_before)\n", + " plt.plot(list(metrics_after.keys()), f1_after)\n", + " plt.title(f'trained on {train_data}, test on {test_data}\\n F1 Score with training')\n", + " plt.xlabel('Threshold')\n", + " plt.ylabel('F1 Score')\n", + " plt.legend(['before finetuning', 'after finetuning'])\n", + " plt.show()\n", + "\n", + "\n", + "def display_metrics(metrics_before, metrics_after):\n", + " # TODO normalize TP, TN, etc. by dividing by dataset size\n", + " colors = ['b','g','r','m']\n", + " plt.figure()\n", + " for val in zip(['TP', 'TN'], colors[:2]):\n", + " plt.plot(list(metrics_before.keys()), [m[val[0]] for thresh, m in metrics_before.items()], color=val[1])\n", + " for val in zip(['TP', 'TN'], colors[:2]):\n", + " plt.plot(list(metrics_after.keys()), [m[val[0]] for thresh, m in metrics_after.items()], marker='.', color=val[1])\n", + "\n", + " plt.title(f'trained on {train_data}, test on {test_data}\\n True Positives and Negatives -- higher is better')\n", + " plt.xlabel('threshold')\n", + " plt.ylabel('successes')\n", + " plt.legend(['TP before', 'TN before', 'TP after', 'TN after'])\n", + "\n", + " plt.figure()\n", + " for val in zip(['FP', 'FN'], colors[2:]):\n", + " plt.plot(list(metrics_before.keys()), [m[val[0]] for thresh, m in metrics_before.items()], color=val[1])\n", + " for val in zip(['TP', 'TN'], colors[2:]):\n", + " plt.plot(list(metrics_after.keys()), [m[val[0]] for thresh, m in metrics_after.items()], marker='.', color=val[1])\n", + "\n", + " plt.title(f'trained on {train_data}, test on {test_data}\\n False Positives and Negatives -- lower is better')\n", + " plt.xlabel('threshold')\n", + " plt.ylabel('errors')\n", + " plt.legend(['FP before', 'FN before', 'FP after', 'FN after'])\n", + " plt.figure()\n", + "\n", + " plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 86, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "display_AUC(metrics_before_training, metrics_after_training)\n", + "display_accuracy(metrics_before_training, metrics_after_training)\n", + "display_metrics(metrics_before_training, metrics_after_training)\n", + "display_f1_score(metrics_before_training, metrics_after_training)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "finetune", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.2" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} From 1523be60d1fed3ed2df9be108166f7e4e1df74bb Mon Sep 17 00:00:00 2001 From: Justin Cechmanek Date: Thu, 30 Jan 2025 16:47:37 -0800 Subject: [PATCH 02/10] adds finetuning notebook and sample datasets --- .../finetuning/00_text_finetuning.ipynb | 577 +++++++++++++++++ .../finetuning/datasets/sample_dataset.csv | 53 ++ .../finetuning/datasets/sample_testset.csv | 21 + .../finetuning/text_finetuning.ipynb | 582 ------------------ 4 files changed, 651 insertions(+), 582 deletions(-) create mode 100644 python-recipes/finetuning/00_text_finetuning.ipynb create mode 100644 python-recipes/finetuning/datasets/sample_dataset.csv create mode 100644 python-recipes/finetuning/datasets/sample_testset.csv delete mode 100644 python-recipes/finetuning/text_finetuning.ipynb diff --git a/python-recipes/finetuning/00_text_finetuning.ipynb b/python-recipes/finetuning/00_text_finetuning.ipynb new file mode 100644 index 00000000..b51d4d33 --- /dev/null +++ b/python-recipes/finetuning/00_text_finetuning.ipynb @@ -0,0 +1,577 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Fine tuning text embedding models using sentence_transformers\n", + "\n", + "If you're building an LLM application your system will likely include a semantic cache to store previous LLM responses and return those cached answers instead of hitting your LLM again to generate the same answer as before.\n", + "\n", + "Semantic caching improves response time, cost, and user experience, but introduces a new measure of cache performance beyond hit rate - the notions of true and false cache hits.\n", + "\n", + "Because semantic caches are not performing exact key-value cache lookups, but instead doing vector similarity search on text embeddings, we're not guaranteed that every cache hit will be a relevant result, or that every cache miss means our cache doesn't hold the answer we're looking for. This is why using the correct text embedding model is critical. Using a text embedding model specifically fine tuned to correctly match queries for your system can improve your overall cache performance." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This notebook uses the [sentence_transformers](https://sbert.net/) library to fine tune a text embedding model on a custom dataset.\n", + "The training method used is contrastive fine tuning, where two statements are assigned a label as either being similar {label=1.0} or dissimilar {label=0.0}.\n", + "Training then proceeds to minimize the cosine distance between similar statements, and maximize the cosine distance between dissimilar statements.\n", + "\n", + "This contrastive loss function is well suited to semantic cache applications where we care about the metrics true positive, true negative, false positive, and false negative.\n", + "\n", + "## Let's Begin!\n", + "\"Open" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m A new release of pip is available: \u001b[0m\u001b[31;49m24.2\u001b[0m\u001b[39;49m -> \u001b[0m\u001b[32;49m25.0\u001b[0m\n", + "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m To update, run: \u001b[0m\u001b[32;49mpip install --upgrade pip\u001b[0m\n" + ] + } + ], + "source": [ + "!pip install --quiet torch datasets sentence_transformers 'transformers[torch]' redisvl" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Select our starting model and dataset to fine tune on\n", + "To perform finetuning you'll need a dataset that ideally is specific to your use case. For the type of training we'll be doing - contrastive fine tuning - you'll need to structure your dataset as a set of pairs of questions or statements and coresponding label indicating if they're similar or not.\n", + "\n", + "An example of what this looks like is in `sample_dataset.csv`\n", + "\n", + "| question_1 | question_2 | label |\n", + "|------------|------------|-------|\n", + "| What is AI? | What is artificial intelligence? | 1.0 |\n", + "| How to bake a cake? | How to make a sandwich? | 0.0 |\n", + "| Define machine learning. | Explain machine learning. | 1.0 |" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [], + "source": [ + "# select the datasets to train and test on\n", + "# we've provided examples in the datasets directory of what these files should look like\n", + "train_data = 'sample_dataset.csv'\n", + "test_data = 'sample_testset.csv'" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [], + "source": [ + "from datasets import load_dataset\n", + "from sentence_transformers import SentenceTransformer\n", + "from sentence_transformers.losses import ContrastiveLoss\n", + "import copy\n", + "\n", + "# load a model to train/finetune\n", + "model_name = 'sentence-transformers/all-mpnet-base-v2'\n", + "model = SentenceTransformer(model_name)\n", + "\n", + "# make a copy of the weights before training if we want to compare how much they've changed\n", + "before_training = copy.deepcopy(model.state_dict())\n", + "\n", + "# this loss requires pairs of text and a floating point similarity score as a label\n", + "# we'll use 'hard labels' of 1.0 or 0.0 as that is shown to lead to the best separation\n", + "loss = ContrastiveLoss(model)\n", + "\n", + "# load an example training dataset that works with our loss function:\n", + "train_dataset = load_dataset(\"csv\", data_files=f\"datasets/{train_data}\", split='train')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Define our training arguments" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [], + "source": [ + "from sentence_transformers.training_args import SentenceTransformerTrainingArguments\n", + "from sentence_transformers.training_args import BatchSamplers\n", + "\n", + "args = SentenceTransformerTrainingArguments(\n", + " # required parameters\n", + " output_dir=f\"models/mpnet-trained_on_{train_data}\",\n", + " # optional training parameters\n", + " num_train_epochs=1,\n", + " per_device_train_batch_size=16,\n", + " per_device_eval_batch_size=16,\n", + " warmup_ratio=0.1,\n", + " fp16=False, # set to False if your GPU can't handle FP16\n", + " bf16=False, # set to True if your GPU supports BF16\n", + " batch_sampler=BatchSamplers.NO_DUPLICATES, # losses using \"in-batch negatives\" benefit from no duplicates\n", + " # optional tracking/debugging parameters\n", + " eval_strategy=\"steps\",\n", + " eval_steps=100,\n", + " save_strategy=\"steps\",\n", + " save_steps=100,\n", + " save_total_limit=2,\n", + " logging_steps=100,\n", + " run_name=f\"mpnet-base-{train_data}\", # used in Weights & Biases if `wandb` is installed\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Split your dataset to perform training validation\n", + "While our model is training both the training loss and validation loss will be recorded. These are printed to `stdout`, and also logged in\n", + "`models/mpnet-base-all/checkpoint-/trainer_state.json`.\n", + "\n", + "sentence_transformers uses the term 'evaluation' rather than 'validation'." + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "train Dataset({\n", + " features: ['question_1', 'question_2', 'label'],\n", + " num_rows: 41\n", + "})\n", + "validation Dataset({\n", + " features: ['question_1', 'question_2', 'label'],\n", + " num_rows: 11\n", + "})\n" + ] + } + ], + "source": [ + "from sentence_transformers.evaluation import EmbeddingSimilarityEvaluator, SimilarityFunction\n", + "\n", + "# split the dataset into training and validation sets\n", + "train_dataset = train_dataset.train_test_split(train_size=0.8, seed=42)\n", + "\n", + "validation_dataset = train_dataset['test']\n", + "train_dataset = train_dataset['train']\n", + "\n", + "print('train', train_dataset)\n", + "print('validation', validation_dataset)\n", + "\n", + "# initialize the evaluator\n", + "dev_evaluator = EmbeddingSimilarityEvaluator(\n", + " sentences1=validation_dataset[\"question_1\"],\n", + " sentences2=validation_dataset[\"question_2\"],\n", + " scores=validation_dataset[\"label\"],\n", + " main_similarity=SimilarityFunction.COSINE,\n", + " name=f\"{train_data}-dev\",\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Train our model\n", + "This cell performs the full training for the number of epochs defined in our `SentenceTransformerTrainingArguments`, args. Losses are periodically printed out." + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "40387058dc3447eaa151b8ed05ad0df0", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/3 [00:00 0 else 1 for m in metrics_before.values()]\n", + " precision_after = [m['TP'] / (m['TP'] + m['FP']) if (m['TP'] + m['FP']) > 0 else 1 for m in metrics_after.values()]\n", + "\n", + " recall_before = [m['TP'] / (m['TP'] + m['FN']) if (m['TP'] + m['FN']) > 0 else 1 for m in metrics_before.values()]\n", + " recall_after = [m['TP'] / (m['TP'] + m['FN']) if (m['TP'] + m['FN']) > 0 else 1 for m in metrics_after.values()]\n", + "\n", + " from sklearn.metrics import roc_auc_score\n", + " y_true_before = []\n", + " y_score_before = []\n", + " y_true_after = []\n", + " y_score_after = []\n", + "\n", + " for m in metrics_before.values():\n", + " y_true_before.extend([1] * m['TP'] + [0] * m['FN'] + [0] * m['TN'] + [1] * m['FP'])\n", + " y_score_before.extend([1] * m['TP'] + [1] * m['FN'] + [0] * m['TN'] + [0] * m['FP'])\n", + "\n", + " for m in metrics_after.values():\n", + " y_true_after.extend([1] * m['TP'] + [0] * m['FN'] + [0] * m['TN'] + [1] * m['FP'])\n", + " y_score_after.extend([1] * m['TP'] + [1] * m['FN'] + [0] * m['TN'] + [0] * m['FP'])\n", + "\n", + " auc_before = roc_auc_score(y_true_before, y_score_before)\n", + " auc_after = roc_auc_score(y_true_after, y_score_after)\n", + "\n", + " plt.figure()\n", + " plt.plot(recall_before, precision_before, scalex=False, scaley=False)\n", + " plt.plot(recall_after, precision_after, scalex=False, scaley=False)\n", + " plt.title(f'trained on {train_data}, test on {test_data}\\n Precision Recall curves with finetuning')\n", + " plt.xlabel('Recall')\n", + " plt.ylabel('Precision')\n", + " plt.ylim([0,1.1])\n", + " plt.legend([f'before finetuning auc={auc_before :.4f}', f'after finetuning auc={auc_after :.4f}'])\n", + " plt.show()\n", + "\n", + "\n", + "def display_accuracy(metrics_before, metrics_after):\n", + " accuracy_before = [m['accuracy'] for m in metrics_before.values()]\n", + " accuracy_after = [m['accuracy'] for m in metrics_after.values()]\n", + " plt.figure()\n", + " plt.plot(list(metrics_before.keys()), accuracy_before)\n", + " plt.plot(list(metrics_after.keys()), accuracy_after)\n", + " plt.title(f'trained on {train_data}, test on {test_data}\\n Accuracy')\n", + " plt.xlabel('Threshold')\n", + " plt.ylabel('Accuracy')\n", + " plt.ylim([0,1.1])\n", + " plt.legend(['before finetuning', 'after finetuning'])\n", + " plt.show()\n", + "\n", + "\n", + "def display_f1_score(metrics_before, metrics_after):\n", + " F1_before = [m[\"F1\"] for m in metrics_before.values()]\n", + " F1_after = [m[\"F1\"] for m in metrics_after.values()]\n", + "\n", + " plt.figure()\n", + " plt.plot(list(metrics_before.keys()), F1_before)\n", + " plt.plot(list(metrics_after.keys()), F1_after)\n", + " plt.title(f'trained on {train_data}, test on {test_data}\\n F1 Score')\n", + " plt.xlabel('Threshold')\n", + " plt.ylabel('F1 Score')\n", + " plt.legend(['before finetuning', 'after finetuning'])\n", + " plt.show()\n", + "\n", + "\n", + "def display_metrics(metrics_before, metrics_after):\n", + " colors = ['b','g','r','m']\n", + " plt.figure()\n", + " for val in zip(['TP', 'TN'], colors[:2]):\n", + " plt.plot(list(metrics_before.keys()), [m[val[0]] for m in metrics_before.values()], color=val[1])\n", + " for val in zip(['TP', 'TN'], colors[:2]):\n", + " plt.plot(list(metrics_after.keys()), [m[val[0]] for m in metrics_after.values()], marker='.', color=val[1])\n", + "\n", + " plt.title(f'trained on {train_data}, test on {test_data}\\n True Positives and Negatives -- higher is better')\n", + " plt.xlabel('threshold')\n", + " plt.ylabel('successes')\n", + " plt.legend(['TP before', 'TN before', 'TP after', 'TN after'])\n", + "\n", + " plt.figure()\n", + " for val in zip(['FP', 'FN'], colors[2:]):\n", + " plt.plot(list(metrics_before.keys()), [m[val[0]] for m in metrics_before.values()], color=val[1])\n", + " for val in zip(['FP', 'FN'], colors[2:]):\n", + " plt.plot(list(metrics_after.keys()), [m[val[0]] for m in metrics_after.values()], marker='.', color=val[1])\n", + "\n", + " plt.title(f'trained on {train_data}, test on {test_data}\\n False Positives and Negatives -- lower is better')\n", + " plt.xlabel('threshold')\n", + " plt.ylabel('errors')\n", + " plt.legend(['FP before', 'FN before', 'FP after', 'FN after'])\n", + " plt.figure()\n", + "\n", + " plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "display_AUC(metrics_before_training, metrics_after_training)\n", + "display_accuracy(metrics_before_training, metrics_after_training)\n", + "display_metrics(metrics_before_training, metrics_after_training)\n", + "display_f1_score(metrics_before_training, metrics_after_training)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Every use case is different\n", + "With semantic caching we always have to keep in mind there is a tradeoff between cache utilization, which improves response times and cuts LLM costs, and the risk of incorrect cache responses. You can control this tradeoff by selecting the cache similarity threshold that makes sense for your system.\n", + "\n", + "If you want to drive down LLM calls and the occasional incorrect response from a cache hit is acceptable, then set a high threshold and return cached entries often.\n", + "\n", + "Or if a false positive cache hit that results in a poor response to your users is something you want to minimize, then choose a small threshold and be confident that only highly similar results will be coming from your cache.\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "redis-ai-res", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.9" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/python-recipes/finetuning/datasets/sample_dataset.csv b/python-recipes/finetuning/datasets/sample_dataset.csv new file mode 100644 index 00000000..cfba8602 --- /dev/null +++ b/python-recipes/finetuning/datasets/sample_dataset.csv @@ -0,0 +1,53 @@ +question_1,question_2,label +What is AI?,What is artificial itelligence?,1.0 +How to bake a cake?,How to make a sandwich?,0.0 +Define machine learning.,Explain machine learning.,1.0 +What is deep learning?,What is AI?,0.0 +How does a car engine work?,Explain the working of a car engine.,1.0 +What are the benefits of exercise?,Why is physical activity important?,1.0 +Where can I buy a laptop?,How do I fix a broken laptop?,0.0 +Describe the process of photosynthesis.,What is photosynthesis?,1.0 +What is the capital of Japan?,How tall is Mount Everest?,0.0 +How do I learn Python?,Where can I find Python tutorials?,1.0 +Who wrote Hamlet?,Who is the author of Romeo and Juliet?,1.0 +What is the boiling point of water?,How much does a liter of water weigh?,0.0 +When was the United States founded?,Who was the first president of the United States?,0.0 +What is quantum computing?,Explain quantum computing.,1.0 +How do airplanes fly?,What are the principles of flight?,1.0 +Where can I find a good restaurant?,How do I cook pasta?,0.0 +What is the Pythagorean theorem?,Who discovered the Pythagorean theorem?,0.0 +What are the symptoms of COVID-19?,How do I know if I have COVID-19?,1.0 +What is the speed of light?,How fast does light travel?,1.0 +Why is the sky blue?,Why do leaves change color in autumn?,0.0 +How do I change a flat tire?,What should I do if my car breaks down?,0.0 +What are the causes of climate change?,How does global warming affect the environment?,1.0 +Who painted the Mona Lisa?,What is the most famous painting by Leonardo da Vinci?,1.0 +How do I improve my writing skills?,What are some tips for becoming a better writer?,1.0 +What is the population of Canada?,What is the capital of Canada?,0.0 +When did World War II end?,What were the causes of World War II?,0.0 +How does a microwave oven work?,What is the function of a microwave oven?,1.0 +What is the difference between a virus and bacteria?,How are viruses and bacteria different?,1.0 +What is the tallest mountain in the world?,Where is Mount Everest located?,0.0 +How do I lose weight?,What are some effective weight loss strategies?,1.0 +Who discovered gravity?,What did Isaac Newton discover?,1.0 +What is the formula for the area of a circle?,How do you calculate the area of a circle?,1.0 +How does a refrigerator work?,What is the function of a refrigerator?,1.0 +What are the benefits of drinking water?,Why is hydration important?,1.0 +How do I start investing in stocks?,What are the basics of stock market investing?,1.0 +Who wrote the Harry Potter books?,Who is J.K. Rowling?,0.0 +What is the capital of Germany?,What is the largest city in Germany?,0.0 +Why do birds migrate?,What are the reasons for bird migration?,1.0 +What is the atomic number of carbon?,How many protons does carbon have?,1.0 +How do I delete my Facebook account?,How do I create a Facebook account?,0.0 +What is the function of the liver?,How does the liver help the body?,1.0 +Where is the Great Wall of China located?,How long is the Great Wall of China?,0.0 +What causes earthquakes?,Why do tectonic plates move?,1.0 +What is the main ingredient in bread?,How is bread made?,0.0 +How do I calculate my BMI?,What is the formula for Body Mass Index?,1.0 +What are renewable energy sources?,How does solar power work?,0.0 +What is the boiling point of water in Celsius?,At what temperature does water boil?,1.0 +What are the symptoms of the flu?,How do I know if I have a cold or the flu?,1.0 +Who was the first human in space?,Who was Yuri Gagarin?,0.0 +Why is the ocean salty?,What causes ocean water to be salty?,1.0 +How do I tie a tie?,What are the steps to tying a Windsor knot?,1.0 +Where can I buy a used car?,How do I negotiate the price of a car?,0.0 diff --git a/python-recipes/finetuning/datasets/sample_testset.csv b/python-recipes/finetuning/datasets/sample_testset.csv new file mode 100644 index 00000000..e37cbce2 --- /dev/null +++ b/python-recipes/finetuning/datasets/sample_testset.csv @@ -0,0 +1,21 @@ +question_1,question_2,label +What is photosynthesis?,How do plants make their own food?,1.0 +Who invented the telephone?,Who was Alexander Graham Bell?,0.0 +What are the seven continents?,How many continents are there?,1.0 +How do I learn to play guitar?,What are some beginner tips for learning guitar?,1.0 +What is the capital of Italy?,Where is Rome located?,0.0 +How do I cook rice?,What is the best way to cook rice?,1.0 +What is the formula for force in physics?,How do you calculate force?,1.0 +What are the primary colors?,What colors make up the primary colors?,1.0 +Where is the Amazon Rainforest located?,How big is the Amazon Rainforest?,0.0 +What is a black hole?,How does a black hole form?,1.0 +How do I improve my public speaking skills?,What are some tips for public speaking?,1.0 +What is the meaning of life?,Why are we here?,1.0 +Who wrote The Great Gatsby?,What books did F. Scott Fitzgerald write?,0.0 +How does an electric car work?,What makes electric cars different from gas-powered cars?,1.0 +What is the freezing point of water?,At what temperature does water freeze?,1.0 +How do I change my email password?,How do I reset my email password?,1.0 +What are the benefits of yoga?,Why is yoga good for you?,1.0 +How do I create a budget?,What are some tips for managing personal finances?,1.0 +What is the difference between a crocodile and an alligator?,How are crocodiles and alligators different?,1.0 +What are the ingredients in a chocolate cake?,How do you bake a chocolate cake?,0.0 diff --git a/python-recipes/finetuning/text_finetuning.ipynb b/python-recipes/finetuning/text_finetuning.ipynb deleted file mode 100644 index a22dfc1d..00000000 --- a/python-recipes/finetuning/text_finetuning.ipynb +++ /dev/null @@ -1,582 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Fine tuning text embedding models using sentence_transformers\n", - "\n", - "If you're building an LLM application your system will likely include a semantic cache to store previous LLM responses and return those cached answers instead of hitting your LLM again to generate the same answer as before.\n", - "\n", - "Semantic caching improves response time, cost, and user experience, but introduces a new measure of cache performance beyond hit rate - the notions of true and false cache hits.\n", - "\n", - "Because semantic caches are not performing exact key-value cache lookups, but instead doing vector similarity search on text embeddings, we're not guaranteed that every cache hit will be a relevant result, or that every cache miss means our cache doesn't hold the answer we're looking for. This is why using the correct text embedding model is critical.\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "This notebook uses the [sentence_transformers](https://sbert.net/) library to fine tune a text embedding model on a custom dataset.\n", - "\n", - "The training method used is contrastive fine tuning, where two statements are assigned a label as either being similar {label=1.0} or dissimilar {label=0.0}.\n", - "Training then proceeds to minimize the cosine distance between similar statements, and maximize the cosine distance between dissimilar statements.\n", - "\n", - "This contrastive loss function is well suited to semantic cache applications where we care about the metrics true positive, true negative, false positive, and false negative." - ] - }, - { - "cell_type": "code", - "execution_count": 39, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "zsh:1: no matches found: transformers[torch]\n" - ] - } - ], - "source": [ - "!pip install --quiet torch datasets sentence_transformers transformers[torch] redisvl" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Select our starting model and dataset to fine tune on\n", - "To perform finetuning you'll need a dataset that ideally is specific to your use case. For the type of training we'll be doing - contrastive fine tuning - you'll need to structure your dataset as a set of pairs of questions or statements and coresponding label indicating if they're similar or not.\n", - "\n", - "An example of what this looks like is in `sample_dataset.csv`\n", - "\n", - "| question_1 | question_2 | label |\n", - "|------------|------------|-------|\n", - "| What is AI? | What is artificial intelligence? | 1.0 |\n", - "| How to bake a cake? | How to make a sandwich? | 0.0 |\n", - "| Define machine learning. | Explain machine learning. | 1.0 |" - ] - }, - { - "cell_type": "code", - "execution_count": 40, - "metadata": {}, - "outputs": [], - "source": [ - "# select the datasets to train and test on\n", - "# must be one of 'medical', 'finance', 'gpt', 'quora', 'combined', but you can mix and match\n", - "\n", - "train_data = 'finance'\n", - "test_data = 'finance'" - ] - }, - { - "cell_type": "code", - "execution_count": 41, - "metadata": {}, - "outputs": [], - "source": [ - "from datasets import load_dataset\n", - "from sentence_transformers import SentenceTransformer\n", - "from sentence_transformers.losses import ContrastiveLoss\n", - "import copy\n", - "\n", - "# load a model to train/finetune\n", - "model_name = 'sentence-transformers/all-mpnet-base-v2'\n", - "model = SentenceTransformer(model_name)\n", - "\n", - "# make a copy of the weights before training if we want to compare how much they've changed\n", - "before_training = copy.deepcopy(model.state_dict())\n", - "\n", - "# this loss requires pairs of text and a floating point similarity score as a label\n", - "# we'll use 'hard labels' of 1.0 or 0.0 as that is shown to lead to the best separation\n", - "loss = ContrastiveLoss(model)\n", - "\n", - "# Load an example training dataset that works with our loss function:\n", - "train_dataset = load_dataset(\"csv\", data_files=f\"../datasets/processed/{train_data}_train.csv\", split='train')" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Define our training arguments" - ] - }, - { - "cell_type": "code", - "execution_count": 42, - "metadata": {}, - "outputs": [], - "source": [ - "from sentence_transformers.training_args import SentenceTransformerTrainingArguments\n", - "from sentence_transformers.training_args import BatchSamplers\n", - "\n", - "args = SentenceTransformerTrainingArguments(\n", - " # required parameters\n", - " output_dir=f\"models/mpnet-trained_on_{train_data}\",\n", - " # optional training parameters\n", - " num_train_epochs=1,\n", - " per_device_train_batch_size=16,\n", - " per_device_eval_batch_size=16,\n", - " warmup_ratio=0.1,\n", - " fp16=False, # set to False if your GPU can't handle FP16\n", - " bf16=False, # set to True if your GPU supports BF16\n", - " batch_sampler=BatchSamplers.NO_DUPLICATES, # losses using \"in-batch negatives\" benefit from no duplicates\n", - " # optional tracking/debugging parameters\n", - " eval_strategy=\"steps\",\n", - " eval_steps=100,\n", - " save_strategy=\"steps\",\n", - " save_steps=100,\n", - " save_total_limit=2,\n", - " logging_steps=100,\n", - " run_name=f\"mpnet-base-{train_data}\", # used in Weights & Biases if `wandb` is installed\n", - ")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## choose a dataset to perform training validation on\n", - "While our model is training both the training loss and validation loss will be recorded. These are printed to std_out, and also logged in\n", - "`models/mpnet-base-all/checkpoint-/trainer_state.json`.\n", - "\n", - "sentence_transformers uses the term 'evaluation' rather than 'validation'." - ] - }, - { - "cell_type": "code", - "execution_count": 43, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "train Dataset({\n", - " features: ['question_1', 'question_2', 'label'],\n", - " num_rows: 195\n", - "})\n", - "validation Dataset({\n", - " features: ['question_1', 'question_2', 'label'],\n", - " num_rows: 49\n", - "})\n" - ] - } - ], - "source": [ - "from sentence_transformers.evaluation import EmbeddingSimilarityEvaluator, SimilarityFunction\n", - "from datasets import DatasetDict\n", - "\n", - "# split the dataset into training and validation sets\n", - "train_dataset = train_dataset.train_test_split(train_size=0.8, seed=42)\n", - "\n", - "validation_dataset = train_dataset['test']\n", - "train_dataset = train_dataset['train']\n", - "\n", - "print('train', train_dataset)\n", - "print('validation', validation_dataset)\n", - "\n", - "# initialize the evaluator\n", - "dev_evaluator = EmbeddingSimilarityEvaluator(\n", - " sentences1=validation_dataset[\"question_1\"],\n", - " sentences2=validation_dataset[\"question_2\"],\n", - " scores=validation_dataset[\"label\"],\n", - " main_similarity=SimilarityFunction.COSINE,\n", - " name=f\"{train_data}-dev\",\n", - ")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Train our model\n", - "This cell performs the full training for the number of epochs defined in our `SentenceTransformerTrainingArguments`, `args`. Losses are periodically printed out." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 13/13 [00:07<00:00, 1.74it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'train_runtime': 7.4775, 'train_samples_per_second': 26.078, 'train_steps_per_second': 1.739, 'train_loss': 0.011066918189709004, 'epoch': 1.0}\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n" - ] - } - ], - "source": [ - "from sentence_transformers import SentenceTransformerTrainer\n", - "\n", - "trainer = SentenceTransformerTrainer(\n", - " model=model,\n", - " args=args,\n", - " train_dataset=train_dataset,\n", - " eval_dataset=validation_dataset,\n", - " loss=loss,\n", - " evaluator=dev_evaluator,\n", - ")\n", - "trainer.train()\n", - "\n", - "# make a copy of the weights after training\n", - "after_training = copy.deepcopy(model.state_dict())" - ] - }, - { - "cell_type": "code", - "execution_count": 81, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "generating vector embeddings\n", - "computing distances between embeddings\n" - ] - } - ], - "source": [ - "import numpy as np\n", - "\n", - "def evaluate_model(model, test_dataset):\n", - " print('generating vector embeddings')\n", - "\n", - " q1_embeddings = [model.encode(pair['question_1']) for pair in test_dataset]\n", - " q2_embeddings = [model.encode(pair['question_2']) for pair in test_dataset]\n", - " labels = [pair['label'] for pair in test_dataset]\n", - "\n", - " # compute all the distances between all the vectors for quicker reference later\n", - " print('computing distances between embeddings')\n", - " distances = np.empty(shape=(len(q1_embeddings), len(q2_embeddings)), dtype=np.float32, order='C')\n", - " for index_1, embedding_1 in enumerate(q1_embeddings):\n", - " for index_2, embedding_2 in enumerate(q2_embeddings):\n", - " # compute cosine distance between embeddings\n", - " cosine_distance = 1 - np.dot(embedding_1, embedding_2) / (np.linalg.norm(embedding_1) * np.linalg.norm(embedding_2))\n", - " distances[index_1, index_2] = cosine_distance\n", - "\n", - " # for our range of thresholds see which embeddings fall within our threshold and so would be returned from a cache\n", - " metrics = {}\n", - " thresholds = [t/1000 for t in range(30, 500, 30)]\n", - " for threshold in thresholds:\n", - " TP = 0\n", - " FP = 0\n", - " TN = 0\n", - " FN = 0\n", - " for index, label in enumerate(labels):\n", - " # for question N find the most similar embedding, aka the one with the lowest distance\n", - " distance_of_nearest = np.min(distances[index, :])\n", - " index_of_nearest = np.argmin(distances[index, :])\n", - " if distances[index, :][index_of_nearest] <= threshold: # if the distance is below our threshold it's a cache hit\n", - " if label == 1: # check the label to see if it should have been a hit (label == 1) or if there shouldn't be a hit (label == 0)\n", - " if index_of_nearest == index: # verify that we hit the correct matched pair, and not some other question\n", - " TP += 1 # we correctly found a matching cache entry\n", - " else:\n", - " FP += 1 # we hit the cache, but returned a wrong result\n", - " else:\n", - " FP += 1 # we hit the cache, but shouldn't have\n", - " else: # it's a cache miss\n", - " if label == 1: # check it should be a miss\n", - " FN += 1 # we failed to find a matching pair\n", - " else:\n", - " TN += 1 # correctly did not match any other embeddings\n", - "\n", - " accuracy = (TP + TN) / len(test_dataset)\n", - " metrics[threshold] = {\"TP\": TP, \"TN\": TN, \"FP\": FP, \"FN\": FN, \"accuracy\": accuracy}\n", - "\n", - " return metrics\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Evaluate the trained model with our Semantic Cache\n", - "As the ultimate goal of fine tuning is to improve performance for semantic caching we'll run an evaluation with our trained model to simulate a series of cache checks.\n", - "\n", - "Here we can also evaluate on different datasets we haven't trained on. For example, we can train on our healthcare dataset and run evaluations on our finance dataset to if performance improves for topics not in our training scope." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Perform our final comparison on our models " - ] - }, - { - "cell_type": "code", - "execution_count": 49, - "metadata": {}, - "outputs": [], - "source": [ - "# load the test dataset\n", - "test_dataset = load_dataset(\"csv\", data_files=f\"../datasets/processed/{test_data}_test.csv\", split='train')" - ] - }, - { - "cell_type": "code", - "execution_count": 82, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "generating vector embeddings\n", - "computing distances between embeddings\n" - ] - } - ], - "source": [ - "model.load_state_dict(before_training)\n", - "metrics_before_training = evaluate_model(model, test_dataset)" - ] - }, - { - "cell_type": "code", - "execution_count": 83, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "generating vector embeddings\n", - "computing distances between embeddings\n" - ] - } - ], - "source": [ - "model.load_state_dict(after_training)\n", - "metrics_after_training = evaluate_model(model, test_dataset)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Visualize metrics\n", - "Since we're tracking multiple metrics - true and false positives and negatives, accuracy - we want a way to quickly visually compare all of these" - ] - }, - { - "cell_type": "code", - "execution_count": 85, - "metadata": {}, - "outputs": [], - "source": [ - "from matplotlib import pyplot as plt\n", - "\n", - "def display_AUC(metrics_before, metrics_after):\n", - " precision_before = [m['TP'] / (m['TP'] + m['FP']) if (m['TP'] + m['FP']) > 0 else 0 for thresh, m in metrics_before.items()]\n", - " precision_after = [m['TP'] / (m['TP'] + m['FP']) if (m['TP'] + m['FP']) > 0 else 0 for thresh, m in metrics_after.items()]\n", - "\n", - " recall_before = [m['TP'] / (m['TP'] + m['FN']) if (m['TP'] + m['FN']) > 0 else 0 for thresh, m in metrics_before.items()]\n", - " recall_after = [m['TP'] / (m['TP'] + m['FN']) if (m['TP'] + m['FN']) > 0 else 0 for thresh, m in metrics_after.items()]\n", - "\n", - " from sklearn.metrics import roc_auc_score\n", - "\n", - " y_true_before = []\n", - " y_score_before = []\n", - " y_true_after = []\n", - " y_score_after = []\n", - "\n", - " for thresh, m in metrics_before.items():\n", - " y_true_before.extend([1] * m['TP'] + [0] * m['FN'] + [0] * m['TN'] + [1] * m['FP'])\n", - " y_score_before.extend([1] * m['TP'] + [1] * m['FN'] + [0] * m['TN'] + [0] * m['FP'])\n", - "\n", - " for thresh, m in metrics_after.items():\n", - " y_true_after.extend([1] * m['TP'] + [0] * m['FN'] + [0] * m['TN'] + [1] * m['FP'])\n", - " y_score_after.extend([1] * m['TP'] + [1] * m['FN'] + [0] * m['TN'] + [0] * m['FP'])\n", - "\n", - " auc_before = roc_auc_score(y_true_before, y_score_before)\n", - " auc_after = roc_auc_score(y_true_after, y_score_after)\n", - "\n", - " plt.figure()\n", - " plt.plot(recall_before, precision_before, scalex=False, scaley=False)\n", - " plt.plot(recall_after, precision_after, scalex=False, scaley=False)\n", - " plt.title(f'trained on {train_data}, test on {test_data}\\n Precision Recall curves with finetuning')\n", - " plt.xlabel('Recall')\n", - " plt.ylabel('Precision')\n", - " plt.legend([f'before finetuning auc={auc_before :.4f}', f'after finetuning auc={auc_after :.4f}'])\n", - " plt.show()\n", - "\n", - "\n", - "def display_accuracy(metrics_before, metrics_after):\n", - " accuracy_before = [m['accuracy'] for thresh, m in metrics_before.items()]\n", - " accuracy_after = [m['accuracy'] for thresh, m in metrics_after.items()]\n", - " plt.figure()\n", - " plt.plot(list(metrics_before.keys()), accuracy_before)\n", - " plt.plot(list(metrics_after.keys()), accuracy_after)\n", - " plt.title(f'trained on {train_data}, test on {test_data}\\n Accuracy with training')\n", - " plt.xlabel('Threshold')\n", - " plt.ylabel('Accuracy')\n", - " plt.legend(['before finetuning', 'after finetuning'])\n", - " plt.show()\n", - "\n", - "\n", - "def display_f1_score(metrics_before, metrics_after):\n", - " f1_before = [2 * (m['TP'] / (m['TP'] + m['FP']) * m['TP'] / (m['TP'] + m['FN'])) / (m['TP'] / (m['TP'] + m['FP']) + m['TP'] / (m['TP'] + m['FN'])) if (m['TP'] + m['FP']) > 0 and (m['TP'] + m['FN']) > 0 else 0 for thresh, m in metrics_before.items()]\n", - " f1_after = [2 * (m['TP'] / (m['TP'] + m['FP']) * m['TP'] / (m['TP'] + m['FN'])) / (m['TP'] / (m['TP'] + m['FP']) + m['TP'] / (m['TP'] + m['FN'])) if (m['TP'] + m['FP']) > 0 and (m['TP'] + m['FN']) > 0 else 0 for thresh, m in metrics_after.items()]\n", - "\n", - " plt.figure()\n", - " plt.plot(list(metrics_before.keys()), f1_before)\n", - " plt.plot(list(metrics_after.keys()), f1_after)\n", - " plt.title(f'trained on {train_data}, test on {test_data}\\n F1 Score with training')\n", - " plt.xlabel('Threshold')\n", - " plt.ylabel('F1 Score')\n", - " plt.legend(['before finetuning', 'after finetuning'])\n", - " plt.show()\n", - "\n", - "\n", - "def display_metrics(metrics_before, metrics_after):\n", - " # TODO normalize TP, TN, etc. by dividing by dataset size\n", - " colors = ['b','g','r','m']\n", - " plt.figure()\n", - " for val in zip(['TP', 'TN'], colors[:2]):\n", - " plt.plot(list(metrics_before.keys()), [m[val[0]] for thresh, m in metrics_before.items()], color=val[1])\n", - " for val in zip(['TP', 'TN'], colors[:2]):\n", - " plt.plot(list(metrics_after.keys()), [m[val[0]] for thresh, m in metrics_after.items()], marker='.', color=val[1])\n", - "\n", - " plt.title(f'trained on {train_data}, test on {test_data}\\n True Positives and Negatives -- higher is better')\n", - " plt.xlabel('threshold')\n", - " plt.ylabel('successes')\n", - " plt.legend(['TP before', 'TN before', 'TP after', 'TN after'])\n", - "\n", - " plt.figure()\n", - " for val in zip(['FP', 'FN'], colors[2:]):\n", - " plt.plot(list(metrics_before.keys()), [m[val[0]] for thresh, m in metrics_before.items()], color=val[1])\n", - " for val in zip(['TP', 'TN'], colors[2:]):\n", - " plt.plot(list(metrics_after.keys()), [m[val[0]] for thresh, m in metrics_after.items()], marker='.', color=val[1])\n", - "\n", - " plt.title(f'trained on {train_data}, test on {test_data}\\n False Positives and Negatives -- lower is better')\n", - " plt.xlabel('threshold')\n", - " plt.ylabel('errors')\n", - " plt.legend(['FP before', 'FN before', 'FP after', 'FN after'])\n", - " plt.figure()\n", - "\n", - " plt.show()\n" - ] - }, - { - "cell_type": "code", - "execution_count": 86, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkIAAAHcCAYAAAA6I8WuAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAgWBJREFUeJztnQd0FNUXxr8UQggl9I4gvRdpAiKKIAoiWFFUUBELoAgW7NgLImJBEBUsfxuigCKCKEUpKiAoSO+9J7QAIWH+53ubWXaXTWWTTXa+3zlzdnd2ypuy+7659757wyzLsiCEEEII4UDCg90AIYQQQohgISEkhBBCCMciISSEEEIIxyIhJIQQQgjHIiEkhBBCCMciISSEEEIIxyIhJIQQQgjHIiEkhBBCCMciISSEEEIIxyIhJBxLlSpVcPvttwdl39wv959bSEpKwqOPPopKlSohPDwc3bt3N/PDwsLw7LPPBrt5Iojs2bMH119/PUqUKGHuh5EjR2LOnDnmPV+FyOtEBrsBQqTGggUL8PPPP+PBBx9E0aJFg92ckGbcuHF4/fXXzbm+4IILcN555wW7SbmGlStXYsKECdkuXt977z3ExMQETZynxqBBgzBjxgwMHToUZcuWRbNmzbB79+5gN0uIgBGmWmMitzJ8+HA88sgj2LRpU7Z0QCdPnjTWj3z58iGnYWfHp+nNmzcjN3DTTTdh3rx52L59u9f8EydOIDIy0kxOZeLEibjhhhswe/ZsXHLJJdm2n/r166NkyZK5zspC8dOhQwf873//c887ffo0EhMTERUVZX5DQuRlnPvvJkIK+485Ojo6w+vkz58/W9uUl9i7d69fq1tmzqdwzr1B8aN7Q4QKkvIiV8K4FFqDyPnnn2/iETjZFhS+HzBgAD7//HPUq1fPiJrp06e7LUmtW7c2MQ0FChRA06ZNzVN9ejFCH3/8sdnu/PnzMXjwYJQqVQoFCxbENddcg3379p21/k8//YS2bduaZQoXLowuXbrgv//+O2u5yZMnm6d9dhx8nTRpUqZdJvYxli9fHv3790d8fLzXMrRUcNt041x66aXGxVKhQgUMGzYszW3zfPKYae1g2+3zbFslfGOE+J7z1q9fb84dO8jY2FjccccdSEhI8Nr2+PHj0b59e5QuXdq0vW7duhg9erTf63DVVVcZi1SLFi3MeapatSo+/fTTs5blcdNVw3W4zYoVK6JXr17Yv3+/l6WPbpzq1aubZRj3xPgnzs8svCdoDSI8r77nJ6P3AV1JPEdsL9tUrlw5dOvWzX0/83i4zty5c937SM/6dOzYMTz00EPm+LjNWrVqmXvf18hv/1bs+5DL8n6yfy9pHTvX5fZGjRrlbhfxFyOU0XuQDyzPPPOM+V3y3uF54/njPejv3uQxjR07FtWqVTNtb968ORYtWnRWe1evXo0bb7zR/G75u+f5ePLJJ72W2bFjB+68806UKVPGfR7oFhYOh64xIXIb//zzj3XzzTfzH9168803rc8++8xMR48eNd9zfp06daxSpUpZzz33nDVq1Chr6dKl5ruKFSta/fr1s959911rxIgRVosWLczyU6dO9dpH5cqVrd69e7s/jx8/3izXpEkTq3379tY777xjPfTQQ1ZERIR14403eq376aefWmFhYdYVV1xhlnvttdesKlWqWEWLFrU2bdrkXm7GjBlWeHi4Vb9+fdOWJ5980oqNjbXq1atn9p8eQ4cONW3q0KGD2c+AAQNMe5o3b24lJia6l2vXrp1Vvnx5q1KlStbAgQOt9957zxwD1502bVqq2+f55HmtXbu2OW/2ed69e7f7PLMNvu3hObr22mvNfu666y4z79FHH/XaNtt4++23m+vHtl9++eVmOV4X3+tQq1Ytq0yZMtYTTzxhvr/gggvM+V2xYoV7uSNHjpjzyOPv27evNXr0aOuFF14w+7GvfXJystlPTEyM9eCDD1rvv/++OWeRkZFWt27drMyyYcMG64EHHjDtZtt8z09G74PWrVub6/7UU09ZH374ofXyyy9bl156qTV37lzz/aRJk8z553Ww9/Hzzz+n2q7Tp0+b68t98/zznHXt2tW0k8ftCec1atTIKleunDlfI0eOtKpWrWrO0f79+9M8draD63fs2NHdLjJ79mwzn6+ZvQf37dtn2jJ48GBzDYcNG2auf758+dzXkfD82fda9erVzbnlsiVLljTnyvP+5/9FkSJFrBIlSliPP/64ue68Hxs0aOBehteM67F9zz//vNn31Vdf7f6PEc5FQkjkWl5//XXzJ+XZodhwPgXGf//9d9Z3CQkJXp/5h8kOlH/KGRFCFB3saGwGDRpkOt/4+Hh3h8yOjp2xJ/yjZWfnOb9x48bmT99el7CD437SE0J79+61oqKiTMfODt6GnR7XHzdunFcnxHnsmG1OnjxplS1b1rruuuvS3I+9PsWZL6kJoTvvvNNruWuuucZ0QmldB9KpUyfTCXvC88Bt/vbbb17Hnj9/fiNEbZ555hmz3HfffXfWdu3rxY6a98Xvv//u9f2YMWPMuvPnz7cyyzfffHNWp5+Z+yAuLs6sz/s5LXj+eR0ywuTJk802X3zxRa/5119/vRFH69evd8/jcryPPOdROHA+xVt6cLn+/ft7zUtNCGXkHkxKSjLzPeE5ohD2vK9sIcT76uDBg+75U6ZMMfN/+OEH97yLL77YKly4sLVlyxav7Xr+jvv06WN+i77i76abbjLXy9/9KpyBXGMiz9KuXTvjbvGFZnGbuLg4HDp0yJje//777wxt9+6773a7AAjXTU5OxpYtW8znmTNnGhfNzTffbFwy9hQREYGWLVu6Tfy7du3CsmXL0Lt3b+MCsOnYsaPfdvvyyy+/GDcCR3J5BqT27dsXRYoUwY8//ui1fKFChXDrrbe6PzOQla6mjRs3ItDce++9Xp95jg4cOIDDhw/7vQ68BjxHvGZsDz97wvPBbdjQvUHXhmfbv/32WzRq1Mi4Kn2xr9c333yDOnXqoHbt2l7Xhi464ut+ORcyeh/wPPBa0I3E+zEQTJs2zezngQce8JpPVxm1C911njDYma4lm4YNG5p7KND3RkbuQbab8+3YvoMHD5r0DRyN5u832qNHDxQrVsz92b5P7G3Sbf3bb78Zl5fvaEf7vuA54f3TtWtX897zenXq1Mncjxn9fxChh4KlRZ6FsUP+mDp1Kl588UUjQjzjQjzFTVr4/pnaf8J2J7Zu3TrzaneuvrCDIbZwqlGjxlnLsJNP74/XXp/LesJOhDE09vc2jD/xPUa2/d9//0WgSesc2cfPWCvG6ixcuPCs+CF2PJ7i0N9wfW7TUzhs2LAB1113XZrt4rVZtWqVEVKpBf4GiozeB4xFee2114xIYWzKhRdeaGKiGNvEEVlZgdee8WKMSfKEItD+3pOMnN9AkNF78JNPPsEbb7xh4npOnTqV5m86vd+jLYgYn5QaFEsUrYw14pTd94bIW0gIiTyLp8XB5vfff8fVV1+Niy++2AQZMyiVw+MZuPvFF19kaLt8YvWHHYTKp1jy2Wef+e3IgjXUPL125+S+KFouu+wyY5kZMWKECeilgKMl480333Sfw0C3ndtt0KCB2ac/2I5AkZn7gFY9WiMYsMycPE8//TReeeUVzJo1C02aNEGo3BsZ2Q+H4TPQnkk7OSCCwfRcj+eD901WtpnRa0VrFS20/qCVTDgTCSGRa8moBccTmr856oidjefweAqhQGG7GPgHTpdDalSuXNnLcuDJmjVr0t2PvT6XpQXIhu4y5lZKa9/B5ocffjDWuO+//97rif5cXFM87ytWrEh3mX/++ceIsKzcP/5IbTsZvQ88l6dViBPvicaNGxuriJ2fJzPt5b1B1+mRI0e8rEK0sNjf51Y4gpP383fffed1zLQeZgX7t5HWvUELIc8TXdy5+XcjgoNihESuhcNqie9Q8bTg0yP/XPmH5zkMl0/igYIxBXR7vPzyy15mfRt7qD2tUezs6AbwjIlhbAmHGKcH/7BpRXn77be9nn4/+ugjsz0O086t2E/xnu1mm89FkNItRpHjL/2AvR8On+YQ6Q8++OCsZY4fP26GnAfqPszofUC3IBNT+ooidsyerlvuJ6P3eufOnc09/u6773rNp7WN9/+VV16JvHRv/Pnnn8aFmhUocmgB5jD4rVu3en1n74P75P3DByV/gslfegzhHGQRErkW5hkhzAXCzMd0cdG9YHdM/qA4oFvkiiuuQM+ePY3fnzlQmFMmULEy7PyYD+e2224z5SjYNv4Z80+YAcxt2rRxd1A097NNF110kQnmZGDoO++8Y/KXHD16NM39cJuPP/44nnvuOXM8dPnROkSXH3OpeAal5jYuv/xyI+J4ve655x5zrBQntJ4wiDwr0I1iZ3nmueT9wfNJq9OYMWNMIDWvCcthMJib1ideCwoGWko4n5ZCBuXaOZF4btPLGE0xy46UcT4Uc7Q02vmRMnIfrF271lioKNIYFE6XGcUca3hxHRseD7fH+Dber9x+avFHPK/M1cPfBoU+j53laKZMmWLccJ6B0bkNxkfRGsSgd/42aN3k9eO5Se83kRp8WOBvjNeBgx0Ya8TzwuvAWEHy6quvmmvNQHYOOOD+eP8wVo/WNb4XDiXYw9aESAvmPalQoYIZEu05lN7fkF6bjz76yKpRo4YZfs28LBwWbw/7zsjw+UWLFqU7VNiez+HgHHobHR1tVatWzeTNWbx4sddy3377rcl5xPbUrVvXDP/mfjOSR8geLs/jYJ4VDjG+7777zHDjjAx/z+h+Mjt8nrlgPLHPnWeqg++//95q2LChOTfMrcM8MBzy77sc29elSxe/bfIdTn7gwAGTF4j3BIeEMy8Mj9FzSDTTJXBfPB6e82LFillNmzY1+aYOHTrkXo5D8znUfNWqVemenw8++MAM+2caBd97Ib37gG3jvcprWLBgQbNcy5YtrQkTJpw17J7ngcPAuY/0htJz+D5TOzB3D+8N3vMcou85ZDyt34rv/R+I4fMZuQfZPuZR4jxeH+YJYo4v3+Xs4fP+0g743peEOaeYxoEpDXgdmJvo6aef9lpmz5495liYS4jnjEP7L7vsMmvs2LHpngcRuqjWmBDCkXBYN2NpOOReCOFcJISEEI6D+Y7oxqLbxB5yLoRwJhJCQgghhHAsGjUmhBBCCMciISSEEEIIxyIhJIQQQgjHIiEkhBBCCMciISQcx8cff2yy7zLhWmbgOkzCJ7zheeS54Xm14XkKVIkLkbl71l528eLFWd7f9OnTTSJJlqvhtpjxmvXBqlSpglCCiTTTSqYpnIGEkMixjtKemKWX9aeYWdbO+ipSxxYV9sQM2+yQHnjggUyVHxGhBTOMe4rPQHHgwAGTBZtFjZmVnUVl08rmHkhYeob3e2YfUoQ4F1RiQ+QYN998s7tG0qpVq0w5gZ9++gl//PGHefrMKVgSgaUNPIuyZgTWqgpWZXnC81WoUCFTL+vXX381pTpYHmDevHlBa5MI3j1LIVSyZEljqQkkixYtMsVcX3jhBa8CpSyRYldxz04hxLIntNLkhPWJZUmEkBASOQbrAHnWx2ItJtbPYgf//vvv+12HnX6gn0ZpkbILP2YGugmCyfXXX286PsL6XewYv/76a/z1118mS7I4m6SkJNN5s+5ZXiar92xWYH0+UrRoUa/5tESGGnn9vhCBQa4xETTsgpIsuugZ2zB37lz069fPFJ2sWLGie3laj9q2bWuEESt3s2Djf//9d9Z2WWCTpn1mDqZ5v1atWqY4ZVrxFoynYDVxCg2uw6KNLOyZXozQ0qVLTaVvFmKltYbFNWnh8sTe3/z58zF48GDTLh4DXYPnUvWa54Js2LDBaz4rebNIa2xsLGJiYtCuXTuzb19Ypb1Pnz4oX768sTTwmO+77z4kJiaa71mE8uGHH0aDBg3MsfEYeaysAB9I2F5aCosVK2bOS8OGDfHWW2+lG8fhG7Niu2CHDx+OkSNHmsKjPC5eI1ryaGnwhUVsuY5nFXe6G1m4tFKlSmZ9FkBlwVVfa8hXX31lCqXyXuS54XnybHdqDwPXXnut1zyuxzZ4FgWmwOU8Wk793bM8bt77/K3YLlPfc8TK9pm937iN3r17m/cs7Mvt2hantM732LFj3eeb69Gq5O93STFfvHhx81DB4rcsmGvDY2RBXcKCsvZxzZkzJ80YPbbJ0yqWmd+b773FfXFdFuh96aWXzP8P28rf9fr168/aN12HVatWNf8ZfBj5/fffFXeUB5FFSAQNuwMvUaKE13yKIP55PfPMM8YiRBinwD9oihV2SgkJCcaSxIrT7OjsP2h2JhQIfHplFWrO535++OEH88eW2hMwq6Vzn4899ph5EuafPCtkpwU7Iu6LneCjjz5q9knLFv8E2UGxyrUn999/v+nshw4darbPznrAgAGm08sKdqfIbdrMmjXLiBV20NxPeHg4xo8fb0Qn/6Rty9HOnTvNe3b6PE+1a9c2wojV3Xlu+aS8ceNGTJ482XROFEmsls7jo7CiC4MC6lyZOXOmqUZerlw5DBw4EGXLljWd/9SpU83nrMDjPXHihDkudszcNtvMzo3nxBOee1pa7A6Yx85leS5odWMs24IFC/D4449j165d5prZ7aarlx0k70fCdrPzTavdvF++/PJL92eKTd5HvE68PhSBhO95P6ZW/oPt4P1EgWqL/DJlypzz/cZt8cGBwub555831z29SvZffPGFcaXxfFFEDBs2zIg93j+2FYnHSAtwhQoVzG+MwoTXo3v37vj222+NSLn44otN3BsryT/xxBPuY89qCZRz+b2xUj2vCR8EDh06ZI7plltuMaLdhv8/3B6v6aBBg8w+eDzcp+cDnMgDBLvqqwh97CrSrP7NquWssj1nzhxTdZrzWZ3ds4L5RRddZCUlJXlV2WZF6b59+3ptl9thJW/P+RdffLGp3r1lyxavZT0rcvtWSp80aZLfqvPpVbzu3r27qYC+YcMG97ydO3ea/bMdvvvr0KGDVztYOZzVzOPj49Pcr13xfc2aNeb8bd682VRxL1CggFWqVCnr2LFj7mNkBXJWQvfcT0JCgnX++edbHTt2dM/r1auXFR4e7veY7XVPnDhhJScne33Hc8aK4c8//7zXPLaPx+nb5rTgNWa7WHE8Li7ObxtSq0JPUqtWXqRIEWvv3r1ey77//vvmu+XLl3vNr1u3rtW+fXv35xdeeMFUiF+7dq3Xco899pi5Vlu3bjWfBw4caPbjeZ9mhG+++ca0Y+XKlebz999/b87n1VdfbfXo0cO9XMOGDU0l9dTuWcJK7/7Oy7neb/b6vvdGaue7RIkS1sGDB93zp0yZYub/8MMP7nms8N6gQQNzT9mwba1btzb3rO/58axqn1bFecI2sW1ZOX7fe4v75bp16tSxTp486Z7/1ltved0//I7H3bx5c+vUqVPu5T7++GOznL/rInIvco2JHINPZnzK5VM/rSa01PBp2tdV0LdvX694CD5903LBJ/D9+/e7Jy5Dq8vs2bPNcjR7//bbb8alxSd5T9Iaym3HQtAKcerUqQwdCwO+GWjJJ0Caxm1ofejZs6cJYGZhT09oofBsB58kuZ0tW7ZkaJ98Uuf5o5WLx0iXDd2FdH8RjsBbt26d2T9H/tjniVY1Wi54buje4URLT9euXY17whe7jbSm8KnYPl5ukxYItoNB2ucKLXl0i9IN5RuPci5D76+77jpznjzhPUb3mKc1YMWKFcay1aNHD/c8VqLndeFTvee9xqBhngOeQ8L28rzy3syKO9PeDi0/dCV17NjRvCe819k2e9mscq73W0bh+fO0StrtpkXItnrRUkl3NS1H9jnl/UQLL+9ZWuACzbkc/x133OEVP+R7THSls/38r/IcQEGrkee5EHkDucZEjsE/Jrog2LmyI6lXr57fkVs0x3vCP0rPmCJf6Jry/JOqX79+ptpFVwg7T8aQvPnmm0akUeBQUKQ2soyii24UigJfaMqn2Ni2bZs5RhtfcWb/YcbFxWWonXQh8Fi5b7oPKCIYm+B7nuwYD3/QzM8YIIq09M4Tj4ExLxydxH2xE7HxdWeei2s0s9crPXzvH8LYL4pBumM4GopQFLET8xTiPId0r/oKKd9AYrpvuS26IenuoWuVHT1js9KC7qsaNWoY0UNXEl8ZD0O3EF05vIfpYuO5P1chdK73W6D2w9gaGnSefvppM6V2Xnkec7Jd57KuLab4MOIJ76dQy7XkBCSERI7BDsBzOG5qeHbuxA5SZZwQrUm+nOuQdj41MjaGQc6MJZoxY4axuLzxxhtmHq0ggSC1UT8uq3/6sLO0R43RmsMgWz6BLlmyxIhL+zy9/vrrqaYj4LHwCT0jvPzyy6bj4rmgeGCQK/dDC052D6P2vT7+zpGnMEvr/rHhKDs+6dNyxvNDIUNxZJ9TwuOidYYxX/6oWbOmeWUgP7fDe4VWOU6MTerVqxc++eSTNI+HcW1Mf8B0DLx2jIWjGOTDAYURhRCvU5MmTRDM+y1Q+7HvFcbb0ALkD19BkRlSuw/O5fhz6tyJ3IGEkMj12MGa7HzSElK2i4puhaxw4YUXmolB1QwApcjgyKC77rrrrGVpMaBLiqOO/I2OoWDgqKPsgh0lXY3s2Nmhs5O3zxOtRmmdJ7ady6R3nigOaa346KOPvObTdeMpHrKK3V62I6328mnctvZ5klkXD618tMLY7rG1a9eaIGjfNh09ejRDgp2uEwpSTuzsaSViMDnFY1odOy09FE28t9iJt27d2twvFEi2EOK89IbL55XM3fbvkoHT6Z3XtI6J94FvAlFaNxnEntNUrlzZbe3ib8QzXQODpu2gd5E3UIyQyPXwKZIdNy0U/mJ47CGx7OBpNRk3bhy2bt2a4Sc5mrt9v7ctKhyC7A92UnSHTJkyxWsYPkdWUUSxU7NddtkFhRpHp9ijljhSjB05hzOzM0/tPLHTpSig9ctfGQb7XPAYfc8LY2gCFc/BoeR0Y3E0j28H57lfHhPFpefQZw7h95cSIC1oceG9ROFIEUIhw/PgCd1bCxcuNJYeX9hGdnSE8SGe8JzanV9q94yN7fLideM6THNgz6eliNckI24xjrzKC5nF+QBDdzNFoj/R4nld7Zxh/o6L94EdW2XD0W2pWYSyE8bW0T3MJJP2PUE+//zzgLseRfYji5DI9VBQcKgqs+uy86T1g6KHYufHH380w3LtPDCMnaEI4XKMSWJHS6HC5VIr50FXBuNgOISXf7YM6OQfHPfL/Dap8eKLL5pgWe6P1gC66Phnz46Qw22zGz5hc6j2I488YmpDMT7lww8/NHErjE2itYhxFxQuDCjn8VD8EIpKBnszPorniXFN7KQodBjoTdHAYe0cQs3t0EKxfPly80fvGRx+LlA88LrSokLhyf0w2Jyih8OtbTFC19yIESOMiGHeI8aTjBkzxhyjb0B6RgJ7mdST15vb8w3S5rlkbhseO3PTUFwyKJrHTgsZ7yVaw2glpIuRcWsUo7ROMdM3jyO94d60FtHFS2si44JsKOKHDBli3mdECLFtPH+8D7lNCo7U4uiCDfPt8HdCdy4DjHkP8aGBonP79u3u3FQ8fxTgFImMZ2OMHo+Jx8Zzfu+995p4ProvuQ7vkUBYJzMLRTRzGvH6sX0U0Lw3mMOI/yF5xVonXEgIiTwBA5eZt4b5PRgDQ7HBTp4dBjtQm0aNGpm4Hron2EkwnwzN2PyjSg2KAWZnppWAf858QmeOHXb6/gJvbdgR05VB98orr7xi3CMcxfa///3vrBxC2QVFDDtCnhcKIT55s3NhTA/FIS1D7HTZHrqFbHjumBOF54nHSUHBeRRR9ig05nKhCKCFi+4kiksKSuaBCRQUIxRpDFRnTBbPITsSdpY2FBaffvqpiaVhgry6deuaeDG2y062l1GYyZwxRBS7nqPFbHjszAFFoUhRyP1SQDI2iG20rTcUU7RGUFDResFzzO2xc7RH2qUF71tun+LAU9hw/7QwZOT+4fmgAKPo5vHwPs6tQojXjJYunkOKBVrUKG4YB8XjsOF5pMjl74mil9Ye3h9clvcEg/bpqqXw5znkgwjjvIIBcwjRcsn7lvFP/O+hiGYupGBnoReZI4xj6DO5jhBCCCF8oJCntZojEWlVFnkDxQgJIYQQmYTWZl87Ai2IdJmqxEbeQhYhIYQQIpPQLcvSGsyNxsBpJhml246uXKZFUEHXvINihIQQQohMwsSJTJHBARq0AjHPFvNIMV5PIihvEVTXGIdCcsQIg2AZZc+0/xlR4QzatKtCM/BOCCGEyGkhxODo3bt3m3xGfGXqDgZ2i7xFUIUQR6Qw0p5DKzMCRwx06dLFJLDiUGhmuOWQSn85P4QQQggh8kyMEC1CkyZNOivBmSfMscHhu54ZcZlThsNXOZxSCCGEECJkY4SYH8U3RTvzkNAylBrMN+OZ6ZXDG+nPZXCbkl4JIYQQeQPabZgzi+E0GcnXFZJCiD5YVm/2hJ+ZDI4FDP0VW2RiLibxEkIIIUTeZ9u2bSajuyOFUFZg1l9mo7Vh2vbzzjvPnMjsrgVFRsxci3HzNpn3H/ZqhgurlcjYislJwKHtQPwWIG6Lx+tW1/tTx9JeP38RoGhloOh5QLEqrvfFUj4XKQ+Ep13QUQghhMhN0OjBkXqFCxcO6HbzlBBi+nWWQPCEnylo/FmDCEeXcfKF6+SEEDpuRSE8v6tkwY9r4nF5k9RLNpxFseIA/FQxZljXsf1A3CYgbjNwkK+bzrwe5Tk6AsSvcE1naoK6iIhKEUjnA8XPdwklz/f5/J9LIYQQItgEOqwlTwmhVq1aYdq0aV7zWGuG83MrBxMS3e9/WrEbzyecQmxMvnPbKG+CQqVcU6UWZ3+feMxlPXKLo81n3tOilJwIHFjvmvxRqGyKKLLFUYpA4vuYEq79CyGEECFAUIUQC0KuX7/ea3g8h8UzMRXdV3RrsXI205YTVh5mIclHH33UVKSeNWsWJkyYYEaS5VbiU4QQtUNi0ml8/+9O3HZh5ezdaVRBoExd1+TL6WSXy81THLktS5uBk4eAo7td09aFfrZdGChexceKlPJapCIQkae0tRBCCIcT1F6L1YiZE8jGjuXp3bu3SZS4a9cubN261f09K4FT9DCt+VtvvWWCpT788EMzciy3cvCYSwh1rFMGP6/cgwmLtmW/EEoLxgYxVogT2p3tcjse5yGOKJQ2nxFKh3cAiUeA3ctd01nbjgRiK51tRbLf5y+UY4cphBBC5Kk8QjkZbBUbG2uCpnMiRqjpCzNx4Fgivux7IXqN+xOnki1Me6At6pbP/n0HnFMnXIHaXlYk+/0WIPlMmgK/FCztLY4845MKlZbLTQghRI733/JjZCOnT1uIS3GNVStVEB3rlsG05bvxzZJtGFq+HvIc+aKBUrVcky+nTwNHdvoJ3k6xKNHSdGyva9r+l59tF/QQSVW8BRMDuyPOMa5KCCGE8IOEUDZy+MQpnE6xtxWNicINzSoZITR56Q48dmVt5I8MoSHsTG4VW9E1Vbno7O+Px6cyym2zK2aJ6QD2/ueafAlL2ba/4G2+j86D1jUhhBC5AgmhbCQu4ZR5LZQ/ElGR4bi4RimULRKN3YdP4NdVe9G5QTk4hgJFgQJNgPJNzv4uKdE1ms3fKDe+Tzqekj9pK7Bp7tnrcySbv+BtzuMIuABmIBVCCBFaSAjlQKB0sYIut05EeBiua1oBo2ZvwITF25wlhNIiMgooWd01+cIQtiO7UxnltglI2A8kHHBNO5b42Xb0GZHkG59El1vk2TmmhBBCOAcJoWwkLkUIFY+Jcs+7oWklI4R+W7sPuw4dR7lYJS9MEwZQFynnmir7yRd14nCKSPIRSnylyy3pBLBvtWs6e+NAkQpnrEe+ySULFMuJIxRCCBFEJISyETtQmvFBNlVKFkTL84vjz00H8e2S7RjQvkYQWxgCMD6oXEPX5EvyKeDQNj+j3FJeGZd0eLtr2vy7n20X9TPKLUUsUUDJ5SaEEHkeCaEcEELFC54RQuTGZpWMEJqweDv6XVId4eEaNp4tcKRZ8aquKa0yJf5GubFMyYl4YNcy1wR/ZUoq+ylRwqmyypQIIUQeQUIoB4Kli/qU1LiyQVkM/f4/bD2YgL82H8SFVTNYiFUEjgyVKdnsv5abu0zJOtfkj8LlUh/lFlNcOZOEECKXICGUwzFCJCYqEl0blcOXf20zQdMSQrkQU6aknmtKtUxJKqPcTh4GjuxyTVsXnL1+/iJn50qyLUsqUyKEEDmK/nFzZNSYtxAizClEITRt+S48d3U9FI5WwsA8g2eZkqqXpF2mxDc+iUknKZR2/+uaztp2pGs0m2/mbfs9BZoQQoiAISGUjcSnuMaK+ViESJNKRVG9dCGs33sUP/yzCz1bnheEFoqAQ5cXXV+cKjY9+/tTx13lSPyNcmP5ErrcDm50TRv8bL9QGT8xSSmWpYKl5HITQohMIiGUjRxM8M4j5ElYWBh6NKuEl6atMu4xCSGHwCDq0rVdU2plSvzVcuMrg7cZxM1p259nrx9V6IzLzdftxmK4KlMihBBnISGUEzFCflxjpHuTCnht+mos2xaPtXuOoGaZwjncQpFry5Sc3/bs7+ly81vLLaVMSeJRYM8K1+RLWIRru/6Ct/maX/eeEMKZSAhlY8HV+OOpu8ZIqcL50b52afy8cg++WbwNT3apm8OtFHkKJnjk5LdMycmUMiV+RrmZMiUnXK43Tphz9voxJf0Hb/N94bJyuQkhQhYJoWziyIkkJKdUXPUdPu+bU4hC6Lu/d+DRK2ojX4SS9IkswFIhJWu4Jn8uN7rT/I5y25RSooSlSvYDOxb72XYB/5m3+Vq0ksqUCCHyNBJC2RwfVDAqIs0q85fUKmUsQ/uOnMSs1XvRqV7ZHGylcIzLzV2mpHUaZUr8jHIzZUqOA/tWuaazCHO53Cq1BBr3dI2i46g6IYTII0gIZXNWaX9D5z2JjAjHtRdUwPtzN2LCom0SQiL3lSmxXW6eFiX7lWVKWMaE04qJrtIjjW52iaIS1YJxNEIIkSkkhIIUKO3rHqMQmr1mL/YcPoEyRaJzoIVCZACONKOg8SdqTJmSfcD+tcB/k4Dl3wCHdwC/D3dN57UGmtwC1O0O5C8UjNYLIUS6KCAl28trpC+EqpUqhGaVi4EhRYwVEiLvlCkpDVS5COjyBvDQWuD6cUC1y1wuM2bVntIfGF4TmNwP2DzPJZ6EECIXISGU7eU1Mpa7hVYhwtFjljoLkRfJFw3Uvw647Ttg0H9A+6eB4tVc7rNlnwMfdwHebgzMHQbEbwt2a4UQwiAhlO3JFNO3CJHODcshJioCG/cfw5ItcdncOiGymdgKwMUPA/cvAe6cATS5zZXwkXFFs18CRjYAPu0G/PuNK9u2EEIECQmhbCLeFkIZcI2RQvkj0aVBOfOemaaFCBn32XkXAt3eBR5eC3QfA1RhskgL2DgH+O4uYHgt4IcHgW2L5DoTQuQ4EkJBKLiaGjc2d7nHpv67C0dPJmVb24QICiwY2/hm4PapwAPLgHaPAbHnAScPAUvGAx91AEa1BOaNBI7sDnZrhRAOQUIom4g75gqWLp5BixBhwHTVkgWRkJiMaf/uysbWCRFkmJDx0seBgf8Avb4HGvZwJW7cvwb4ZSgwoi7w+Y3AyilAkuuhQgghsgMJoezOI5TBYGm7EOsNKUHTco8JxyR7rNoOuHYs8PAaoOtbQMUWgJUMrJsBTOgFvFEL+GkIsOufYLdWCBGCSAgFOaGiL9ddUAER4WFYvCUOG/YdzabWCZELiY4Fmt4O3DUT6L8IaPMgUKgscPwg8OcY4P2LgdEXAX+MBo4dCHZrhRAhgoRQNsDh73YeoYwGS9uULhKNS2qWMu+/Wbw9W9onRK6nVE2g43OuYfi3THQlZYyIAvYsB6Y/5rISfX0rsGY6kKx4OiFE1pEQygYOZ7DgamrY7rFv/96OpOTTAW+fEHmGiEigRkfgxk+Ah9YAV74OlGsEnD4FrPoB+LIH8GZd4OengX1rgt1aIUQeREIoG5MpsuBqdL7MF6BsX7s0ShSMMoVY56zZlw0tFCIPElMcaHk3cM9vwL3zgQv7AzElgaN7gAVvA6NaAB+0BxZ9BByPD3ZrhRB5BAmhbIwPykh5DX9ERboKsRIFTQvhh7L1gSteBgavAnp8DtTqDIRFADuWAD8OdrnOJvYBNswCTicHu7VCiFyMhFA2CqGMFFxNzz02a/VeYxkSQvghMgqocxVw85fAQ6uBy18EStUBkk4AKyYCn10DjGwIzHoROLAh2K0VQuRCJISygYMpOYQyO2LMk5plCqNxpaJIOm1h8lIVYhUiXVgAtvX9QL+FQN9ZQLM+rpFoh7cDv70OvHMBMO5KYOn/gJMakSmEcCEhlK3lNTIfKO2vECvdYyrEKkQmynpUaApcNQJ4aC1w/Tig2mX8Ati6AJjSHxheE5jcD9g8X2U9hHA4EkLZWV4jizFCNlc1KofofOFYt/colm1T8KcQmSZfNFD/OuC271xD8ds/DRSvBpw6Biz7HPi4M/B2E2Du60C84vGEcCISQtmaVfrchFCR6HzoXF+FWIUICLEVgIsfBu5fAtw5A2hyGxBVCIjbBMx+ERjZAPi0G/DvN8Cp48FurRAih5AQys46YwXPzTXmWYj1h392ISFRieOECIjr7LwLgW7vAg+vBbqPAaq0ZSpUYOMc4Lu7gOG1gB8eBLYvlutMiBBHQigbOJjF8hr+aHl+cVQuEWOq0f+0XBW5hQgoUQWBxjcDt08FHlgGtBsCxJ4HnDwELBkPfHgZMKolMP8t4Ih+f0KEIhJC2Rosfe5CyBRibVrRvJd7TIhspPj5wKVPAAP/AXp9DzTsAUQWAPavAWY+A4yoC3x+I7ByCpDk+o0LIfI+EkLZOXw+AEKIXNe0orHm/7npIDbvPxaQbQohUiE8HKjaDrh2LPDwGqDrW0DFFoCVDKybAUzo5UrY+NMQYNe/wW6tEOIckRAKMBzmHh+AhIqelIstgItruAqxTlyiQqxC5BjMQ9T0duCumUD/RUCbB4FCZYHjB4E/xwDvtwXGXAT8MQY4diDYrRVCZAEJoQBz5GSSSYKY1YKr6eUUohCyC7oKIXKQUjWBjs+5huHfMhGo2x2IiAJ2LwemD3FZib6+FVgzHUjWwAYh8gqRwW5AqBZcjcliwdXU6FC3tEnQuPvwCfy2bh8urVU6YNsWQmSCiEigRkfXlHAQWD4RWPY/YNc/wKofXFOhMq4Yoya3AqVqBbvFQog0kEUolyZT9CV/ZAS6N3EVYv1GQdNC5A5iigMt7wbu+Q24dz5wYT8gpgRwdA+w4G1gVAvgg8uAxeOA40qKKkRuREIowMQn2HXGAucWs7mhqcs9NnPlHrfgEkLkEsrWB654BRi8GujxOVCrMxAWAexYDEwd5HKdTewDbJgFnD4d7NYKIVKQEMojFiFSt3wRNKgQi1PJKsQqRK4lMgqocxVw85fAQ6uBy18EStUBkk4AKyYCn13jymI960Xg4MZgt1YIxyMhlEvLa6TGjc3O5BRSIVYhcjmFSgOt7wf6LQT6zgKa9XGNRDu8HfjtdVeds/GdgaWfAyePBru1QjgSCaFsEkKBGjrvy9WNKiAqMhyrdx/B8h2HsmUfQogAw0RgFZoCV40AHloLXD8OqHYZvwC2zAem9AOG1wQm9wM2z1dZDyFyEAmhXJ5M0ZfYmHy4sn5Z816ZpoXIg+SLBupfB9z2nWsofvungeJVgVPHgGWfAx93dlmK5r4OHFLeMCGyGwmh7CqvkQ3B0r45haYs24kTp5KzbT9CiGwmtgJw8cPA/X8Dd0wHmtwGRBUC4jYBs18E3qwPfNrdNUT/1PFgt1aIkERCKA8FS9u0qloCFYoWwJETSZjxnwpBChESrrPKrYBu7wIPrwW6jwGqtGWuemDjbODbPsDwWsAPDwLbF8t1JkQAkRDKYzFCJDw8DDd4BE0LIUKIqIJA45uB26cCDywD2g0BYs8DTh4ClowHPrwMeO9CYP5bwJE9wW6tEHkeCaEAE5eSRyiQ5TX8cX1KIdb56w9g28GEbN2XECJIFD8fuPQJYOA/QK8pQIMbgchoYN9qYOYzwIg6wBc9gJXfA0nKLSZEVpAQCiAczm6X2MhOixCpWCwGbaqVNO+/USFWIUKb8HCg6iXAdR+4XGdd3wIqtgCsZGDtdGDCba6EjT8NAXb9G+zWCpGnkBDKpoKr2RkjZHNj85RCrIu3qRBrNrNuzxH8sfEA9h89GeymCKfDPERNbwfumgn0XwS0eRAoVBY4fhD4cwzwfltgzEXAH2OAYweC3Vohcj0quhpA4lOGzhfIF9iCq6lxed0yKBIdiZ2HTmDBhv1oW6NUtu/TaSzafBDvzlqPuWv3uefR2le9dCHUKF0INcsUNq/VyxRCqUL5EUZ/pRA5RamaQMfnXEPwWbqDw+/XTAN2LwemDwF+fgqodaWr+CvzFrFgrBDCC/0qAsjBHAiU9oRii4VYP124BRMWb5cQCqCLk7FX78xahz83HTTzIsLDUC42Gjvij5uRgX9tOmgmTxgXZkRR6cJnRFKZQihdWAJJZDMUODUvd00JB13D7Zf9D9j1D7Dqe9dUqAzQsIdLFJWqFewWC5FrkBDKhhFj2R0o7ZtTiEKIw+iZw6hoDrjkQlkA/bpqL96ZvR7/bHNVCs8XEYbrm1bCfe2q4bwSMTiemIwN+45i3d4jWLeHr0eN22zrwQRTcHfR5jgzeUKrXQ3bcuQhkMoWiZZAEoEnpjjQ8m7XtHuFy0r079fA0T3AgrddU4VmQJNbXIkd6WoTwsFICAWQnAqU9qRe+SKoU64IVu06jO//2Ylerark2L5DBcZX/bRil3GBsXQJyR8ZjptbnId72lVFudgC7mULREWgfoVYM3nCxJYb9x3zEEhHjEjaciABh08kYcmWODN5Ujh/pHGpUSDVoBWJ78sURvlYCSQRIMrWB654BejwHLDuZ5coWjsD2LHYNU1/HKjTFWh8C3B+O1dQthAOQ0IojyVT9IUdJguxPvfDSny9aJuEUCY4lXzaZOd+b856I2JIwagI3NaqCvpcdD5KFc6fKTdl3fJFzOTJyaRkbNp/zCWO9rjEESfOY3D90q3xZvKEbaieYkGyXWy0JDGJJnNICZFpIqOAOle5pqN7XRYiFnrdtwpY/o1rKnoe0GagK7t1ZMbvfSHyOhJCAYSuEVIsB11jpHvjCnhl2mr8t/MwVuw4dJa1QuAscfLN4u0YM3cDtse5yhbEFsiHO9pUwe2tqwTUvZg/MgK1yxYxkyeJSaex+YBLIK3dcwTr97peKZCOJSYb15ztnrOJoUBKca/RglTTWJMKo2IxCSSRCQqVBlrfD7QaAOz82yWIVkwE4rcCPz4E/PYGcNEg4IJerrpoQoQ4EkLZECxdLAddY/b+OtYrgx//3YWJS7ZLCKVCQmISvvxrG8b+tgF7DruGwZcsFIW72lbFrRdWRqH8OfdziIoMN5YeTl1QzstKteXAMaw1FqQzsUgb9x9FQmIy/t1+yEyeROcLd4sjdwxS6UKoVDzGBHkL4Re6Xys0dU2dXgL+/gyY9yZwZCfw0yPA72+4LEQcqh8VE+zWCpFtSAjl8Rghz6BpCqFJS3fgsStr58jw/bzCkROnTED5R/M2ud2XDFRm/M9Nzc8zcT+5hXwRFDUUNIWBBmfmJ1EgHUw4y8XGwO0Tp05jxQ5aAw97bYtxTtVKMe4oJQ4pRSCdVzwGkRGKBREe5CvgCq5u2htY+j+XIDq0DZjxODBvBND6AaB5H1f5DyFCDAmhbBk1lvNC6KLqJc3w7l2HTuCXVXtwVcPycDoUpuPnb8LHCzabgGVSqXgB9LukOq69oIJxW+UVKFwoajhdUb+sl0DaFnf8jDhKeaWr7WTSaazcddhMvtaoqiULuoURXWwUXpVLxBghJhwMY4MoeBgn9M8XLqsQXWYznwbmj3S51JrfBeQvHOyWChE6QmjUqFF4/fXXsXv3bjRq1AjvvPMOWrRokeryI0eOxOjRo7F161aULFkS119/PV555RVERwfflx2XklCxeBCEEF0grD/2zqz1JmjayUJo75ET+Oj3Tfjsjy3GnUSqlSqIAe2ro2vD8iFlDeGxnF+yoJkur+c9Em57nMuCtHbvEaxPGepPgXT8VLIZHWePkLNhqoCqJV3JIT2TRVYuUdCIJ+Gw4Gq6xDiajIHVvw0H4jYBvzzrKvbK+KIWdwPR3rFvQuRFgiqEvv76awwePBhjxoxBy5Ytjcjp1KkT1qxZg9KlS5+1/BdffIHHHnsM48aNQ+vWrbF27VrcfvvtZuTUiBEj4MQ8Qp7c0LSSEULz1u83if84yshJ8JjHzt2ArxZtM9YQUrdcESOArqhX1lEBxRTGFDCcOtQt455/+rRlzhNjj+w4pPUpQ/0pGtfsOWImTyLDw4zQqpFiObKDtKuUjMlTVjWRBSLyuRIwNrzJFVD92+vAgfXArBdc+Ygu7A+0vAcoUDTYLRUiy4RZzCIXJCh+mjdvjnfffdd8Pn36NCpVqoT777/fCB5fBgwYgFWrVuHXX391z3vooYfw559/Yt68eRna5+HDhxEbG4tDhw6hSJHAPc3wNNZ86iecSraw4LH2KB8kEXLz2D+wcOMBDO5YEw9cVgNOYPP+Yxg9ZwO+W7rdnH/S5LyiuL99dVxaq7Ry8mQACqSdh46fca95WJCOnnS5Ff2JrSolYrxyINGCRNGkGLUQ5XQysOI74LdhwP61rnn5Y4EL7wVa3utK5ihENpFd/XfQLEKJiYlYsmQJHn/8cfe88PBwdOjQAQsXLvS7Dq1A//vf//DXX38Z99nGjRsxbdo03Hbbbanu5+TJk2byPJHZATsLuxPOyTxCvtzYvKIRQhQGrJNVr3ysSbrIkWSVi8eElFWEw83fm73eJJK0a862qlrCCKBW1UpIAGUC3hcVi8WYieLRU+Az7sxbILlemQdpw75jZpr+n8e2woAqJQq6RrKVOZMHifFNEki5GyYGpWWbbn5mqudI2LiEU4g/5nrPFCFxCZVxyBqOhlG/4dbEr1Hj5DZg7ms4MudtfJJ8OT5KuhJxCC2XGdNrNKpUFE04nVcUjSsVVRb/ECJoQmj//v1ITk5GmTJnzPaEn1evXu13nZ49e5r1LrroIvMHnZSUhHvvvRdPPPFEqvth/NBzzz2HnMohxKHMwRyFdEW9chhRfC22HTyO39ftN5MNh4fTVVQ3RRhRILGDymsBssyVxCzQ0//b7Z53aa1SxgXWtLKeSAMJxSStm5za1TxTy46/P6YgsF1sxr2WkhOJgekb9x8z088r93gJJI5YM7XYjEByudgokHLTyL1QgNeH+ag4YID/TS4RQ4FDQeMSORQ4/EzhY5Y5lmjixzLKUlyAT9EYncIXY2Dkd6gTvhUDIqfgjojp+DT5cnyQ1AUHQ0QQHTp+Cr+t3WcmGw44aHyeLY6KoVbZwnnuv1QE2TW2c+dOVKhQAQsWLECrVq3c8x999FHMnTvXuLt8mTNnDm666Sa8+OKLxq22fv16DBw4EH379sXTTz+dYYsQ3W+BNq0x+V23UfNNeYQFj1+GYCcMXL3rCFbsPGSSLHJiCQ4m8fOFQbC1yxZ2W47skh258cl9yZaDJgZqzpozf0ZX1i+L/pdWV+6kXAL/TvYdOem2IK2ley0lYNt+WPCFhrtKxehicwVq10wRShRIBXMwt1NudlseOZFkBMsZQUPLjEvE+BM0fE1MPvv3nhEYE0ZrBxPD0rpdrKDrlfOKF8yX8t2Z90Wi8yEcp5Fv/XTELHwDkXuXm+1YkTE40bg3jjfvB6ug9wNvXoId5O5DJ7B0a5wrE/y2eJP41Bc+BDeoEGtEUeMUy5FneR6Re11jQRNCdI3FxMRg4sSJ6N69u3t+7969ER8fjylTppy1Ttu2bXHhhReaUWY2dJXdfffdOHr0qHGtBetEzl6zF3eMX2SExI8PtEVug8Os6cKgNcVkoN55CKt2HjbuDX+xHxxlVb98rNt6xFf+4eU0vD0XbDhgLEB0+dmWhW6NK6DfJdVMXIrI/fA67j+aaCxIdhZtOw7Jzu3kD2bN9syBxFdaMXMy+WWgf4e0LvgKGPM+xWLjK2zij58yowCzAh90OIqVAziY36yYx/uzhA2/K5jP1MDLsluZ3Qlrmc19zZW1mkRGA03vcCVnLHImeWhehtdn2XZXeZxl2+KxbGucO0WHJ8xXZosiCiQKJVk/s07IxQhFRUWhadOmJvDZFkIMluZnBkX7IyEh4SyxExHhuqmCGPNt4FNasOOD0htmTdMtp+uannnSZNV0l9XoEFbwdcchHDiWaNwdnL5busO9DeaZcVmNbOtRbKbqcWUGXs9Zq/fi3dnr3bW4OLz7ugsq4t521VClpBK75SXYsfJe4dS6Wkmv7w4cPWNBcr264pAonFgChdNsDysg4YhIVzbtlBgkM6KtUI6KdVpeXTEz3hYa2yrjKWxMvM2xRL+dZUZhDTqXeHGJGZdVxlvYnLHiuN4XyBeRs7Fy3FetK4CanYD1vwJzXwW2LwL+HA0sHudK2NjmQSC2AvIyPL+MpbPj6fhfuunAsZTagS7LEUdf7j58wrjwbTc+HzJpgXfFGRUzr+eXKBhSsZt5kaCOGuPweVqA3n//fRP8zOHzEyZMMDFCjBXq1auXcZ8xzoc8++yzZpj82LFj3a6x++67zwgqbiuYipJZi1+YuhJdG5XHOzc3QV7Fjv0wwmiHSyBRKHHItT/KFMlvLEcURnXLsyp7EdNJZfXPl38o/NOgBchOBGhXgr/74qpBG40nch4KB1qP7OBs+3XvkTOubl+YVNSrFlvKkH8Gu6Z1zzM25iwLjY+7ydv1lGhicLJKkehIb/GSYq3xFDnebql8eTNVAbuXjbOBOa8B2/5wzYuIcg3Jv2gwULQSQrmkz/Lth4zFyOVSi3OX9vFEgdgOdo3ZcOi8nVCxcePGePvtt43IIZdccgmqVKmCjz/+2HxmcPRLL72Ezz77DDt27ECpUqXQtWtXM69o0aJBPZHDZ6wx1oterSrj+W71EWqwU6Aw8XSt0U/u7+7hn7av5YhDqtOqe0WXAUd/jZq93rjw7CfgW1tVxl0XVc02y5PIe1CEuATSmYK1FEh8+k4NCnaKI4p0jvA08TYpsTR8b+edyiy8pX3dTZ7CxtdCw/fs+EIpqWeG4B/F5t9dgmhLSqqT8HxA455A28FAsSpwArsOHXdbjSiQWDfQ372nQGyHCaFQOZFPTlqOz//cioGX1cCgjjXhBI6dTDJB2HbVe77yqd1OI+BbOZ1B2PVtgVShiOmYLFj4dskOUwmebjr7afn2NufjjtZVcryArci7MPaGomi9nSzSBGofwc5DqQskT6Iiwj0EzdkCxrbQGPdUyufC0ZFya2SWzfOAucOATXNdn8MjgUY3AW0fAopXhZNgkWUObFm2TYHYGUFCKJefyH6fL8G05bvx3NX10Lu1M55uUoub4NO5p2uNliQWBvWFMT8cFWSPJipRMAp92p6P2y6sjMJBCMwWoVt017Yg7Yo/gdgCkUbg2ILGiJ6CUcYCqdxTOcjWP1xB1RtmuT6HRQANbwTaPgyUrA6nokDs1JEQyuUn0s7o/NZNjc2IJnEGjnjZtP+oV8wRLUj2j5tui3surmbigEL9hyyE8GHbIlem6nU/uz6HhQP1rwcufhgoVQtOh3GTzMnlijU6E4jtO5LQDsRuX7u0iVXlIIJQ47CEUO4+kVeM/M0UsfysTwu0rXEm8ZzwD287jgZi1uJGlWLzZiCoECJw7PjbVctszbSUGWFAvWuAix8BytQNcuNyZyA2XWnLtsbj761xZw0i4GABFpm+qlF5E6MZChyWEMrdJ7LFS7+YG3Hq/RcpuZ8QQmSVXf+4YohWTz0zr243lyAq2yCYLcu12KVw/tx0AD/+uwtz1+7zitXkaN6rGpZHlwblUKl4DPIqhyWEcu+J5Cms9dR0k8l1/mPtHVf1XQghAs7uFS4L0Uom103ppmpf5RJE5RsHu3W5fuDAz//txg//7sL89fu93GiMKbJFUdnYaOQlJIRy8YnkcNz6Q2eY96uev0JxLkIIESj2rnIJIla9twVR+QuAapcCVS8FKrUAIpVeIzWYsJS52ab+swt/bDrgTnnCcQHNqxQ38UQsVVSyUO4/hxJCufhEbjuYgLbDZpvEf2tevDIg2xRCCOHBvrXA78OB5d8Alsco1HwxQOU2QNVLXOKodF1XLy/OYu/hE5i2fBem/rsLi7fEueeHhwEtzy+By+uVQce6ZVCxWO50n0kI5eIT+e/2eFz97nyT1XZhkAuuCiFESHN4lytb9YbZwMY5wLG93t8XKuMSRbQW8TVE6psFGlYLmPbvLvzw706T2NGTuuWKGEFEYcT3uSWthIRQLj6Rc9bsxe3jF5kbZtrA3FdwVQghQhJ2X3v+cwkiiqPN84Ekn3JApWq7RBGtRbQc5S8UrNbmWrYeSMDPK3dj5so9WLT5IDxH5jPm1YiiumXQ/PziQc1wLSGUi0/k5KU78ODXy9Cmegl8fteFAdmmEEKITJJ0Etj25xlr0c6lZ+KK7LIejCmyLUblmwARQas9nis5eCzRFLxmsPVv6/Z5JcNleRjmKaIwalezlEmIm5NICOXiEzlu3iY8P3UlrmpYDu/2vCAg2xRCCHGOJBwENv12xpUWv8X7+/yxwPltU+KL2rtKfOQSN1Bu4HhiMuat34+ZK3fjl1V7jUiyiYoMR5tqJUw5JIqivCyEJIUDAIs2EtYoEkIIkUuIKQ7U6+6ayMGNLksRRRFrnZ045MpXZOcsij0PqJZiLTq/HVCwBJxMgagIY/3hxCH4TNxIS9HPK/dgy4EEzF6zD0u2xOHfZzshLyMhFEAhxNpFQgghcim0+HBqdidwOhnYuQzYOAvYONdV++zQVuDvT10TM1uXa3gmvqjShUC+vJV3J5BEhIeZ4facnuhcB39tOogeY//A8VPJyOtICAWAuGOuoqHFY1QoVAgh8gThEUDFpq6JSRoTjwFbFqTEF80G9q50ZbnmNH8kEBkNVG59Jr6oTH0gPHiBw8EkLCwMlUuERtkOIiEUAGy/KStYCyGEyINEFQRqdHRN5Mhul6XIji86uhvYMMs1kZiSZ3IX8TW2YlCbL7KOhFAAXWPF5BoTQojQoHBZoFEP18QxRftWnxmNtnkekLAfWDHRNZESNc5ku65yERAduGBekb1ICAUABUsLIUQIw5Fkpeu4plb9gKREYPsil7WIwmjHEuDAOtf011ggjG635mcsRhWaAhEKncitSAidI8w+YMcIFVWMkBBChD6RUUCVNq6p/VPA8Xhg8+9n4os4Om3bH65p7qtAVOGUYfopbrSSNTRMPxchIXSOJCQmm6rzRBYhIYRwIAWKAnW6uiYSt+VMtmvGGR0/CKyZ5ppIkYpnrEUcpl8oZ/LwCP9ICAUoUJoFVwvkU9V5IYRwPMUqA017u6bTp4Hd/5yJL+Iw/cPbgWX/c02kTANX/qLqHYHzL5a1KIeREDpH4hNOuQOlc0thOiGEELkEDrFnKQ9ObQcDiQnA1oUpo9HmAHuWn5kWvONyn3V9yyWmRI4gIXSOHLRHjMktJoQQIj2iYoDql7kmcnSvqwwIh+Wv+NYlkN67ELjsGaDF3a58RyJbcWY2qAASl+IaK15QgdJCCCEySaHSQIPrge7vAffOByq3AU4lANMfA8Z1AvauDnYLQx4JoXNE5TWEEEIEhJLVgd5TgS4jXCPNOER/zEXAnNdcQ/ZFtiAhFCiLkISQEEKIQMQUNe8D9P8TqNEJOH0KmPMyMLYdsH1JsFsXkkgIBSpGSDmEhBBCBIrYCkDPr4HrPgJiSrhqn33UAZjxpKsumggYEkLnSJw9akzB0kIIIQIJRyIzfqj/IqDBjYB1Glj4LjC6tSs/kQgIEkIBC5aWEBJCCJENFCwBXPcB0PMboEgFIG4z8OnVwJQBrqzW4pyQEAqQRUjB0kIIIbKVmpcD/f4Amt/l+rz0M2BUS2DV1GC3LE8jIXSOKFhaCCFEjsGq9l3eAO74CShRHTi6G/j6FmBCL+DInmC3Lk8iIXSOBVfPJFRUsLQQQogconJrV96hiwa7qt2vnAKMagEs+4KdU7Bbl6eQEDoHjp9KRmLSaXeJDSGEECLHyBcNdBgK3D0bKNsQOBEPTL4P+N+1rsKvIkNICAWg4GpUZDhiopQGXQghRBAo1wjoOwvo8CwQkd9VruO9VsAfY4DTycFuXa5HQugciDt2yh0fpIKrQgghgkZEPuCiQcB9C1LKdBwDpg9RmY4MICEUkPIaig8SQgiRS8t0vN8WmDtMZTpSQUIoAEJIOYSEEELkvjIdf7jKdCQnArNfAsZeAuxQmQ5fJIQCECOkQGkhhBC5jtiKPmU6/gM+tMt0JAS7dbkGCaGAlNeQa0wIIURuLtPxF9DgBo8yHa1UpiOFSPuNyDxKpiiEECJPULAkcN2HLjE0ddCZMh2NbwUqNQfCaBcJcwkn9/twj8/w+i7/8WR0Cl+OMIQheZWFCLrjvNaDn22kvEZEAeWbABG5Q4Lkjlbk+WBpCSEhhBB5gJqdXGU6fnkWWPwRsOx/rimTFAPwvt31fZ2FdjS9A+g6ErkBCaFzQMHSQggh8mSZjqtGuFxmiz4ETh13ucxMRmrrzHu+en4mKe8t6zQ27juCI8cTTZWFMJyZwlNeI8PDUCBfGKIjw5A/Igz5+Zp0FGEsCxK3CbkFCaFz4GBKHqFiEkJCCCHyYpmOyq2ztCo9X9UAnD5tYevBBKzefRirdx/B6l1HsGbPEWw+cMylnU54r9c9Yj5G5huFVbuOIP++o6haqhCCjYTQORBv1xlTHiEhhBAOJDw8DFVKFjTTFfXLuecnJCZh3Z6jboG0hiJp9xGcPu76fv/Rk6jMuKJcgITQuRRc1fB5IYQQ4ixioiLRqFJRM3n2m4cX7QWmAVVLFUS5YgWQG5AQOoeCqyftgqtyjQkhhBBpwlJUsdGu/rJC0QJAeO4oTZU77FJ5OIdQVEQ4CqrgqhBCCJEnkRA6xxxCTKaogqtCCCFE3kRC6ByHzis+SAghhMi7SAhlEQVKCyGEEHkfCaFzLa+hQGkhhBAizyIhdI7B0kWVQ0gIIYTIs0gIZRGV1xBCCCHyPhJCWUQxQkIIIUTeR0Ioi8SnuMY4fF4IIYQQeRMJoSwii5AQQgiR95EQyiLKIySEEELkfSSEsoiCpYUQQoi8j4RQFjiemIwTp1RwVQghhMgSloXcgoTQOViD8kWEqeCqEEIIkVEiIl2vm+cB0x4FEg4i2EgInWOgtAquCiGEEBmkegeg9lWAlQz89T7wzgXAn2OB5CQECwmhLKD4ICGEECIL5C8M3PQ50GsKULoucDwO+OkRYEwbYP2vCAYSQllA5TWEEEKIc6DqJcA9vwNdRgAFigP7VgP/uxb4ogewfx0cJYRGjRqFKlWqIDo6Gi1btsRff/2V5vLx8fHo378/ypUrh/z586NmzZqYNm0achIVXBVCCCECEC/UvA/wwFLgwv5AeCSwdjrw3oXA9CeA4/EIeSH09ddfY/DgwRg6dCj+/vtvNGrUCJ06dcLevXv9Lp+YmIiOHTti8+bNmDhxItasWYMPPvgAFSpUCEqMUFHlEBJCCCHOjQJFgSteBvr9AdToBJxOAv4Y5YofWvRRtscPBVUIjRgxAn379sUdd9yBunXrYsyYMYiJicG4ceP8Ls/5Bw8exOTJk9GmTRtjSWrXrp0RUDlJvB0jJCEkhBBCBIaSNYBbJgC3fguUrAUkHAB+HAy83xbYOAchJ4Ro3VmyZAk6dOhwpjHh4ebzwoUL/a7z/fffo1WrVsY1VqZMGdSvXx8vv/wykpOTc7DlwEF3nTEJISGEECLgI8vumw9c+ToQXRTYuxL4tBvwTR+ElBDav3+/ETAUNJ7w8+7du/2us3HjRuMS43qMC3r66afxxhtv4MUXX0x1PydPnsThw4e9pkBZhIopWFoIIYQIPBH5gJZ3u+KHWtwDhEUA62eEZrB0Zjh9+jRKly6NsWPHomnTpujRoweefPJJ41JLjVdeeQWxsbHuqVKlSoHLIySLkBBCCJF9xBQHOg8D7lsAFC4fWkKoZMmSiIiIwJ49e7zm83PZsmX9rsORYhwlxvVs6tSpYyxIdLX54/HHH8ehQ4fc07Zt2wI3akwxQkIIIUT2U7o2UKRCaAmhqKgoY9X59ddfvSw+/Mw4IH8wQHr9+vVmOZu1a9cagcTt+YND7IsUKeI1BSqPkCrPCyGEEHmboLrGOHSew98/+eQTrFq1Cvfddx+OHTtmRpGRXr16GYuODb/nqLGBAwcaAfTjjz+aYGkGT+dkwdXjp1zB2cUKKkZICCGEyMukVD8LDozx2bdvH5555hnj3mrcuDGmT5/uDqDeunWrGUlmw/ieGTNmYNCgQWjYsKHJH0RRNGTIkKAUXC2UP6inTwghhBDnSNB78gEDBpjJH3PmnJ03gG6zP/74A8HCFkJMpqiCq0IIIUTeJk+NGssNxB1zxQcpUFoIIYTI+0gIZZKDbouQ4oOEEEKIvI6EUFbLayiHkBBCCJHnkRDKJEqmKIQQQjg8WJolLj7++GOT84eV4j3z+pBZs2YhVIl35xCSa0wIIYRwpBDikHUKoS5dupjCp04aPeW2CClYWgghhHCmEPrqq68wYcIEdO7cGU7DHj6vGCEhhBDCoTFCLGdRvXp1OBFbCMkiJIQQQjhUCD300EN46623YFkWnJpHSMHSQgghhENdY/PmzcPs2bPx008/oV69esiXzztw+LvvvkPoxwgpWFoIIYRwpBAqWrQorrnmGjiNE6c8C67KIiSEEEI4UgiNHz8eTo4PigwPQ2EVXBVCCCHyPOfUm7Ny/Jo1a8z7WrVqoVSpUnBCfJAKrgohhBAODpY+duwY7rzzTpQrVw4XX3yxmcqXL48+ffogISEBoT90XvFBQgghhGOF0ODBgzF37lz88MMPiI+PN9OUKVPMPI4oC1WUTFEIIYQILbLkGvv2228xceJEXHLJJe55TK5YoEAB3HjjjRg9ejRCueCqhJAQQgjhYIsQ3V9lypQ5a37p0qVD2jV2UDmEhBBCiOBQrHLuEUKtWrXC0KFDceLECfe848eP47nnnjPfhSqKERJCCCGCRNeRucc1xqzSnTp1QsWKFdGoUSMz759//kF0dDRmzJiBUEXlNYQQQojQIktCiBXn161bh88//xyrV682826++WbccsstJk4oVFGwtBBCCBFaZDmPUExMDPr27Qsn4bYIyTUmhBBCOEsIff/997jyyitNXTG+T4urr74aIV1wVRYhIYQQwllCqHv37ti9e7cZGcb3qcGMy8nJrnpcoRssLSEkhBBCOEoInT592u97JxVcTUhMdpfYEEIIIUTeJ0vD5/3B7NKhTHyCyy0WER6GItEquCqEEEI4Vgi99tpr+Prrr92fb7jhBhQvXhwVKlQww+hDfcSYCq4KIYQQDhZCY8aMQaVKlcz7mTNn4pdffsH06dNNMPUjjzyC0C6voRFjQgghRKiQJR8Pg6ZtITR16lRTX+zyyy9HlSpV0LJlS4QiB91D5xUfJIQQQjjaIlSsWDFs27bNvKclqEOHDua9ZVmhO2LM7RqTRUgIIYRwtEXo2muvRc+ePVGjRg0cOHDAuMTI0qVLUb16dYQicSnB0ho6L4QQQjhcCL355pvGDUar0LBhw1CoUCEzf9euXejXrx9CEZXXEEIIIUKPLAkhZpd++OGHz5o/aNAghCpngqUlhIQQQohQQSU2MsjBFNeYgqWFEEKI0EElNjIZLF1cBVeFEEKIkEElNjJZZ0zlNYQQQojQIWAlNkIdt0VIQkgIIYRwthB64IEH8Pbbb581/91338WDDz6IUONkUjKOpRRcVYyQEEII4XAh9O2336JNmzZnzW/dujUmTpyIUEMFV4UQQojQJEtCiEkUY2Njz5pfpEgR7N+/H6GbQyifCq4KIYQQThdCzB7N0hq+/PTTT6hatSpCNT5IgdJCCCFEaJElP8/gwYMxYMAA7Nu3D+3btzfzfv31V7zxxhsYOXIkQra8hoSQEEIIEVJkSQjdeeedOHnyJF566SW88MILZh5LbowePRq9evVC6FaeVw4hIYQQIpTIcuTvfffdZyZahQoUKOCuNxaKxKvOmBBCCBGSZDmPUFJSEn755Rd89913sCzLzNu5cyeOHj2K0LUISQgJIYQQcLpFaMuWLbjiiiuwdetW4yLr2LEjChcujNdee818HjNmDEIJJVMUQgghQpMsWYQGDhyIZs2aIS4uzrjFbK655hoTNB2qwdJFYxQjJIQQQsDpFqHff/8dCxYsQFSUt4WEAdM7duxAqNYZKy7XmBBCCBFSZMkixKKr/irMb9++3bjIQjWhovIICSGEEKFFloTQ5Zdf7pUviNmWGSQ9dOhQdO7cGaFaYkMWISGEECK0yJJrbPjw4SZYum7dujhx4gR69uyJdevWoWTJkvjyyy8RSiQmncbRk0nmvYKlhRBCiNAiS0KoUqVK+Oeff/D111+bV1qD+vTpg1tuucUreDoUiE+JDwoPAwqr4KoQQggRUmS6Zz916hRq166NqVOnGuHDKZRx5xCKiUI41ZAQQgghnBsjlC9fPuMOcwruyvOKDxJCCCFCjiwFS/fv398kT2R26VDHDpQuphxCQgghRMiRpaCXRYsWmcSJP//8Mxo0aICCBQt6fc+yGyFnEVKgtBBCCBFyZEkIFS1aFNdddx2cgLu8hlxjQgghhLOFEBMpvv7661i7di0SExPRvn17PPvssyE3Usx/eQ0JISGEEMLRMUIvvfQSnnjiCRQqVAgVKlTA22+/beKFQpkz5TUUIySEEEI4Wgh9+umneO+99zBjxgxMnjwZP/zwAz7//HNjKQpVVF5DCCGECF0yJYS2bt3qVUKjQ4cOprzGzp07EarYCRWVVVoIIYRwuBDicPno6Oiz8goxyWLIJ1RUsLQQQgjh7GBpy7Jw++23I3/+/O55TK547733eg2hD6Xh8/HHlEdICCGECFUyJYR69+591rxbb701kO3JdQVXj9gFV2UREkIIIZwthMaPH58tjRg1apQZlr979240atQI77zzDlq0aJHuel999RVuvvlmdOvWzQRvZ2fB1SLRsggJIYQQoUaWSmwEElawHzx4MIYOHYq///7bCKFOnTph7969aa63efNmPPzww2jbtm2O5BBSwVUhhBAi9Ai6EBoxYgT69u2LO+64A3Xr1sWYMWMQExODcePGpbpOcnKyqXr/3HPPoWrVqjlQXkPWICGEECIUCaoQYnbqJUuWmGH47gaFh5vPCxcuTHW9559/HqVLl0afPn1yJJmi6owJIYQQoUmWao0Fiv379xvrTpkyZbzm8/Pq1av9rjNv3jx89NFHWLZsWYb2cfLkSTPZHD58OPNCSIHSQgghREgSdNdYZjhy5Ahuu+02fPDBByhZsmSG1nnllVcQGxvrnipVqpT5gquyCAkhhBAhSVAtQhQzERER2LNnj9d8fi5btuxZy2/YsMEESXft2tU9zy7vERkZiTVr1qBatWpe6zz++OMmGNvTIpRRMeQOlladMSGEECIkCaoQioqKQtOmTfHrr7+ie/fubmHDzwMGDDhr+dq1a2P58uVe85566iljKXrrrbf8Chwmf/RMAJkZZBESQgghQpugCiFCaw0TNTZr1szkDho5ciSOHTtmRpGRXr16mUr3dHGxvEf9+vW91i9atKh59Z0fCFReQwghhAhtgi6EevTogX379uGZZ54xCRUbN26M6dOnuwOoWeiVI8mCge0a06gxIYQQIjQJs1hAzEEwRohB04cOHUKRIkXSXPbiYbOx9WACvr2vFZpWLp5jbRRCCCFE1vvvkB01ltPYMULMLC2EEEKI0ENCKBVOJXsUXJUQEkIIIUISCaF0kimagqsFNHxeCCGECEUkhFIhPiVQOrZAPkSo4KoQQggRkkgIpVdwVUPnhRBCiJBFQigVlExRCCGECH0khNIrryEhJIQQQoQsEkLpBEsXV50xIYQQImSREEoFxQgJIYQQoY+EUDoWIZXXEEIIIUIXCaFUULC0EEIIEfpICKXCQXewtGKEhBBCiFBFQigV4t3B0rIICSGEEKGKhFAqKFhaCCGECH0khFIruHrCVXBVwdJCCCFE6CIhlEadsbAwV60xIYQQQoQmEkJpDJ0vqoKrQgghREgjIZTG0Hm5xYQQQojQRkIorWSKCpQWQgghQhoJIT8cPOaKESqmHEJCCCFESCMh5AeV1xBCCCGcgYRQWuU15BoTQgghQhoJIT/EuctrSAgJIYQQoYyEUBquseIFFSMkhBBChDISQmmV15BFSAghhAhpJITSKLiq4fNCCCFEaCMh5AdZhIQQQghnICHkQ1LyaRxOKbiqUWNCCCFEaCMh5EP8cRVcFUIIIZyChFAqOYQoglRwVQghhAhtJIR8UHyQEEII4RwkhFJJpqg6Y0IIIUToIyGUajJFWYSEEEKIUEdCKBUhpPIaQgghROgjIeSDCq4KIYQQzkFCyIeDx+wYIQkhIYQQItSREEqtvIaCpYUQQoiQR0LIh4OqMyaEEEI4BgmhVGKE5BoTQgghQh8JoVTyCBUvKNeYEEIIEepICPkUXD2UUmtMFiEhhBAi9JEQ8sAWQUQFV4UQQojQR0LITzJFiqDICJ0aIYQQItRRb+8nh5CSKQohhBDOQELIb3kNucWEEEIIJyAh5K+8hgKlhRBCCEcgIeSBkikKIYQQzkJCyIP4lBxCKq8hhBBCOAMJIQ8O2lmlZRESQgghHIGEkAcqryGEEEI4CwkhP6PGJISEEEIIZyAh5LfOmISQEEII4QQkhPxahBQsLYQQQjgBCSF/BVdlERJCCCEcgYRQChRBluV6X1QFV4UQQghHICHkEx9UJDpSBVeFEEIIh6Ae3yc+SIHSQgghhHOQEPJJplhUQ+eFEEIIxyAhlEK8LEJCCCGE45AQSuHgMbvOmISQEEII4RQkhHwsQsohJIQQQjgHCaEUVHBVCCGEcB4SQilo1JgQQgjhPHKFEBo1ahSqVKmC6OhotGzZEn/99Veqy37wwQdo27YtihUrZqYOHTqkuXxm8wjJNSaEEEI4h6ALoa+//hqDBw/G0KFD8ffff6NRo0bo1KkT9u7d63f5OXPm4Oabb8bs2bOxcOFCVKpUCZdffjl27NhxTu2Is11jCpYWQgghHEOYZdmFJYIDLUDNmzfHu+++az6fPn3aiJv7778fjz32WLrrJycnG8sQ1+/Vq1e6yx8+fBixsbE4dOgQihQp4p7f+PmfEZ9wCjMHXYwaZQqf41EJIYQQIpCk1n/naYtQYmIilixZYtxb7gaFh5vPtPZkhISEBJw6dQrFixfPcjuST1vugqtKqCiEEEI4h8hg7nz//v3GolOmTBmv+fy8evXqDG1jyJAhKF++vJeY8uTkyZNm8lSUaRZcVYyQEEII4RiCHiN0Lrz66qv46quvMGnSJBNo7Y9XXnnFmNLsiW631IbOF46ORD4VXBVCCCEcQ1B7/ZIlSyIiIgJ79uzxms/PZcuWTXPd4cOHGyH0888/o2HDhqku9/jjjxt/oj1t27btrGVUXkMIIYRwJkEVQlFRUWjatCl+/fVX9zwGS/Nzq1atUl1v2LBheOGFFzB9+nQ0a9YszX3kz5/fBFV5TqkmU1R8kBBCCOEoghojRDh0vnfv3kbQtGjRAiNHjsSxY8dwxx13mO85EqxChQrGxUVee+01PPPMM/jiiy9M7qHdu3eb+YUKFTJTVuBoMaIcQkIIIYSzCLoQ6tGjB/bt22fEDUVN48aNjaXHDqDeunWrGUlmM3r0aDPa7Prrr/faDvMQPfvss1lqw0G7zphcY0IIIYSjCLoQIgMGDDBTagkUPdm8eXPA928nUywu15gQQgjhKDREyqPOmCxCQgghhLOQEDLB0naMkISQEEII4SQkhDwtQgqWFkIIIRyFhJBcY0IIIYRjkRDyDJaWEBJCCCEcheOFkHfBVbnGhBBCCCfheCF0+PgpnE4puKpgaSGEEMJZOF4I2ckUVXBVCCGEcB6O7/ntgquyBgkhhBDOw/FCyJ1DSIHSQgghhONwvBA6U15DgdJCCCGE05AQkmtMCCGEcCyOF0KqPC+EEEI4F8cLIds1pvIaQgghhPOIhMOJS/AfLJ2cnIxTp1zfCSGcRVRUFMLDHf+cKIQjkBByB0u7hJBlWdi9ezfi4+OD3DIhRLCgCDr//PONIBJChDYSQikxQkVThJAtgkqXLo2YmBiEhYUFuYVCiJzk9OnT2LlzJ3bt2oXzzjtP/wFChDgSQimuMRZcpTvMFkElSpQIdtOEEEGiVKlSRgwlJSUhXz7FDwoRyjjaCX76tHUms3TBfO6YIFqChBDOxXaJ8eFICBHaOFoIHT5xpuBq0QJnYgFkChfC2eg/QAjn4GghdDAlULpw/khERebtU3HJJZfgwQcfPOftTJ48GdWrV0dERERAtpdZxo4di0qVKplg1ZEjR+LZZ59F48aNkVf4+OOPUbRo0WA3QwghRAbJ271/oAKlCyoGwOaee+7B9ddfj23btuGFF17I0X0fPnwYAwYMwJAhQ7Bjxw7cfffdePjhh/Hrr7/mGbHSo0cPrF27Fk6EIy6feeYZlCtXDgUKFECHDh2wbt26dNfjtb711ltNXB7Xa9CgARYvXuz+/vbbbzcWGs/piiuu8NrG1VdfbQKbo6Ojzf5vu+02E+Njc+LECbMdbjsyMhLdu3cP8NELIfIqzhZCKQVX7aHzTufo0aPYu3cvOnXqhPLly6Nw4cJZ2k5ioktgZpatW7eaOK0uXbqYzoyxWoUKFcpTgevsyBls70SGDRuGt99+G2PGjMGff/6JggULmnuJIiQ14uLi0KZNGxOQ/NNPP2HlypV44403UKxYMa/lKHw4isuevvzyS6/vL730UkyYMAFr1qzBt99+iw0bNhhBb8NYH16bBx54wAg0IYRwYzmMQ4cOMSrIvH69aKtVechUq/e4P813x48ft1auXGle8xrt2rWz+vfvb6YiRYpYJUqUsJ566inr9OnT7mVOnDhhPfTQQ1b58uWtmJgYq0WLFtbs2bPNd3zlefGc7O8mTpxo1a1b14qKirIqV65sDR8+3GvfnPf8889bt912m1W4cGGrd+/eZv7vv/9uXXTRRVZ0dLRVsWJF6/7777eOHj3qt/3jx48/a/+bNm2yhg4dajVq1Mi9HLfdrVs36/XXX7fKli1rFS9e3OrXr5+VmJiY5ePkPgjfT5o0yatdsbGxpm2E7eEy3377rXXJJZdYBQoUsBo2bGgtWLDA6zi4jo3d/k8//dScJ16bHj16WIcPH3Yvw/c9e/Y0beUxjRgxwlzPgQMHpnq9169fb1199dVW6dKlrYIFC1rNmjWzZs6c6bVMesdDtm3bZt10001WsWLFzP6bNm1q/fHHH1Zm4X3GtvO62MTHx1v58+e3vvzyy1TXGzJkiLlH0sK+5plhypQpVlhYmNd9kZnt5eX/AiGc0H8HEkdbhNwjxtKwCLE/SUhMCsrk6ssyzieffGLM/n/99RfeeustjBgxAh9++KH7e7qdFi5ciK+++gr//vsvbrjhBvOkTfdF69atzdM04RM1n7o5b8mSJbjxxhtx0003Yfny5SZm5+mnnzbuJU+GDx+ORo0aYenSpeZ7PpFz29ddd53Z19dff4158+aZNqTmUvrll1/Me7af+2eskD9mz55tts9XHjPb4tme9I6TsUdFihRxWxfofssMTz75pFln2bJlqFmzJm6++WYzzDo12FbGXk2dOtVMc+fOxauvvur+fvDgwZg/fz6+//57zJw5E7///jv+/vvvdK13nTt3Nm5DnnMeX9euXY1VLaNwG+3atTOuKe77n3/+waOPPmry6BC2gxa5tKbPP//cLLtp0yaTg8vT2hIbG4uWLVuaa5Ea3G+zZs3MNaIlrUmTJvjggw/OWm7OnDnm+1q1auG+++7DgQMHUt3mwYMHTbt4rTX0XQiRHo7OI3QwxTWWlhA6fioZdZ+ZgWCw8vlOiInK+CWicHjzzTdNDAU7DAoXfu7bt6/pIMePH29e6fYi7MynT59u5r/88stul07x4sVRtmxZ855i6rLLLjPihrDjp/vi9ddfNzEXNu3bt8dDDz3k/nzXXXfhlltucQdc16hRw7hN2PGOHj3axHJ4QreF7QJjDhd7//6g2+Tdd981Ad21a9c2rjQKgoweJztonqO09pEW3B73SZ577jnUq1cP69evN23xB4UFhZrtamT8Ctv70ksv4ciRI0bMffHFF+Y8E7bTbntqUHRysmE816RJk4ywSE1s+sJ97tu3D4sWLTLXnDBQ3oYChWIvLcqUKWNeKYI8P3t+b3/nj40bN5r7gWLwiSeeMG2h+4rD13v37m2Woci79tprTaZnikoud+WVVxqBxXvAhrFlvC8SEhJw4YUXGtEphBDp4Wgh5C6vESLB0vzz9xz226pVKxNvwfgIiiK+Ush4cvLkyTRjcFatWoVu3bp5zWNMB60q3J7dEbHT9ITWBVpjbIsBoYWLooDWgzp16mT5OCk8PDtAxhPx+EhWjzMzNGzY0GvfhLFVqQmhKlWqeMVbcR0ubwsBxkW1aNHC/T2FGoVsetYcWud+/PFHY9WiRer48eOZsghR5NACY4sgXyhOPYVRdsD7gfcOBSphe1asWGHijGwhRGukDYOdef6rVatmrES2eCSPPPII+vTpgy1bthiB2qtXLyOGNBReCJEWzhZCPuU1/FEgX4SxzAQD7jtQsOOkeKCry1NEELo4zhUGxvrujyPQ+HTvC0f3nAu+7g52dLY751yOk9vxdUf6K7zruX+7k7X3n9n2ZhVapehGo0uSYoWihcHBnoHq6R0P10kLusZoeUmL999/31j+bOvanj173OLQ/pxW+gMuW7duXa95FMl0z6ZG1apVUbJkSWOF8xRCnMeJIpjboIX0jz/+MA8EQgiRGhJCKeU1UoOdSWbcU8GEI3U8YSdAlxQFAZ+0aSmhJaJt27YZ3iY7FMaveMLP7Gx8hYYnF1xwgXGhZbdFwZeMHCfdLv4yBtMlR+uKDWOK6GbJTtipUyjRJWQLxEOHDpkh+BdffHGq6/Ea0DV5zTXXuAXg5s2bM3U8tKwwhowxNf6sQplxjdFtRTFEl58tfJgOgfckY3pSg9ZFOzbNhsdeuXLlVNfZvn27iRHyFFy+2EKTlkAhhEiLvNHDZ3NCxbRihPISdIsw1oKWGAbbvvPOO8Y1Rihc+OROdwHnUTAwPoQdFztEO+bFF8b9NG/e3MSgMKCZcRmMw3jvvffSbAvjNeiqY7wK44VoMaIwohWD62cXGTlOuqooHDiPcTYcps+JcU5sGy0IFEo8huwOtqXLjC4gunUoRhinNXToUJNQMi2XDgXud999ZwKkuRxjuHytTOkdD4O86ZJiTp1XXnnFCAsGXjM+ietkxjXGNjAe7MUXXzRtozBim7gtz5w9tOBQvNlxTIMGDTJBzWwHg/IZKM+kmpwIrxPdXAy6p9BijBADutkuDs0nFFsUkhdddJGJH+My3DfdZ57WIN5/tJhR+DE2yxZ5eSlhpxAi8Dh81FhKsHSIxAix82ecCONN+vfvj4EDB5qkhDYMwuUyFDeMQWEH5WmJSM2yw/wsHIFVv359kzDv+eef9wqU9gdFB0dH8emelhkKEq6bXhBwIEjvONnx3nvvvUbY0WrC/DeEwonuFLa3Z8+exv2UE3XnGJDODvuqq64yo65oJaElzjeg3Hcddvo8FoohigJeK0/SOx5axn7++WcjvjgCjfE3HM2WlqUvLShQ7r//fnPPUTxTxDBI3fM4KFL279/v/szlGOTNvEC8vyi4GX9GMUvYFsaaMWEiRS5jgJo2bWrcdvnz5zfL8JgoCimyeL25jH3/2csQHiPvwx9++MHEF/E9JyGEswnjGHo4CJrrGYwaFxePC16bZ2qN/fXEZShdJNokfmMgL59m0+qEhMhOjh07hgoVKhghw05d5Dz6LxAi9/bfDB9gCpRA4VjXmFfB1RBxjYm8Cd1Rq1evNpY8/sBpcSO+o/WEEEIEHscKofjjLrdYoRAouCryPhz9xaBhuqts1w9HQAkhhMheIp2eQyhU4oNE3oVxKhzuL4QQIudxrCnkUIpFKFRGjAkhhBAi8zhWCLktQhJCQgghhGNxrBCKP55+MkUhhBBChDbOFUIJrmrhRWMUIySEEEI4FQcLoRSLkFxjQgghhGNxrBByF1yVa0wIIYRwLI4VQodSXGNOsggxaR/rfzFTbk7VV2JxUJZuYI0rlrpgaQPWpYqPj0degIVM2d70io8KIYTImzhWCMUdd14eIRbzZPFTJu5jwdGPP/4YRYsWzdZ9sggsRRfLFXB/rI3FiuhMk54XxAprdbG9rIPlRL755hvUrl3biGcK2mnTpqW7Diu+P/nkk6aCPGt9scjtuHHj3N9/8MEHpv4Za6VxYn01Flv1ZM+ePaaeHWvTsZbYFVdcgXXr1vndH6sEXXnlleYemDx5cgCOWgjhJBwrhA4lOG/4PAteskI3O6gSJUoEbLusbO5b+dxzn6yCXrFiRSO6mDmZVcTTqqyem2DRT7Y3MtJ5uUcXLFhgKtSz3hnLgNCix2nFihVprscq8hTaH330kRHdLKjKYqg2tApyu7Nnz8bChQuN2Lz88suxY8cOt7DhfjZu3IgpU6aYffOepWBiHTZfWKQ1r9xPQohciOUwDh06xApjVpXB31iVh0y1dh867v7u+PHj1sqVK81rXuOnn36y2rRpY8XGxlrFixe3unTpYq1fv979PY/Zc2rXrt1Z84YOHWqWPXHihPXQQw9Z5cuXt2JiYqwWLVpYs2fPdm9r/PjxZj9Tpkyx6tSpY0VERFibNm3yag8/+26f63E7fB8XF+e1renTp1u1a9e2ChYsaHXq1MnauXOn1/Y++OAD833+/PmtWrVqWaNGjUrz2AhfBw4c6LWdbt26Wb1793Z/rly5svXSSy9Zd9xxh1WoUCGrUqVK1vvvv3/WcSxdutR8ttv/yy+/WE2bNrUKFChgtWrVylq9erXXfl544QWrVKlSZpt9+vSxhgwZYjVq1CjV65eUlGTdeeedVpUqVazo6GirZs2a1siRI72Wycjx8No9+uijVsWKFa2oqCirWrVq1ocffmhlhRtvvNHcR560bNnSuueee9K8D3k9Dxw4kOH98NgLFy5sffLJJ+bzmjVrzDlesWKFe5nk5GRzPnkfeMLrUqFCBWvXrl1mnUmTJlmBIC//FwgR6v33oUOHArpdx1qEklMqrqY7fJ79bOKx4Eymj88YfFKmG2rx4sXmaTw8PBzXXHON21JD9069evXw0EMPmffff/+9eZJmBV9+5vTwww+bZQcMGGCe1L/66iv8+++/uOGGG85yTSQkJOC1117Dhx9+iP/++w+lS5f261Li9rkfvu/Ro4fftnNbrLX12Wef4bfffsPWrVvdbSGff/45nnnmGbz00ktYtWoVXn75ZTz99NP45JNPzPe2W+WXX34x+/nuu++QGVjlvVmzZsby0K9fP9x3333GkpEWdP1wPZ5vWovuvPNOr/ayrTw/LJ1x3nnnYfTo0Wluj9eJVjO6olauXGmO94knnsCECRMydSy9evUyFpi3337bnKv3338fhQoVcn/P92lN9957r3tZ3gO0wnjSqVMnMz81eF/xXA4bNgwVKlRAzZo1zbU8fvx4quvw+p86dQrFixd3u9aIZ9V33s90s82bN89rvZ49e2LUqFHGaieEEFnBefZ+DwpGRSB/ZETaC51KAF4uj6DwxE4gqmCGFr3uuuu8PjMmo1SpUqZTZXyL7d5hZ2d3GozToUvBsxOhCBk/frx5ZXwGYUc2ffp0M58ihLDjeu+999CoUaM0XUrcPveTVkfFbY0ZMwbVqlVzCzG7Arsd20TRce2115rP559/vjkudvK9e/c2x0no7stKh9i5c2cjgMiQIUPw5ptvGreNpzvHFwqddu3amfePPfYYunTpghMnTpjO+5133jHupDvuuMN8T1Hz888/4+jRo6luj8Hkzz33nPszj5GCg0KIrqaMsHbtWrP8zJkz3QKmatWqXsukF0dF4Wqze/dulClTxut7fub81KA7i2KF52HSpEnYv3+/ObcHDhww948/eM55r9ltZkwSxePjjz9urjHj2nhNtm/fboSuzaBBg0zMWbdu3dI8JiGESAtHC6FiITR0ntYadrh//vmn6XxsSxAFTWYCfZcvX25ifvgk7wmf0j3jihjr07Bhw4C0ncGwtggi5cqVw969e92WLsYZUVj07dvXvUxSUlLAAq49j8MWhvb+M7IO20u4DjtwWpNsYWXTokULzJo1K81t0rJBActrRgtKYmJipkb3UeRQgNoCzR/Vq1dHdsL7jueQVjH7+owYMQLXX3+9Ec4FChTwWv7VV181lkfGDdkWIIpCWvV4zWkl4jFRJDEg2uUJdVmeeD5pxRNCiHPB0UIoQ+U18sW4LDPBgPvOIF27djUBpRyRw6drdkgUQOxMMwOtFux46NLhqyeeLhZ2aIEKUGXH5wm3a3d4thWFx9WyZUuv5Xzb5wvdKfZ2PK1PGdl/asHf/taxz0N666QFxQAtb7R8tWrVCoULF8brr79uhG1Gj8dXZPjD8xr649ZbbzXWOUJByNFbnvBzWlY3ikK6xDxFap06dUy7adGpUaOGez7doRRCdGn6iuqmTZsaYXfo0CFzD9Pqx+tPtxuhCKJA9h31SMsoR6RRWAkhREZwtBAqmpERY+zkMuieChZ0O9AKYQ9LJp6xFKlBqw6tP540adLEzKN1w95WMKErhsKOLpdbbrkl1eMgvsfCztPTlcLvOeLp0ksvzdY206W2aNEiE69jw8/p5Vuim8fTksSOPjPHw+HtFGNz5849K7YnK64xCjLGmz344IPueXS7cX5qtGnTxsQ5UcDaoosuO4o4xkDZMIaI7sUZM2a4xY0/bEFFiyfjsV544QW3O/Kuu+7yWpbHTxcaHwqEECKjOFoIFQ+ROmPMxUK31dixY80TOV0r7CjSg/ld2GGxs2OsD11UdIlRcLATp3WCwmjfvn1mGT61MxYmp2HszAMPPGA6RQZt003HTjEuLs4EiDNQm9YQxjGxs6WLhcty2D6///HHH43rjS6anEjkeP/99xs3Hjt4ipuvv/7aBJ37xut4QkvJp59+aoQB44MYOE7xxPc26R0Prydjphi4zWBpXtMtW7YYUWvHGWXGNTZw4EDjZuN9wOtOqxXPO+8zG8bxcNg7204YvEyxwvgoXje6aR955BHTJttixSByunG/+OIL02Y75sgO2CYUUxR+dDXSXcu2cEg9h9kTWqX8Waa4vOc5E0KI9HDsqLEMW4TyAHzaZidFdxbdYQwipVslPdhJc5QQR3Ox0+FTOmFQK4UQR5jRusEOiJ0yO5lgwCd/jk5ju/jUz86ZyRntDo9B4Oz4GVhL65EdPMvOl8KAx8J1KESy2xpEKCQpEOjquuCCC0wySSYH9BwF5cs999xjgsF5LegCopXPN84oI8fD0WmMx+G6DDqmIPOXeycj8P6gWKHwoaiaOHGiSVjoGXNGCxWFtw2FDK1GFGgUgjwXtNDw+ni2ke4utpPC3Z7oKvPc7m233WaOgSKY7zkaTgghAk0Yx9DDQRw+fNhYCyo9OAEPX9UYD1x2JmaBo37YabGDTavTEiKzdOzY0VgwaOkRuR/9FwiRe/tvxg56uvHPFUe7xkJp1JjIPTC/DQOOmXOHAd20ZDAgmJYSIYQQuQtnC6EQiRESuQuOImNNLgYD07JA9+K3336bagCzEEKI4OFoIeSkyvMi52BQMC1AQgghcj+ODpaWa0wIIYRwNs4WQrIICSGEEI7G0UIotYKrDhtIJ4TwQf8BQjgHxwqhAlHhiM4X4bdsAkf9CCGci12aJr0yLkKIvI9jg6WLFjjbLcY/PdYusgtuMtNyoOppCSHyBixTwmzq/P0zWacQIrRx7K88tfggO21/etXHhRChC7O1M5O6HoSECH0cK4RiU4kP4h8f0/2zfpW/SuVCiNCHhXwphoQQoU+uEEKjRo0ytbFYfJE1jd555x20aNEi1eVZkPHpp5/G5s2bTbFKFnHs3LlzQJMp0k2m+AAhhBAitAn6Iw8rc7Oi9tChQ/H3338bIcTSBKm5phYsWICbb74Zffr0wdKlS01BUE4rVqzI1H41dF4IIYQQQS+6ykrbzZs3x7vvvusOVKxUqRLuv/9+PPbYY2ctz+rcrKY9depU97wLL7wQjRs3NvWdMlq07dXJf2NItyYBPhohhBBC5KWiq+HBHqK6ZMkSrxpM9Mvz88KFC/2uw/m+NZtoQUpt+dQoVjBXeAWFEEIIEUSCqgb279+P5ORklClTxms+P69evdrvOowj8rc85/vj5MmTZrKhkiT5TicadSmEEEKI3I/dZwfakRXyZpFXXnkFzz333Fnz7+zUDHcGpUVCCCGEyCoHDhwwLrKQEEIlS5Y0I7P27NnjNZ+f7Xw+vnB+ZpZ//PHHTTC2TXx8PCpXroytW7cG9ESKrKl7xoNt27YtoP5ekTV0PXIPuha5B12L3AM9OszvVbx48YBuNzLYuTqaNm2KX3/91Yz8soOl+XnAgAF+12nVqpX5/sEHH3TPmzlzppnvj/z585vJF4og3dS5A14HXYvcg65H7kHXIvega5F7CHSOr6C7xmit6d27N5o1a2ZyB40cOdKMCrvjjjvM97169UKFChWMi4sMHDgQ7dq1wxtvvIEuXbrgq6++wuLFizF27NggH4kQQggh8hpBF0IcDs+6Ps8884wJeOYw+OnTp7sDounC8lR/rVu3xhdffIGnnnoKTzzxhEmoOHnyZNSvXz+IRyGEEEKIvEjQhRChGyw1V9icOXPOmnfDDTeYKSvQTcbkjf7cZSJn0bXIXeh65B50LXIPuhahfy2CnlBRCCGEEMKxJTaEEEIIIYKFhJAQQgghHIuEkBBCCCEcS0gKoVGjRqFKlSqIjo42RV3/+uuvNJf/5ptvULt2bbN8gwYNMG3atBxra6iTmWvxwQcfoG3btihWrJiZWFMuvWsnsve3YcM0FWFhYe58XyLnrwWTwfbv3x/lypUzwaI1a9bUf1WQrgXTvNSqVQsFChQwyRYHDRqEEydO5Fh7Q5XffvsNXbt2Rfny5c3/DUeEpwcHVF1wwQXmN1G9enV8/PHHmd+xFWJ89dVXVlRUlDVu3Djrv//+s/r27WsVLVrU2rNnj9/l58+fb0VERFjDhg2zVq5caT311FNWvnz5rOXLl+d4251+LXr27GmNGjXKWrp0qbVq1Srr9ttvt2JjY63t27fneNtDkcxeD5tNmzZZFSpUsNq2bWt169Ytx9obymT2Wpw8edJq1qyZ1blzZ2vevHnmmsyZM8datmxZjrfd6dfi888/t/Lnz29eeR1mzJhhlStXzho0aFCOtz3UmDZtmvXkk09a3333HQdxWZMmTUpz+Y0bN1oxMTHW4MGDTf/9zjvvmP58+vTpmdpvyAmhFi1aWP3793d/Tk5OtsqXL2+98sorfpe/8cYbrS5dunjNa9mypXXPPfdke1tDncxeC1+SkpKswoULW5988kk2ttI5ZOV68Bq0bt3a+vDDD63evXtLCAXpWowePdqqWrWqlZiYmIOtdAaZvRZctn379l7z2BG3adMm29vqJJABIfToo49a9erV85rXo0cPq1OnTpnaV0i5xhITE7FkyRLjUrFhMkZ+Xrhwod91ON9zedKpU6dUlxfZdy18SUhIwKlTpwJeV8aJZPV6PP/88yhdujT69OmTQy0NfbJyLb7//ntTRoiuMSabZQLZl19+GcnJyTnY8tAjK9eCSX25ju0+27hxo3FRdu7cOcfaLQLbf+eKhIqBYv/+/eaPwc5KbcPPq1ev9rsOs1n7W57zRc5eC1+GDBlifMW+N7rImesxb948fPTRR1i2bFkOtdIZZOVasLOdNWsWbrnlFtPprl+/Hv369TMPCkwwJ3LuWvTs2dOsd9FFF9GjgqSkJNx7772m0oHIWVLrv1ko9/jx4yaGKyOElEVIhA6vvvqqCdCdNGmSCWAUOcuRI0dw2223mQD2kiVLBrs5jofFqGmZY01FFqpmaaInn3wSY8aMCXbTHAeDc2mNe++99/D333/ju+++w48//ogXXngh2E0TWSSkLEL8w46IiMCePXu85vNz2bJl/a7D+ZlZXmTftbAZPny4EUK//PILGjZsmM0tdQaZvR4bNmzA5s2bzQgOz86YREZGYs2aNahWrVoOtDz0yMpvgyPF8uXLZ9azqVOnjnkipnsnKioq29sdimTlWjz99NPmIeGuu+4ynznSmIXC7777biNOA10ZXaROav13kSJFMmwNIiF1xfhnwKelX3/91evPm5/pX/cH53suT2bOnJnq8iL7rgUZNmyYebJi4d1mzZrlUGtDn8xeD6aTWL58uXGL2dPVV1+NSy+91LznkGGRc7+NNm3aGHeYLUbJ2rVrjUCSCMrZa8HYRV+xYwtUVazKWQLWf1shOBSSQxs//vhjM5zu7rvvNkMhd+/ebb6/7bbbrMcee8xr+HxkZKQ1fPhwM2R76NChGj4fpGvx6quvmmGsEydOtHbt2uWejhw5EsSjcO718EWjxoJ3LbZu3WpGUA4YMMBas2aNNXXqVKt06dLWiy++GMSjcOa1YB/Ba/Hll1+a4ds///yzVa1aNTMCWZwb/K9n+hROlCcjRoww77ds2WK+53Xg9fAdPv/II4+Y/pvpVzR8PgXmEjjvvPNMp8qhkX/88Yf7u3bt2pk/dE8mTJhg1axZ0yzPoXg//vhjEFodmmTmWlSuXNnc/L4T/3hEcH4bnkgIBfdaLFiwwKT2YKfNofQvvfSSSW8gcvZanDp1ynr22WeN+ImOjrYqVapk9evXz4qLiwtS60OH2bNn++0D7PPPV14P33UaN25srh1/F+PHj8/0flV9XgghhBCOJaRihIQQQgghMoOEkBBCCCEci4SQEEIIIRyLhJAQQgghHIuEkBBCCCEci4SQEEIIIRyLhJAQQgghHIuEkBBCCCEci4SQEEIACAsLw+TJk817FpzlZ9ZVE0KENhJCQoigc/vttxvhwYlV1s8//3w8+uijOHHiRLCbJoQIcSKD3QAhhCBXXHEFxo8fj1OnTmHJkiXo3bu3EUavvfZasJsmhAhhZBESQuQK8ufPj7Jly6JSpUro3r07OnTogJkzZ5rvTp8+jVdeecVYigoUKIBGjRph4sSJXuv/999/uOqqq1CkSBEULlwYbdu2xYYNG8x3ixYtQseOHVGyZEnExsaiXbt2+Pvvv4NynEKI3IWEkBAi17FixQosWLAAUVFR5jNF0KeffooxY8YYwTNo0CDceuutmDt3rvl+x44duPjii42YmjVrlrEo3XnnnUhKSjLfHzlyxFiY5s2bhz/++AM1atRA586dzXwhhLORa0wIkSuYOnUqChUqZMTLyZMnER4ejnfffde8f/nll/HLL7+gVatWZtmqVasaUfP+++8b686oUaOMpeerr74yMUakZs2a7m23b9/ea19jx45F0aJFjZCiFUkI4VwkhIQQuYJLL70Uo0ePxrFjx/Dmm28iMjIS1113nbEAJSQkGNeWJ4mJiWjSpIl5z9FddIXZIsiXPXv24KmnnsKcOXOwd+9eJCcnm21u3bo1R45NCJF7kRASQuQKChYsiOrVq5v348aNM3FAH330EerXr2/m/fjjj6hQoYLXOnSFEcYNpQXdYgcOHMBbb72FypUrm/VoXaKYEkI4GwkhIUSug26xJ554AoMHD8batWuNcKH1hm4wfzRs2BCffPKJGXHmzyo0f/58vPfeeyYuiGzbtg379+/P9uMQQuR+FCwthMiV3HDDDYiIiDBxQA8//LAJkKbY4Ugwjvh65513zGcyYMAAHD58GDfddBMWL16MdevW4bPPPsOaNWvM9wyO5udVq1bhzz//xC233JKuFUkI4QxkERJC5EoYI0SBM2zYMGzatAmlSpUyo8c2btxoAp0vuOACYzUiJUqUMKPFHnnkEWM1ooBq3Lgx2rRpY76ni+3uu+8263B4PoOvKa6EECLMsiwr2I0QQgghhAgGco0JIYQQwrFICAkhhBDCsUgICSGEEMKxSAgJIYQQwrFICAkhhBDCsUgICSGEEMKxSAgJIYQQwrFICAkhhBDCsUgICSGEEMKxSAgJIYQQwrFICAkhhBDCsUgICSGEEAJO5f8Tfi5DJ6ZmAAAAAABJRU5ErkJggg==", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "display_AUC(metrics_before_training, metrics_after_training)\n", - "display_accuracy(metrics_before_training, metrics_after_training)\n", - "display_metrics(metrics_before_training, metrics_after_training)\n", - "display_f1_score(metrics_before_training, metrics_after_training)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "finetune", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.12.2" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} From 9c79ee22263201b877c04bbecde9afbb5df4d48f Mon Sep 17 00:00:00 2001 From: Justin Cechmanek Date: Fri, 31 Jan 2025 11:37:08 -0800 Subject: [PATCH 03/10] moves sample data to S3 bucket --- .../finetuning/00_text_finetuning.ipynb | 21 ++++++++ .../finetuning/datasets/sample_dataset.csv | 53 ------------------- .../finetuning/datasets/sample_testset.csv | 21 -------- 3 files changed, 21 insertions(+), 74 deletions(-) delete mode 100644 python-recipes/finetuning/datasets/sample_dataset.csv delete mode 100644 python-recipes/finetuning/datasets/sample_testset.csv diff --git a/python-recipes/finetuning/00_text_finetuning.ipynb b/python-recipes/finetuning/00_text_finetuning.ipynb index b51d4d33..efa368a9 100644 --- a/python-recipes/finetuning/00_text_finetuning.ipynb +++ b/python-recipes/finetuning/00_text_finetuning.ipynb @@ -74,6 +74,27 @@ "test_data = 'sample_testset.csv'" ] }, + { + "cell_type": "code", + "execution_count": 49, + "metadata": {}, + "outputs": [], + "source": [ + "import requests\n", + "import os\n", + "\n", + "if not (os.path.exists(f\"./datasets/{train_data}\") and os.path.exists(f\"./datasets/{test_data}\")):\n", + " if not os.path.exists('./datasets/'):\n", + " os.mkdir('./datasets/')\n", + "\n", + " # download the files and save them locally\n", + " for file in [train_data, test_data]:\n", + " url = f'https://redis-ai-resources.s3.us-east-2.amazonaws.com/finetuning/datasets/{file}'\n", + " r = requests.get(url)\n", + " with open(f'./datasets/{file}', 'wb') as f:\n", + " f.write(r.content)" + ] + }, { "cell_type": "code", "execution_count": 32, diff --git a/python-recipes/finetuning/datasets/sample_dataset.csv b/python-recipes/finetuning/datasets/sample_dataset.csv deleted file mode 100644 index cfba8602..00000000 --- a/python-recipes/finetuning/datasets/sample_dataset.csv +++ /dev/null @@ -1,53 +0,0 @@ -question_1,question_2,label -What is AI?,What is artificial itelligence?,1.0 -How to bake a cake?,How to make a sandwich?,0.0 -Define machine learning.,Explain machine learning.,1.0 -What is deep learning?,What is AI?,0.0 -How does a car engine work?,Explain the working of a car engine.,1.0 -What are the benefits of exercise?,Why is physical activity important?,1.0 -Where can I buy a laptop?,How do I fix a broken laptop?,0.0 -Describe the process of photosynthesis.,What is photosynthesis?,1.0 -What is the capital of Japan?,How tall is Mount Everest?,0.0 -How do I learn Python?,Where can I find Python tutorials?,1.0 -Who wrote Hamlet?,Who is the author of Romeo and Juliet?,1.0 -What is the boiling point of water?,How much does a liter of water weigh?,0.0 -When was the United States founded?,Who was the first president of the United States?,0.0 -What is quantum computing?,Explain quantum computing.,1.0 -How do airplanes fly?,What are the principles of flight?,1.0 -Where can I find a good restaurant?,How do I cook pasta?,0.0 -What is the Pythagorean theorem?,Who discovered the Pythagorean theorem?,0.0 -What are the symptoms of COVID-19?,How do I know if I have COVID-19?,1.0 -What is the speed of light?,How fast does light travel?,1.0 -Why is the sky blue?,Why do leaves change color in autumn?,0.0 -How do I change a flat tire?,What should I do if my car breaks down?,0.0 -What are the causes of climate change?,How does global warming affect the environment?,1.0 -Who painted the Mona Lisa?,What is the most famous painting by Leonardo da Vinci?,1.0 -How do I improve my writing skills?,What are some tips for becoming a better writer?,1.0 -What is the population of Canada?,What is the capital of Canada?,0.0 -When did World War II end?,What were the causes of World War II?,0.0 -How does a microwave oven work?,What is the function of a microwave oven?,1.0 -What is the difference between a virus and bacteria?,How are viruses and bacteria different?,1.0 -What is the tallest mountain in the world?,Where is Mount Everest located?,0.0 -How do I lose weight?,What are some effective weight loss strategies?,1.0 -Who discovered gravity?,What did Isaac Newton discover?,1.0 -What is the formula for the area of a circle?,How do you calculate the area of a circle?,1.0 -How does a refrigerator work?,What is the function of a refrigerator?,1.0 -What are the benefits of drinking water?,Why is hydration important?,1.0 -How do I start investing in stocks?,What are the basics of stock market investing?,1.0 -Who wrote the Harry Potter books?,Who is J.K. Rowling?,0.0 -What is the capital of Germany?,What is the largest city in Germany?,0.0 -Why do birds migrate?,What are the reasons for bird migration?,1.0 -What is the atomic number of carbon?,How many protons does carbon have?,1.0 -How do I delete my Facebook account?,How do I create a Facebook account?,0.0 -What is the function of the liver?,How does the liver help the body?,1.0 -Where is the Great Wall of China located?,How long is the Great Wall of China?,0.0 -What causes earthquakes?,Why do tectonic plates move?,1.0 -What is the main ingredient in bread?,How is bread made?,0.0 -How do I calculate my BMI?,What is the formula for Body Mass Index?,1.0 -What are renewable energy sources?,How does solar power work?,0.0 -What is the boiling point of water in Celsius?,At what temperature does water boil?,1.0 -What are the symptoms of the flu?,How do I know if I have a cold or the flu?,1.0 -Who was the first human in space?,Who was Yuri Gagarin?,0.0 -Why is the ocean salty?,What causes ocean water to be salty?,1.0 -How do I tie a tie?,What are the steps to tying a Windsor knot?,1.0 -Where can I buy a used car?,How do I negotiate the price of a car?,0.0 diff --git a/python-recipes/finetuning/datasets/sample_testset.csv b/python-recipes/finetuning/datasets/sample_testset.csv deleted file mode 100644 index e37cbce2..00000000 --- a/python-recipes/finetuning/datasets/sample_testset.csv +++ /dev/null @@ -1,21 +0,0 @@ -question_1,question_2,label -What is photosynthesis?,How do plants make their own food?,1.0 -Who invented the telephone?,Who was Alexander Graham Bell?,0.0 -What are the seven continents?,How many continents are there?,1.0 -How do I learn to play guitar?,What are some beginner tips for learning guitar?,1.0 -What is the capital of Italy?,Where is Rome located?,0.0 -How do I cook rice?,What is the best way to cook rice?,1.0 -What is the formula for force in physics?,How do you calculate force?,1.0 -What are the primary colors?,What colors make up the primary colors?,1.0 -Where is the Amazon Rainforest located?,How big is the Amazon Rainforest?,0.0 -What is a black hole?,How does a black hole form?,1.0 -How do I improve my public speaking skills?,What are some tips for public speaking?,1.0 -What is the meaning of life?,Why are we here?,1.0 -Who wrote The Great Gatsby?,What books did F. Scott Fitzgerald write?,0.0 -How does an electric car work?,What makes electric cars different from gas-powered cars?,1.0 -What is the freezing point of water?,At what temperature does water freeze?,1.0 -How do I change my email password?,How do I reset my email password?,1.0 -What are the benefits of yoga?,Why is yoga good for you?,1.0 -How do I create a budget?,What are some tips for managing personal finances?,1.0 -What is the difference between a crocodile and an alligator?,How are crocodiles and alligators different?,1.0 -What are the ingredients in a chocolate cake?,How do you bake a chocolate cake?,0.0 From c86478f1b1e5d52767c820aaa3c1d6be944e9351 Mon Sep 17 00:00:00 2001 From: Justin Cechmanek Date: Fri, 31 Jan 2025 11:53:04 -0800 Subject: [PATCH 04/10] adds link to contrastive loss paper. removes some plots --- .../finetuning/00_text_finetuning.ipynb | 64 +------------------ 1 file changed, 3 insertions(+), 61 deletions(-) diff --git a/python-recipes/finetuning/00_text_finetuning.ipynb b/python-recipes/finetuning/00_text_finetuning.ipynb index efa368a9..604da926 100644 --- a/python-recipes/finetuning/00_text_finetuning.ipynb +++ b/python-recipes/finetuning/00_text_finetuning.ipynb @@ -18,7 +18,7 @@ "metadata": {}, "source": [ "This notebook uses the [sentence_transformers](https://sbert.net/) library to fine tune a text embedding model on a custom dataset.\n", - "The training method used is contrastive fine tuning, where two statements are assigned a label as either being similar {label=1.0} or dissimilar {label=0.0}.\n", + "The training method used is [contrastive fine tuning](https://arxiv.org/abs/2408.00690), where two statements are assigned a label as either being similar {label=1.0} or dissimilar {label=0.0}.\n", "Training then proceeds to minimize the cosine distance between similar statements, and maximize the cosine distance between dissimilar statements.\n", "\n", "This contrastive loss function is well suited to semantic cache applications where we care about the metrics true positive, true negative, false positive, and false negative.\n", @@ -458,40 +458,12 @@ " plt.xlabel('Threshold')\n", " plt.ylabel('F1 Score')\n", " plt.legend(['before finetuning', 'after finetuning'])\n", - " plt.show()\n", - "\n", - "\n", - "def display_metrics(metrics_before, metrics_after):\n", - " colors = ['b','g','r','m']\n", - " plt.figure()\n", - " for val in zip(['TP', 'TN'], colors[:2]):\n", - " plt.plot(list(metrics_before.keys()), [m[val[0]] for m in metrics_before.values()], color=val[1])\n", - " for val in zip(['TP', 'TN'], colors[:2]):\n", - " plt.plot(list(metrics_after.keys()), [m[val[0]] for m in metrics_after.values()], marker='.', color=val[1])\n", - "\n", - " plt.title(f'trained on {train_data}, test on {test_data}\\n True Positives and Negatives -- higher is better')\n", - " plt.xlabel('threshold')\n", - " plt.ylabel('successes')\n", - " plt.legend(['TP before', 'TN before', 'TP after', 'TN after'])\n", - "\n", - " plt.figure()\n", - " for val in zip(['FP', 'FN'], colors[2:]):\n", - " plt.plot(list(metrics_before.keys()), [m[val[0]] for m in metrics_before.values()], color=val[1])\n", - " for val in zip(['FP', 'FN'], colors[2:]):\n", - " plt.plot(list(metrics_after.keys()), [m[val[0]] for m in metrics_after.values()], marker='.', color=val[1])\n", - "\n", - " plt.title(f'trained on {train_data}, test on {test_data}\\n False Positives and Negatives -- lower is better')\n", - " plt.xlabel('threshold')\n", - " plt.ylabel('errors')\n", - " plt.legend(['FP before', 'FN before', 'FP after', 'FN after'])\n", - " plt.figure()\n", - "\n", - " plt.show()\n" + " plt.show()" ] }, { "cell_type": "code", - "execution_count": 43, + "execution_count": 50, "metadata": {}, "outputs": [ { @@ -514,35 +486,6 @@ "metadata": {}, "output_type": "display_data" }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, { "data": { "image/png": "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", @@ -557,7 +500,6 @@ "source": [ "display_AUC(metrics_before_training, metrics_after_training)\n", "display_accuracy(metrics_before_training, metrics_after_training)\n", - "display_metrics(metrics_before_training, metrics_after_training)\n", "display_f1_score(metrics_before_training, metrics_after_training)" ] }, From 8c91192ca5ed4110ff9e9bc16367a3cb2fd2c138 Mon Sep 17 00:00:00 2001 From: Justin Cechmanek Date: Mon, 3 Feb 2025 17:17:27 -0800 Subject: [PATCH 05/10] updates finetuning recipe to be more general --- .../finetuning/00_text_finetuning.ipynb | 96 ++++++++++--------- 1 file changed, 52 insertions(+), 44 deletions(-) diff --git a/python-recipes/finetuning/00_text_finetuning.ipynb b/python-recipes/finetuning/00_text_finetuning.ipynb index 604da926..2efa860b 100644 --- a/python-recipes/finetuning/00_text_finetuning.ipynb +++ b/python-recipes/finetuning/00_text_finetuning.ipynb @@ -6,11 +6,11 @@ "source": [ "# Fine tuning text embedding models using sentence_transformers\n", "\n", - "If you're building an LLM application your system will likely include a semantic cache to store previous LLM responses and return those cached answers instead of hitting your LLM again to generate the same answer as before.\n", + "If you're building an LLM application your system will likely include a text embedding model that transforms written text into vector embeddings. These may be used for classification, routing, document retrieval, semantic caching or search.\n", "\n", - "Semantic caching improves response time, cost, and user experience, but introduces a new measure of cache performance beyond hit rate - the notions of true and false cache hits.\n", + "One of the key measure of an embedding model is how well it can group semantically equivalent statements together, and similarly, how well it an distinguish between similar, but not equivalent statements.\n", "\n", - "Because semantic caches are not performing exact key-value cache lookups, but instead doing vector similarity search on text embeddings, we're not guaranteed that every cache hit will be a relevant result, or that every cache miss means our cache doesn't hold the answer we're looking for. This is why using the correct text embedding model is critical. Using a text embedding model specifically fine tuned to correctly match queries for your system can improve your overall cache performance." + "Because embedding models are not performing logical reasoning, but instead are often used to perform vector similarity calculations, we're not guaranteed that every pair of similar vectors will be relevant or equivalent, or that embeddings that are far apart in vector space aren't relevant to each other. This is why using the correct text embedding model is critical. Using a text embedding model specifically fine tuned to correctly match queries for your system can improve your overall app performance." ] }, { @@ -21,7 +21,7 @@ "The training method used is [contrastive fine tuning](https://arxiv.org/abs/2408.00690), where two statements are assigned a label as either being similar {label=1.0} or dissimilar {label=0.0}.\n", "Training then proceeds to minimize the cosine distance between similar statements, and maximize the cosine distance between dissimilar statements.\n", "\n", - "This contrastive loss function is well suited to semantic cache applications where we care about the metrics true positive, true negative, false positive, and false negative.\n", + "This contrastive loss function is well suited to applications where we care about the metrics true positive, true negative, false positive, and false negative.\n", "\n", "## Let's Begin!\n", "\"Open" @@ -29,7 +29,7 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 1, "metadata": {}, "outputs": [ { @@ -51,7 +51,7 @@ "metadata": {}, "source": [ "## Select our starting model and dataset to fine tune on\n", - "To perform finetuning you'll need a dataset that ideally is specific to your use case. For the type of training we'll be doing - contrastive fine tuning - you'll need to structure your dataset as a set of pairs of questions or statements and coresponding label indicating if they're similar or not.\n", + "To perform finetuning you'll need a dataset that ideally is specific to your use case. For the type of training we'll be doing - contrastive fine tuning - you'll need to structure your dataset as a set of pairs of questions or statements and coresponding label indicating if they're equivalent or not.\n", "\n", "An example of what this looks like is in `sample_dataset.csv`\n", "\n", @@ -64,19 +64,19 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "# select the datasets to train and test on\n", - "# we've provided examples in the datasets directory of what these files should look like\n", + "# we've provided examples in the datasets directory of our public S3 bucket for what these files should look like\n", "train_data = 'sample_dataset.csv'\n", "test_data = 'sample_testset.csv'" ] }, { "cell_type": "code", - "execution_count": 49, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -97,7 +97,7 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -107,7 +107,8 @@ "import copy\n", "\n", "# load a model to train/finetune\n", - "model_name = 'sentence-transformers/all-mpnet-base-v2'\n", + "model_name = 'sentence-transformers/all-MiniLM-L6-v2'\n", + "\n", "model = SentenceTransformer(model_name)\n", "\n", "# make a copy of the weights before training if we want to compare how much they've changed\n", @@ -130,7 +131,7 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ @@ -139,7 +140,7 @@ "\n", "args = SentenceTransformerTrainingArguments(\n", " # required parameters\n", - " output_dir=f\"models/mpnet-trained_on_{train_data}\",\n", + " output_dir=f\"models/trained_on_{train_data}\",\n", " # optional training parameters\n", " num_train_epochs=1,\n", " per_device_train_batch_size=16,\n", @@ -155,7 +156,7 @@ " save_steps=100,\n", " save_total_limit=2,\n", " logging_steps=100,\n", - " run_name=f\"mpnet-base-{train_data}\", # used in Weights & Biases if `wandb` is installed\n", + " run_name=f\"model-base-{train_data}\", # used in Weights & Biases if `wandb` is installed\n", ")" ] }, @@ -165,14 +166,14 @@ "source": [ "## Split your dataset to perform training validation\n", "While our model is training both the training loss and validation loss will be recorded. These are printed to `stdout`, and also logged in\n", - "`models/mpnet-base-all/checkpoint-/trainer_state.json`.\n", + "`models/model-base-all/checkpoint-/trainer_state.json`.\n", "\n", "sentence_transformers uses the term 'evaluation' rather than 'validation'." ] }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 6, "metadata": {}, "outputs": [ { @@ -222,13 +223,13 @@ }, { "cell_type": "code", - "execution_count": 35, + "execution_count": 7, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "40387058dc3447eaa151b8ed05ad0df0", + "model_id": "876f7c097a1546218450819fcbd597ae", "version_major": 2, "version_minor": 0 }, @@ -242,7 +243,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "d3e1075c966748c991ce601967f1f58e", + "model_id": "f227b7fa7d6f4f24a665b60d6f92f77c", "version_major": 2, "version_minor": 0 }, @@ -257,7 +258,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "{'train_runtime': 4.2494, 'train_samples_per_second': 9.648, 'train_steps_per_second': 0.706, 'train_loss': 0.031828783452510834, 'epoch': 1.0}\n" + "{'train_runtime': 3.3658, 'train_samples_per_second': 12.181, 'train_steps_per_second': 0.891, 'train_loss': 0.03720299402872721, 'epoch': 1.0}\n" ] } ], @@ -283,23 +284,27 @@ "metadata": {}, "source": [ "## That's it!\n", - "That is all it takes to produce a finetuned model on your dataset. Every application is different and you'll want to know how well this model can do with your cache, and how much better it is now that you've tuned it. Here we compute some metrics to see the impact of fine tuning.\n", - "These will also help you choose the best cache hit similarity threshold for your app based on your criteria." + "That is all it takes to produce a finetuned model on your dataset. Every application is different and you'll want to know how well this model can do with your system, and how much better it is now that you've tuned it. Here we compute some metrics to see the impact of fine tuning.\n", + "These will also help you choose the best similarity threshold for your app based on your criteria." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## Evaluate the trained model for use in a semantic cache\n", - "As the ultimate goal of this fine tuning is to improve performance for semantic caching we'll run an evaluation with our trained model to simulate a series of cache checks.\n", + "## Evaluate the trained model\n", + "As the ultimate goal of this fine tuning is to improve performance for distinguishing equivalent and not equivalent statements, we'll evaluate our trained model to to see how well it correctly identifies pairs of statements as either equivalent or not. We have a labeled dataset for this, where statements are known to be either equivalent, and labelled `1.0`, or not equivalent and labelled `0.0`. If you have a background in data science or statistics you may recognize this as a binary classification problem. Pairs embeddings will be classified as similar, aka positive, or dissimilar, aka negative. Comparing to our known labels that means that every pair of interest will in one of four groups:\n", + "- true positives (TP): our model correctly determines two vector embeddings are equivalent\n", + "- true negatives (TN): our model correctly determines two vector embeddings are different\n", + "- false positives (FP): our model incorrectly determines two vector embeddings are equivalent\n", + "- false negatives (FN): our model incorrectly determines two vector embeddings are different\n", "\n", "Here we can also evaluate on different datasets we haven't trained on. We've again provided a `sample_testset.csv` file to illustrate this, but you should replace this with data relevant to your app." ] }, { "cell_type": "code", - "execution_count": 36, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ @@ -318,7 +323,7 @@ " cosine_distance = 1 - np.dot(embedding_1, embedding_2) / (np.linalg.norm(embedding_1) * np.linalg.norm(embedding_2))\n", " distances[index_1, index_2] = cosine_distance\n", "\n", - " # for our range of thresholds see which embeddings fall within our threshold and so would be returned from a cache\n", + " # for our range of thresholds see which embeddings fall within our threshold and so would be consindered equivalent\n", " metrics = {}\n", " thresholds = np.linspace(0.01, 0.6, 60)\n", " for threshold in thresholds:\n", @@ -330,15 +335,15 @@ " # for question N find the most similar embedding, aka the one with the lowest distance\n", " distance_of_nearest = np.min(distances[index, :])\n", " index_of_nearest = np.argmin(distances[index, :])\n", - " if distances[index, :][index_of_nearest] <= threshold: # if the distance is below our threshold it's a cache hit\n", - " if label == 1: # check the label to see if it should have been a hit (label == 1) or if there shouldn't be a hit (label == 0)\n", + " if distances[index, :][index_of_nearest] <= threshold: # if the distance is below our threshold our model thinks they're equivalent\n", + " if label == 1: # check the label to see if it really is equivalent (label == 1) or if they're actually different (label == 0)\n", " if index_of_nearest == index: # verify that we hit the correct matched pair, and not some other question\n", - " TP += 1 # we correctly found a matching cache entry\n", + " TP += 1 # we correctly found a matching entry\n", " else:\n", - " FP += 1 # we hit the cache, but returned a wrong result\n", + " FP += 1 # we found something we think is equivalent, but it's not what we should have found\n", " else:\n", - " FP += 1 # we hit the cache, but shouldn't have\n", - " else: # it's a cache miss\n", + " FP += 1 # we think we found an equivalent statement, but shouldn't have\n", + " else: # we didn't find anything\n", " if label == 1: # check it should be a miss\n", " FN += 1 # we failed to find a matching pair\n", " else:\n", @@ -360,7 +365,7 @@ }, { "cell_type": "code", - "execution_count": 37, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ @@ -370,7 +375,7 @@ }, { "cell_type": "code", - "execution_count": 38, + "execution_count": 10, "metadata": {}, "outputs": [], "source": [ @@ -387,12 +392,12 @@ "source": [ "## Visualize metrics\n", "Since we're tracking multiple metrics - true & false positives & negatives, accuracy and F1 score - we want a way to quickly visually compare all of these.\n", - "We'll plot these metrics to see how they change after fine tuning, and also how we can influence them by selecting the best cosine similarity threshold for our semantic cache." + "We'll plot these metrics to see how they change after fine tuning, and also how we can influence them by selecting the best cosine similarity threshold." ] }, { "cell_type": "code", - "execution_count": 42, + "execution_count": 11, "metadata": {}, "outputs": [], "source": [ @@ -463,12 +468,12 @@ }, { "cell_type": "code", - "execution_count": 50, + "execution_count": 12, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -478,7 +483,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -488,7 +493,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -508,12 +513,15 @@ "metadata": {}, "source": [ "## Every use case is different\n", - "With semantic caching we always have to keep in mind there is a tradeoff between cache utilization, which improves response times and cuts LLM costs, and the risk of incorrect cache responses. You can control this tradeoff by selecting the cache similarity threshold that makes sense for your system.\n", - "\n", - "If you want to drive down LLM calls and the occasional incorrect response from a cache hit is acceptable, then set a high threshold and return cached entries often.\n", + "With vector embeddings we always have to keep in mind there is a tradeoff between true and false positives and negatives. You an cast a wide net with a large threshold and grab many seemingly similar vectors at the risk of getting some irrelevant ones, or you can be conservative and match only highly similar embeddings, and risk missing something important. You can control this tradeoff by selecting the similarity threshold that makes sense for your system.\n", "\n", - "Or if a false positive cache hit that results in a poor response to your users is something you want to minimize, then choose a small threshold and be confident that only highly similar results will be coming from your cache.\n" + "Where you set this threshold depends on your own use case and system, and your tolerance for different types of errors. Choosing the threshold that maximizes F1 score or accuracy are good places to start. Ultimately you'll want to optimize for your specific use case, and we have a [retrieval optimizer tool](https://github.com/redis-applied-ai/retrieval-optimizer) to help with that when you're ready for the next level of system improvements." ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [] } ], "metadata": { From 1af440d4e857270f20d351aa46c037e9907ab648 Mon Sep 17 00:00:00 2001 From: Tyler Hutcherson Date: Tue, 11 Feb 2025 23:29:05 -0500 Subject: [PATCH 06/10] update github actions workflow and update gitignore file --- .github/workflows/nightly-test.yml | 26 ++-- .github/workflows/test.yml | 25 ++-- .gitignore | 224 ++++++++++++++++++++++++++++- .python-version | 2 +- 4 files changed, 251 insertions(+), 26 deletions(-) diff --git a/.github/workflows/nightly-test.yml b/.github/workflows/nightly-test.yml index a0571d1c..2816c926 100644 --- a/.github/workflows/nightly-test.yml +++ b/.github/workflows/nightly-test.yml @@ -16,12 +16,16 @@ jobs: runs-on: ubuntu-latest outputs: notebooks: ${{ steps.get_nbs.outputs.notebooks }} + has_notebooks: ${{ steps.get_nbs.outputs.has_notebooks }} steps: - - uses: actions/checkout@v2 + - uses: actions/checkout@v3 - id: get_nbs run: | - # 1) Read ignore patterns from .github/ignore-notebooks.txt + # 1) Find all available notebooks + NBS=$(find python-recipes -name '*.ipynb') + + # 2) Load notebooks to ignore IGNORE_LIST=() while IFS= read -r skip_nb || [ -n "$skip_nb" ]; do # Skip empty lines or comment lines @@ -29,9 +33,6 @@ jobs: IGNORE_LIST+=("$skip_nb") done < .github/ignore-notebooks.txt - # 2) Find all .ipynb in python-recipes (or your path) - NBS=$(find python-recipes -name '*.ipynb') - # 3) Filter out notebooks that match anything in IGNORE_LIST FILTERED_NBS=() for nb in $NBS; do @@ -42,29 +43,36 @@ jobs: break fi done - if [ "$skip" = false ]; then FILTERED_NBS+=("$nb") fi done - # 4) Convert the final array to compact JSON for GitHub Actions + # 4) Stuff into a single-line JSON array NB_JSON=$(printf '%s\n' "${FILTERED_NBS[@]}" \ | jq -R . \ | jq -s -c .) - # 5) Default to an empty array if there's nothing left if [ -z "$NB_JSON" ] || [ "$NB_JSON" = "[]" ]; then NB_JSON="[]" fi echo "All valid notebooks: $NB_JSON" + + # 5) Check if there's anything in FILTERED_NBS + if [ "${#FILTERED_NBS[@]}" -gt 0 ]; then + echo "has_notebooks=true" >> $GITHUB_OUTPUT + else + echo "has_notebooks=false" >> $GITHUB_OUTPUT + fi + echo "notebooks=$NB_JSON" >> $GITHUB_OUTPUT # --------------------------------------------------------- # 2) Test all notebooks in parallel # --------------------------------------------------------- test_all_notebooks: + if: ${{ needs.gather_all_notebooks.outputs.has_notebooks == 'true' }} needs: gather_all_notebooks runs-on: ubuntu-latest strategy: @@ -79,7 +87,7 @@ jobs: - 6379:6379 steps: - - uses: actions/checkout@v2 + - uses: actions/checkout@v3 # Setup Python - uses: actions/setup-python@v4 diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml index d93f8977..17af1c43 100644 --- a/.github/workflows/test.yml +++ b/.github/workflows/test.yml @@ -17,16 +17,18 @@ jobs: runs-on: ubuntu-latest outputs: notebooks: ${{ steps.get_nbs.outputs.notebooks }} + has_notebooks: ${{ steps.get_nbs.outputs.has_notebooks }} steps: - - uses: actions/checkout@v2 + - uses: actions/checkout@v3 - - id: get_nbs + - name: Gather notebooks + id: get_nbs run: | - # Compare this commit/PR to 'main' and list changed .ipynb files + # 1) Compare this commit/PR to 'main' and list changed notebooks git fetch --depth=1 origin main CHANGED_NOTEBOOKS=$(git diff --name-only origin/main | grep '\.ipynb$' || true) - # 1) Read ignore patterns from .github/ignore-notebooks.txt + # 2) Load notebooks to ignore IGNORE_LIST=() while IFS= read -r skip_nb || [ -n "$skip_nb" ]; do # Skip empty lines or comment lines @@ -34,11 +36,10 @@ jobs: IGNORE_LIST+=("$skip_nb") done < .github/ignore-notebooks.txt - # 2) Filter out notebooks in CHANGED_NOTEBOOKS that match ignore patterns + # 3) Filter out ignored notebooks FILTERED_NBS=() for nb in $CHANGED_NOTEBOOKS; do skip=false - # Check if in ignore list for ignore_nb in "${IGNORE_LIST[@]}"; do # Partial match: @@ -47,33 +48,31 @@ jobs: break fi done - if [ "$skip" = false ]; then FILTERED_NBS+=("$nb") fi done - # 3) Build a single-line JSON array + # 4) Stuff into a single-line JSON array NB_JSON=$(printf '%s\n' "${FILTERED_NBS[@]}" \ | jq -R . \ | jq -s -c .) - # 4) Fallback to an empty array if there's nothing left if [ -z "$NB_JSON" ] || [ "$NB_JSON" = "[]" ]; then NB_JSON="[]" fi echo "All valid notebooks: $NB_JSON" - # 5) Write to $GITHUB_OUTPUT - if [ "$NB_JSON" != "[]" ]; then + # 5) Check if there's anything in FILTERED_NBS + if [ "${#FILTERED_NBS[@]}" -gt 0 ]; then echo "has_notebooks=true" >> $GITHUB_OUTPUT else echo "has_notebooks=false" >> $GITHUB_OUTPUT fi echo "notebooks=$NB_JSON" >> $GITHUB_OUTPUT - + # --------------------------------------------------------- # 2) Test each changed notebook in parallel # --------------------------------------------------------- @@ -93,7 +92,7 @@ jobs: - 6379:6379 steps: - - uses: actions/checkout@v2 + - uses: actions/checkout@v3 # Setup Python - uses: actions/setup-python@v4 diff --git a/.gitignore b/.gitignore index 1a701dd5..5dced209 100644 --- a/.gitignore +++ b/.gitignore @@ -1,4 +1,222 @@ -.env -node_modules/ +# Created by https://www.toptal.com/developers/gitignore/api/python,venv,macos +# Edit at https://www.toptal.com/developers/gitignore?templates=python,venv,macos + +### macOS ### +# General .DS_Store -.pytest_cache/ \ No newline at end of file +.AppleDouble +.LSOverride + +# Icon must end with two \r +Icon + + +# Thumbnails +._* + +# Files that might appear in the root of a volume +.DocumentRevisions-V100 +.fseventsd +.Spotlight-V100 +.TemporaryItems +.Trashes +.VolumeIcon.icns +.com.apple.timemachine.donotpresent + +# Directories potentially created on remote AFP share +.AppleDB +.AppleDesktop +Network Trash Folder +Temporary Items +.apdisk + +### macOS Patch ### +# iCloud generated files +*.icloud + +### Python ### +# Byte-compiled / optimized / DLL files +__pycache__/ +*.py[cod] +*$py.class + +# C extensions +*.so + +# Distribution / packaging +.Python +build/ +develop-eggs/ +dist/ +downloads/ +eggs/ +.eggs/ +lib/ +lib64/ +parts/ +sdist/ +var/ +wheels/ +share/python-wheels/ +*.egg-info/ +.installed.cfg +*.egg +MANIFEST + +# PyInstaller +# Usually these files are written by a python script from a template +# before PyInstaller builds the exe, so as to inject date/other infos into it. +*.manifest +*.spec + +# Installer logs +pip-log.txt +pip-delete-this-directory.txt + +# Unit test / coverage reports +htmlcov/ +.tox/ +.nox/ +.coverage +.coverage.* +.cache +nosetests.xml +coverage.xml +*.cover +*.py,cover +.hypothesis/ +.pytest_cache/ +cover/ + +# Translations +*.mo +*.pot + +# Django stuff: +*.log +local_settings.py +db.sqlite3 +db.sqlite3-journal + +# Flask stuff: +instance/ +.webassets-cache + +# Scrapy stuff: +.scrapy + +# Sphinx documentation +docs/_build/ + +# PyBuilder +.pybuilder/ +target/ + +# Jupyter Notebook +.ipynb_checkpoints + +# IPython +profile_default/ +ipython_config.py + +# pyenv +# For a library or package, you might want to ignore these files since the code is +# intended to run in multiple environments; otherwise, check them in: +.python-version + +# pipenv +# According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control. +# However, in case of collaboration, if having platform-specific dependencies or dependencies +# having no cross-platform support, pipenv may install dependencies that don't work, or not +# install all needed dependencies. +#Pipfile.lock + +# poetry +# Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control. +# This is especially recommended for binary packages to ensure reproducibility, and is more +# commonly ignored for libraries. +# https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control +#poetry.lock + +# pdm +# Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control. +#pdm.lock +# pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it +# in version control. +# https://pdm.fming.dev/#use-with-ide +.pdm.toml + +# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm +__pypackages__/ + +# Celery stuff +celerybeat-schedule +celerybeat.pid + +# SageMath parsed files +*.sage.py + +# Environments +.env +.venv +env/ +venv/ +ENV/ +env.bak/ +venv.bak/ + +# Spyder project settings +.spyderproject +.spyproject + +# Rope project settings +.ropeproject + +# mkdocs documentation +/site + +# mypy +.mypy_cache/ +.dmypy.json +dmypy.json + +# Pyre type checker +.pyre/ + +# pytype static type analyzer +.pytype/ + +# Cython debug symbols +cython_debug/ + +# PyCharm +# JetBrains specific template is maintained in a separate JetBrains.gitignore that can +# be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore +# and can be added to the global gitignore or merged into this file. For a more nuclear +# option (not recommended) you can uncomment the following to ignore the entire idea folder. +#.idea/ + +### Python Patch ### +# Poetry local configuration file - https://python-poetry.org/docs/configuration/#local-configuration +poetry.toml + +# ruff +.ruff_cache/ + +# LSP config files +pyrightconfig.json + +### venv ### +# Virtualenv +# http://iamzed.com/2009/05/07/a-primer-on-virtualenv/ +[Bb]in +[Ii]nclude +[Ll]ib +[Ll]ib64 +[Ll]ocal +pyvenv.cfg +pip-selfcheck.json + +libs/redis/docs/.Trash* +.python-version +.idea/* diff --git a/.python-version b/.python-version index 2419ad5b..2c073331 100644 --- a/.python-version +++ b/.python-version @@ -1 +1 @@ -3.11.9 +3.11 From 72b7d1f70c9f5c783f572dedbd098816bd600256 Mon Sep 17 00:00:00 2001 From: Tyler Hutcherson Date: Wed, 12 Feb 2025 08:09:37 -0500 Subject: [PATCH 07/10] test nighly run --- .github/workflows/nightly-test.yml | 2 ++ 1 file changed, 2 insertions(+) diff --git a/.github/workflows/nightly-test.yml b/.github/workflows/nightly-test.yml index 2816c926..10ea4d19 100644 --- a/.github/workflows/nightly-test.yml +++ b/.github/workflows/nightly-test.yml @@ -1,6 +1,8 @@ name: Tests - Nightly Run on: + pull_request: + branches: [ main ] schedule: - cron: "0 3 * * *" # 3 AM UTC nightly workflow_dispatch: From a97341d1e1c59b78ab37361e83928d47ea9ecdd3 Mon Sep 17 00:00:00 2001 From: Tyler Hutcherson Date: Wed, 12 Feb 2025 08:16:01 -0500 Subject: [PATCH 08/10] rm nightly run --- .github/workflows/nightly-test.yml | 2 -- 1 file changed, 2 deletions(-) diff --git a/.github/workflows/nightly-test.yml b/.github/workflows/nightly-test.yml index 10ea4d19..2816c926 100644 --- a/.github/workflows/nightly-test.yml +++ b/.github/workflows/nightly-test.yml @@ -1,8 +1,6 @@ name: Tests - Nightly Run on: - pull_request: - branches: [ main ] schedule: - cron: "0 3 * * *" # 3 AM UTC nightly workflow_dispatch: From 5f3caa2929f5a74f6a1cba2778fd4a97f7e4dcf0 Mon Sep 17 00:00:00 2001 From: Justin Cechmanek Date: Wed, 12 Feb 2025 09:45:24 -0800 Subject: [PATCH 09/10] includes matplotlib as a dependency --- python-recipes/finetuning/00_text_finetuning.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/python-recipes/finetuning/00_text_finetuning.ipynb b/python-recipes/finetuning/00_text_finetuning.ipynb index 2efa860b..468cfbb5 100644 --- a/python-recipes/finetuning/00_text_finetuning.ipynb +++ b/python-recipes/finetuning/00_text_finetuning.ipynb @@ -43,7 +43,7 @@ } ], "source": [ - "!pip install --quiet torch datasets sentence_transformers 'transformers[torch]' redisvl" + "!pip install --quiet torch datasets sentence_transformers 'transformers[torch]' redisvl matplotlib" ] }, { From dc602b661c8945c5773f273e61a274564ae11fac Mon Sep 17 00:00:00 2001 From: Justin Cechmanek Date: Thu, 13 Feb 2025 16:32:42 -0800 Subject: [PATCH 10/10] adds interactive cosine similarity threshold selector --- .../finetuning/00_text_finetuning.ipynb | 205 +++++++++++++++++- 1 file changed, 199 insertions(+), 6 deletions(-) diff --git a/python-recipes/finetuning/00_text_finetuning.ipynb b/python-recipes/finetuning/00_text_finetuning.ipynb index 468cfbb5..224df6fb 100644 --- a/python-recipes/finetuning/00_text_finetuning.ipynb +++ b/python-recipes/finetuning/00_text_finetuning.ipynb @@ -37,13 +37,13 @@ "output_type": "stream", "text": [ "\n", - "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m A new release of pip is available: \u001b[0m\u001b[31;49m24.2\u001b[0m\u001b[39;49m -> \u001b[0m\u001b[32;49m25.0\u001b[0m\n", + "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m A new release of pip is available: \u001b[0m\u001b[31;49m24.2\u001b[0m\u001b[39;49m -> \u001b[0m\u001b[32;49m25.0.1\u001b[0m\n", "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m To update, run: \u001b[0m\u001b[32;49mpip install --upgrade pip\u001b[0m\n" ] } ], "source": [ - "!pip install --quiet torch datasets sentence_transformers 'transformers[torch]' redisvl matplotlib" + "!pip install --quiet torch datasets sentence_transformers 'transformers[torch]' redisvl matplotlib seaborn scikit-learn ipywidgets" ] }, { @@ -229,7 +229,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "876f7c097a1546218450819fcbd597ae", + "model_id": "aafb575008c049f391e1d074a59e91dd", "version_major": 2, "version_minor": 0 }, @@ -243,7 +243,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "f227b7fa7d6f4f24a665b60d6f92f77c", + "model_id": "8c4ce9fb5ce24bbc80fae2f63dc0950c", "version_major": 2, "version_minor": 0 }, @@ -258,7 +258,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "{'train_runtime': 3.3658, 'train_samples_per_second': 12.181, 'train_steps_per_second': 0.891, 'train_loss': 0.03720299402872721, 'epoch': 1.0}\n" + "{'train_runtime': 2.2703, 'train_samples_per_second': 18.06, 'train_steps_per_second': 1.321, 'train_loss': 0.03720299402872721, 'epoch': 1.0}\n" ] } ], @@ -513,7 +513,7 @@ "metadata": {}, "source": [ "## Every use case is different\n", - "With vector embeddings we always have to keep in mind there is a tradeoff between true and false positives and negatives. You an cast a wide net with a large threshold and grab many seemingly similar vectors at the risk of getting some irrelevant ones, or you can be conservative and match only highly similar embeddings, and risk missing something important. You can control this tradeoff by selecting the similarity threshold that makes sense for your system.\n", + "With vector embeddings we always have to keep in mind there is a tradeoff between true and false positives and negatives. You can cast a wide net with a large threshold and grab many seemingly similar vectors at the risk of getting some irrelevant ones, or you can be conservative and match only highly similar embeddings, and risk missing something important. You can control this tradeoff by selecting the similarity threshold that makes sense for your system.\n", "\n", "Where you set this threshold depends on your own use case and system, and your tolerance for different types of errors. Choosing the threshold that maximizes F1 score or accuracy are good places to start. Ultimately you'll want to optimize for your specific use case, and we have a [retrieval optimizer tool](https://github.com/redis-applied-ai/retrieval-optimizer) to help with that when you're ready for the next level of system improvements." ] @@ -521,6 +521,199 @@ { "cell_type": "markdown", "metadata": {}, + "source": [ + "## Choosing your threshold\n", + "To get a sense of how the choice of similarity threshold changes cache performance here's an interactive tool that lets you change the threshold and immediately see how the tradeoff between true and false positives and negatives balances out." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.metrics import precision_score, recall_score, f1_score, confusion_matrix, precision_recall_curve\n", + "\n", + "def compute_metrics_at_threshold(\n", + " scores: np.ndarray,\n", + " labels: np.ndarray,\n", + " threshold: float,\n", + " high_score_more_similar: bool = True\n", + "):\n", + " if high_score_more_similar:\n", + " predictions = (scores >= threshold).astype(int)\n", + " else:\n", + " predictions = (scores <= threshold).astype(int)\n", + "\n", + " print(predictions)\n", + " precision = precision_score(labels, predictions)\n", + " recall = recall_score(labels, predictions)\n", + " f1 = f1_score(labels, predictions)\n", + " cm = confusion_matrix(labels, predictions)\n", + "\n", + " return {'precision': precision, 'recall': recall, 'f1_score': f1, 'confusion_matrix': cm}\n" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.metrics.pairwise import cosine_similarity\n", + "\n", + "q1_embeddings = [model.encode(pair['question_1']) for pair in test_dataset]\n", + "q2_embeddings = [model.encode(pair['question_2']) for pair in test_dataset]\n", + "cosine_similarities = np.array([cosine_similarity([emb1], [emb2])[0][0] for emb1, emb2 in zip(q1_embeddings, q2_embeddings)])\n", + "labels = np.array(test_dataset[\"label\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "663bbe8f3bd34492a26b59566de2a926", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "interactive(children=(FloatSlider(value=0.8114206194877625, continuous_update=False, description='Cosine Simil…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import seaborn as sns\n", + "from ipywidgets import FloatSlider, Layout, interact\n", + "from IPython.display import display, HTML\n", + "\n", + "\n", + "def update_plots(threshold):\n", + " # set a pleasing style and update global font sizes\n", + " plt.rcParams.update({'font.size': 16})\n", + "\n", + " metrics = compute_metrics_at_threshold(cosine_similarities, labels, threshold, high_score_more_similar=True)\n", + " precision = metrics['precision']\n", + " recall_val = metrics['recall']\n", + " f1 = metrics['f1_score']\n", + " cm = metrics['confusion_matrix']\n", + "\n", + " precision_curve, recall_curve, pr_thresholds = precision_recall_curve(labels, cosine_similarities)\n", + "\n", + " # clear previous plots\n", + " plt.clf()\n", + "\n", + " # create subplots with a larger figure size for better readability\n", + " fig, axs = plt.subplots(1, 2, figsize=(12, 6))\n", + "\n", + " # Precision-Recall curve plot\n", + " axs[0].plot(recall_curve, precision_curve, color='blue', linewidth=2, label='Precision-Recall Curve')\n", + " axs[0].scatter(recall_val, precision, color='red', s=100, zorder=5,\n", + " label=(f'Threshold = {threshold:.4f}\\n'\n", + " f'Precision = {precision:.2f}\\n'\n", + " f'Recall = {recall_val:.2f}'))\n", + " axs[0].set_title('Precision-Recall Curve', fontsize=20, fontweight='bold')\n", + " axs[0].set_xlabel('Recall', fontsize=18)\n", + " axs[0].set_ylabel('Precision', fontsize=18)\n", + " axs[0].tick_params(axis='both', labelsize=16)\n", + " axs[0].legend(fontsize=14)\n", + " axs[0].grid(True, linestyle='--', alpha=0.7)\n", + "\n", + " # confusion matrix heatmap\n", + " sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', ax=axs[1],\n", + " cbar=True, annot_kws={'size': 16})\n", + " axs[1].set_title('Confusion Matrix', fontsize=20, fontweight='bold')\n", + " axs[1].set_xlabel('Predicted Label', fontsize=18)\n", + " axs[1].set_ylabel('True Label', fontsize=18)\n", + " axs[1].set_xticklabels(['Dissimilar (0)', 'Similar (1)'], fontsize=16)\n", + " axs[1].set_yticklabels(['Dissimilar (0)', 'Similar (1)'], fontsize=16, rotation=0)\n", + "\n", + " # overall figure title with metrics\n", + " fig.suptitle(\n", + " (f'Cosine Similarity Threshold: {threshold:.4f}\\n'\n", + " f'Precision: {precision:.2f}, Recall: {recall_val:.2f}, F1 Score: {f1:.2f}'),\n", + " fontsize=12, fontweight='bold'\n", + " )\n", + "\n", + " plt.tight_layout(rect=[0, 0.03, 1, 0.95])\n", + " plt.show()\n", + "\n", + "# add some CSS to increase the font size for the slider's description and readout\n", + "display(HTML(\"\"\"\n", + "\n", + "\"\"\"))\n", + "\n", + "# add a slider with the new description and custom styling\n", + "threshold_slider = FloatSlider(\n", + " value=np.median(cosine_similarities),\n", + " min=np.min(cosine_similarities),\n", + " max=np.max(cosine_similarities),\n", + " step=0.001,\n", + " description='Cosine Similarity Threshold:',\n", + " readout=True,\n", + " readout_format='.4f',\n", + " continuous_update=False,\n", + " style={'description_width': 'initial'},\n", + " layout=Layout(width='80%', margin='20px 0px 20px 0px')\n", + ")\n", + "\n", + "# add a custom class to the slider for our CSS targeting\n", + "threshold_slider.add_class(\"custom-slider\")\n", + "interact(update_plots, threshold=threshold_slider)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [] } ],