From 97793c8e5dfa113046fe2bb8927ef54d8b6e998b Mon Sep 17 00:00:00 2001 From: cheng Date: Sun, 12 Nov 2023 16:10:33 +0000 Subject: [PATCH 01/16] add byom notebook --- notebooks/news_recommendation_byom.ipynb | 188 +++++++++++++++++++++++ src/learn_to_pick/pick_best.py | 2 +- 2 files changed, 189 insertions(+), 1 deletion(-) create mode 100644 notebooks/news_recommendation_byom.ipynb diff --git a/notebooks/news_recommendation_byom.ipynb b/notebooks/news_recommendation_byom.ipynb new file mode 100644 index 0000000..c38e4c6 --- /dev/null +++ b/notebooks/news_recommendation_byom.ipynb @@ -0,0 +1,188 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# ! pip install ../\n", + "# ! pip install matplotlib" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This is an example of a news recommendation system. We have two users `Tom` and `Anna`, and some article topics that we want to recommend to them.\n", + "\n", + "The users come to the news site in the moring and in the afternoon and we want to learn what topic to recommend to which user at which time of day.\n", + "\n", + "- The action space here are the `article` topics\n", + "- The criteria/context are the user and the time of day\n", + "- The score is whether the user liked or didn't like the recommendation (simulated in the `CustomSelectionScorer`)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import random\n", + "from typing import Any, Dict, List, Optional\n", + "import re\n", + "\n", + "users = [\"Tom\", \"Anna\"]\n", + "times_of_day = [\"morning\", \"afternoon\"]\n", + "articles = [\"politics\", \"sports\", \"music\", \"food\", \"finance\", \"health\", \"camping\"]\n", + "\n", + "def choose_user(users):\n", + " return random.choice(users)\n", + "\n", + "\n", + "def choose_time_of_day(times_of_day):\n", + " return random.choice(times_of_day)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import learn_to_pick\n", + "\n", + "class CustomSelectionScorer(learn_to_pick.SelectionScorer):\n", + " def get_score(self, user, time_of_day, article):\n", + " preferences = {\n", + " 'Tom': {\n", + " 'morning': 'politics',\n", + " 'afternoon': 'music'\n", + " },\n", + " 'Anna': {\n", + " 'morning': 'sports',\n", + " 'afternoon': 'politics'\n", + " }\n", + " }\n", + "\n", + " # if the article was the one the user prefered for this time of day, return 1.0\n", + " # if it was a different article return 0.0\n", + " return int(preferences[user][time_of_day] == article)\n", + "\n", + " def score_response(\n", + " self, inputs, picked, event: learn_to_pick.PickBestEvent\n", + " ) -> float:\n", + " chosen_article = picked[\"article\"]\n", + " user = event.based_on[\"user\"]\n", + " time_of_day = event.based_on[\"time_of_day\"]\n", + " score = self.get_score(user[0], time_of_day[0], chosen_article)\n", + " return score" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Initializing two pickers, one with the default decision making policy `picker` and one with a random decision making policy `random_picker`.\n", + "\n", + "Both pickers are initialized with the `CustomSelectionScorer` and with `metrics_step` and `metrics_window` in order to keep track of how the score evolves in a rolling window average fashion." + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [], + "source": [ + "picker = learn_to_pick.PickBest.create(metrics_step=20, metrics_window_size=20, selection_scorer=CustomSelectionScorer())\n", + "random_picker = learn_to_pick.PickBest.create(metrics_step=20, metrics_window_size=20, policy=learn_to_pick.PickBestRandomPolicy(), selection_scorer=CustomSelectionScorer())" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [], + "source": [ + "# randomly pick users and times of day\n", + "\n", + "for i in range(500):\n", + " user = choose_user(users)\n", + " time_of_day = choose_time_of_day(times_of_day)\n", + " picker.run(\n", + " article = learn_to_pick.ToSelectFrom(articles),\n", + " user = learn_to_pick.BasedOn(user),\n", + " time_of_day = learn_to_pick.BasedOn(time_of_day),\n", + " )\n", + " random_picker.run(\n", + " article = learn_to_pick.ToSelectFrom(articles),\n", + " user = learn_to_pick.BasedOn(user),\n", + " time_of_day = learn_to_pick.BasedOn(time_of_day),\n", + " )" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Plot the score evolution for the default picker and the random picker. We should observe the default picker to **learn** to make good suggestions over time." + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The final average score for the default policy, calculated over a rolling window, is: 1.0\n", + "The final average score for the random policy, calculated over a rolling window, is: 0.6\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from matplotlib import pyplot as plt\n", + "picker.metrics.to_pandas()['score'].plot(label=\"vw\")\n", + "random_picker.metrics.to_pandas()['score'].plot(label=\"random\")\n", + "plt.legend()\n", + "\n", + "print(f\"The final average score for the default policy, calculated over a rolling window, is: {picker.metrics.to_pandas()['score'].iloc[-1]}\")\n", + "print(f\"The final average score for the random policy, calculated over a rolling window, is: {random_picker.metrics.to_pandas()['score'].iloc[-1]}\")\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": ".venv", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.5" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/src/learn_to_pick/pick_best.py b/src/learn_to_pick/pick_best.py index e0b53fc..dee6e80 100644 --- a/src/learn_to_pick/pick_best.py +++ b/src/learn_to_pick/pick_best.py @@ -325,7 +325,7 @@ def _call_after_scoring_before_learning( @classmethod def create( - cls: Type[PickBest], + # cls: Type[PickBest], policy: Optional[base.Policy] = None, llm=None, selection_scorer: Union[base.AutoSelectionScorer, object] = SENTINEL, From afef4a7bf0e18cad0321318e4fa121bc85b9e4a3 Mon Sep 17 00:00:00 2001 From: cheng Date: Sun, 12 Nov 2023 17:19:58 +0000 Subject: [PATCH 02/16] WIP: BYOM --- notebooks/news_recommendation_byom.ipynb | 183 ++++++++++++++++-- setup.py | 1 - src/learn_to_pick/__init__.py | 9 + src/learn_to_pick/byom/__init__.py | 0 src/learn_to_pick/byom/igw.py | 16 ++ src/learn_to_pick/byom/logistic_regression.py | 70 +++++++ .../byom/pytorch_feature_embedder.py | 87 +++++++++ src/learn_to_pick/byom/pytorch_policy.py | 54 ++++++ src/learn_to_pick/pick_best.py | 2 +- 9 files changed, 403 insertions(+), 19 deletions(-) create mode 100644 src/learn_to_pick/byom/__init__.py create mode 100644 src/learn_to_pick/byom/igw.py create mode 100644 src/learn_to_pick/byom/logistic_regression.py create mode 100644 src/learn_to_pick/byom/pytorch_feature_embedder.py create mode 100644 src/learn_to_pick/byom/pytorch_policy.py diff --git a/notebooks/news_recommendation_byom.ipynb b/notebooks/news_recommendation_byom.ipynb index c38e4c6..1d35c41 100644 --- a/notebooks/news_recommendation_byom.ipynb +++ b/notebooks/news_recommendation_byom.ipynb @@ -2,14 +2,138 @@ "cells": [ { "cell_type": "code", - "execution_count": null, + "execution_count": 12, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The autoreload extension is already loaded. To reload it, use:\n", + " %reload_ext autoreload\n" + ] + } + ], "source": [ - "# ! pip install ../\n", + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "huggingface/tokenizers: The current process just got forked, after parallelism has already been used. Disabling parallelism to avoid deadlocks...\n", + "To disable this warning, you can either:\n", + "\t- Avoid using `tokenizers` before the fork if possible\n", + "\t- Explicitly set the environment variable TOKENIZERS_PARALLELISM=(true | false)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing /home/chetan/dev/learn_to_pick\n", + " Preparing metadata (setup.py) ... \u001b[?25ldone\n", + "\u001b[?25hRequirement already satisfied: numpy>=1.24.4 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from learn-to-pick==0.0.3) (1.26.1)\n", + "Requirement already satisfied: pandas>=2.0.3 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from learn-to-pick==0.0.3) (2.1.1)\n", + "Requirement already satisfied: vowpal-wabbit-next==0.7.0 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from learn-to-pick==0.0.3) (0.7.0)\n", + "Requirement already satisfied: sentence-transformers>=2.2.2 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from learn-to-pick==0.0.3) (2.2.2)\n", + "Requirement already satisfied: torch==2.0.1 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from learn-to-pick==0.0.3) (2.0.1)\n", + "Requirement already satisfied: pyskiplist in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from learn-to-pick==0.0.3) (1.0.0)\n", + "Requirement already satisfied: parameterfree in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from learn-to-pick==0.0.3) (0.0.1)\n", + "Requirement already satisfied: filelock in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from torch==2.0.1->learn-to-pick==0.0.3) (3.12.4)\n", + "Requirement already satisfied: typing-extensions in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from torch==2.0.1->learn-to-pick==0.0.3) (4.8.0)\n", + "Requirement already satisfied: sympy in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from torch==2.0.1->learn-to-pick==0.0.3) (1.12)\n", + "Requirement already satisfied: networkx in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from torch==2.0.1->learn-to-pick==0.0.3) (3.2)\n", + "Requirement already satisfied: jinja2 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from torch==2.0.1->learn-to-pick==0.0.3) (3.1.2)\n", + "Requirement already satisfied: nvidia-cuda-nvrtc-cu11==11.7.99 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from torch==2.0.1->learn-to-pick==0.0.3) (11.7.99)\n", + "Requirement already satisfied: nvidia-cuda-runtime-cu11==11.7.99 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from torch==2.0.1->learn-to-pick==0.0.3) (11.7.99)\n", + "Requirement already satisfied: nvidia-cuda-cupti-cu11==11.7.101 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from torch==2.0.1->learn-to-pick==0.0.3) (11.7.101)\n", + "Requirement already satisfied: nvidia-cudnn-cu11==8.5.0.96 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from torch==2.0.1->learn-to-pick==0.0.3) (8.5.0.96)\n", + "Requirement already satisfied: nvidia-cublas-cu11==11.10.3.66 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from torch==2.0.1->learn-to-pick==0.0.3) (11.10.3.66)\n", + "Requirement already satisfied: nvidia-cufft-cu11==10.9.0.58 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from torch==2.0.1->learn-to-pick==0.0.3) (10.9.0.58)\n", + "Requirement already satisfied: nvidia-curand-cu11==10.2.10.91 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from torch==2.0.1->learn-to-pick==0.0.3) (10.2.10.91)\n", + "Requirement already satisfied: nvidia-cusolver-cu11==11.4.0.1 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from torch==2.0.1->learn-to-pick==0.0.3) (11.4.0.1)\n", + "Requirement already satisfied: nvidia-cusparse-cu11==11.7.4.91 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from torch==2.0.1->learn-to-pick==0.0.3) (11.7.4.91)\n", + "Requirement already satisfied: nvidia-nccl-cu11==2.14.3 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from torch==2.0.1->learn-to-pick==0.0.3) (2.14.3)\n", + "Requirement already satisfied: nvidia-nvtx-cu11==11.7.91 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from torch==2.0.1->learn-to-pick==0.0.3) (11.7.91)\n", + "Requirement already satisfied: triton==2.0.0 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from torch==2.0.1->learn-to-pick==0.0.3) (2.0.0)\n", + "Requirement already satisfied: setuptools in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from nvidia-cublas-cu11==11.10.3.66->torch==2.0.1->learn-to-pick==0.0.3) (68.0.0)\n", + "Requirement already satisfied: wheel in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from nvidia-cublas-cu11==11.10.3.66->torch==2.0.1->learn-to-pick==0.0.3) (0.41.2)\n", + "Requirement already satisfied: cmake in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from triton==2.0.0->torch==2.0.1->learn-to-pick==0.0.3) (3.27.7)\n", + "Requirement already satisfied: lit in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from triton==2.0.0->torch==2.0.1->learn-to-pick==0.0.3) (17.0.4)\n", + "Requirement already satisfied: python-dateutil>=2.8.2 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from pandas>=2.0.3->learn-to-pick==0.0.3) (2.8.2)\n", + "Requirement already satisfied: pytz>=2020.1 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from pandas>=2.0.3->learn-to-pick==0.0.3) (2023.3.post1)\n", + "Requirement already satisfied: tzdata>=2022.1 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from pandas>=2.0.3->learn-to-pick==0.0.3) (2023.3)\n", + "Requirement already satisfied: transformers<5.0.0,>=4.6.0 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from sentence-transformers>=2.2.2->learn-to-pick==0.0.3) (4.34.1)\n", + "Requirement already satisfied: tqdm in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from sentence-transformers>=2.2.2->learn-to-pick==0.0.3) (4.66.1)\n", + "Requirement already satisfied: torchvision in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from sentence-transformers>=2.2.2->learn-to-pick==0.0.3) (0.15.2)\n", + "Requirement already satisfied: scikit-learn in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from sentence-transformers>=2.2.2->learn-to-pick==0.0.3) (1.3.2)\n", + "Requirement already satisfied: scipy in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from sentence-transformers>=2.2.2->learn-to-pick==0.0.3) (1.11.3)\n", + "Requirement already satisfied: nltk in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from sentence-transformers>=2.2.2->learn-to-pick==0.0.3) (3.8.1)\n", + "Requirement already satisfied: sentencepiece in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from sentence-transformers>=2.2.2->learn-to-pick==0.0.3) (0.1.99)\n", + "Requirement already satisfied: huggingface-hub>=0.4.0 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from sentence-transformers>=2.2.2->learn-to-pick==0.0.3) (0.17.3)\n", + "Requirement already satisfied: fsspec in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from huggingface-hub>=0.4.0->sentence-transformers>=2.2.2->learn-to-pick==0.0.3) (2023.10.0)\n", + "Requirement already satisfied: requests in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from huggingface-hub>=0.4.0->sentence-transformers>=2.2.2->learn-to-pick==0.0.3) (2.31.0)\n", + "Requirement already satisfied: pyyaml>=5.1 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from huggingface-hub>=0.4.0->sentence-transformers>=2.2.2->learn-to-pick==0.0.3) (6.0.1)\n", + "Requirement already satisfied: packaging>=20.9 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from huggingface-hub>=0.4.0->sentence-transformers>=2.2.2->learn-to-pick==0.0.3) (23.2)\n", + "Requirement already satisfied: six>=1.5 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from python-dateutil>=2.8.2->pandas>=2.0.3->learn-to-pick==0.0.3) (1.16.0)\n", + "Requirement already satisfied: regex!=2019.12.17 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from transformers<5.0.0,>=4.6.0->sentence-transformers>=2.2.2->learn-to-pick==0.0.3) (2023.10.3)\n", + "Requirement already satisfied: tokenizers<0.15,>=0.14 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from transformers<5.0.0,>=4.6.0->sentence-transformers>=2.2.2->learn-to-pick==0.0.3) (0.14.1)\n", + "Requirement already satisfied: safetensors>=0.3.1 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from transformers<5.0.0,>=4.6.0->sentence-transformers>=2.2.2->learn-to-pick==0.0.3) (0.4.0)\n", + "Requirement already satisfied: MarkupSafe>=2.0 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from jinja2->torch==2.0.1->learn-to-pick==0.0.3) (2.1.3)\n", + "Requirement already satisfied: click in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from nltk->sentence-transformers>=2.2.2->learn-to-pick==0.0.3) (8.1.7)\n", + "Requirement already satisfied: joblib in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from nltk->sentence-transformers>=2.2.2->learn-to-pick==0.0.3) (1.3.2)\n", + "Requirement already satisfied: threadpoolctl>=2.0.0 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from scikit-learn->sentence-transformers>=2.2.2->learn-to-pick==0.0.3) (3.2.0)\n", + "Requirement already satisfied: mpmath>=0.19 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from sympy->torch==2.0.1->learn-to-pick==0.0.3) (1.3.0)\n", + "Requirement already satisfied: pillow!=8.3.*,>=5.3.0 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from torchvision->sentence-transformers>=2.2.2->learn-to-pick==0.0.3) (10.1.0)\n", + "Requirement already satisfied: charset-normalizer<4,>=2 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from requests->huggingface-hub>=0.4.0->sentence-transformers>=2.2.2->learn-to-pick==0.0.3) (3.3.1)\n", + "Requirement already satisfied: idna<4,>=2.5 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from requests->huggingface-hub>=0.4.0->sentence-transformers>=2.2.2->learn-to-pick==0.0.3) (3.4)\n", + "Requirement already satisfied: urllib3<3,>=1.21.1 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from requests->huggingface-hub>=0.4.0->sentence-transformers>=2.2.2->learn-to-pick==0.0.3) (2.0.7)\n", + "Requirement already satisfied: certifi>=2017.4.17 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from requests->huggingface-hub>=0.4.0->sentence-transformers>=2.2.2->learn-to-pick==0.0.3) (2023.7.22)\n", + "Building wheels for collected packages: learn-to-pick\n", + " Building wheel for learn-to-pick (setup.py) ... \u001b[?25ldone\n", + "\u001b[?25h Created wheel for learn-to-pick: filename=learn_to_pick-0.0.3-py3-none-any.whl size=22905 sha256=212caafaac49093734f8b40ad0fbc03ac97fa9af06f7166aaa7252166a0c4395\n", + " Stored in directory: /tmp/pip-ephem-wheel-cache-qsmxj9e8/wheels/18/bf/25/d8dda8a9a6b5284eaed510a4708ef9b22b9894a5e94b329ea2\n", + "Successfully built learn-to-pick\n", + "Installing collected packages: learn-to-pick\n", + " Attempting uninstall: learn-to-pick\n", + " Found existing installation: learn-to-pick 0.0.3\n", + " Uninstalling learn-to-pick-0.0.3:\n", + " Successfully uninstalled learn-to-pick-0.0.3\n", + "Successfully installed learn-to-pick-0.0.3\n" + ] + } + ], + "source": [ + "! pip install ../\n", "# ! pip install matplotlib" ] }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.0.1+cu117\n" + ] + } + ], + "source": [ + "import torch\n", + "print(torch.__version__)" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -25,13 +149,11 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 15, "metadata": {}, "outputs": [], "source": [ "import random\n", - "from typing import Any, Dict, List, Optional\n", - "import re\n", "\n", "users = [\"Tom\", \"Anna\"]\n", "times_of_day = [\"morning\", \"afternoon\"]\n", @@ -47,7 +169,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 16, "metadata": {}, "outputs": [], "source": [ @@ -91,23 +213,39 @@ }, { "cell_type": "code", - "execution_count": 39, + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "from learn_to_pick import PyTorchFeatureEmbedder\n", + "fe = PyTorchFeatureEmbedder(auto_embed=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, "metadata": {}, "outputs": [], "source": [ - "picker = learn_to_pick.PickBest.create(metrics_step=20, metrics_window_size=20, selection_scorer=CustomSelectionScorer())\n", - "random_picker = learn_to_pick.PickBest.create(metrics_step=20, metrics_window_size=20, policy=learn_to_pick.PickBestRandomPolicy(), selection_scorer=CustomSelectionScorer())" + "from learn_to_pick import PyTorchPolicy\n", + "\n", + "picker = learn_to_pick.PickBest.create(\n", + " metrics_step=100, metrics_window_size=100, selection_scorer=CustomSelectionScorer())\n", + "pytorch_picker = learn_to_pick.PickBest.create(\n", + " metrics_step=100, metrics_window_size=100, policy=PyTorchPolicy(feature_embedder=fe), selection_scorer=CustomSelectionScorer())\n", + "random_picker = learn_to_pick.PickBest.create(\n", + " metrics_step=100, metrics_window_size=100, policy=learn_to_pick.PickBestRandomPolicy(), selection_scorer=CustomSelectionScorer())" ] }, { "cell_type": "code", - "execution_count": 40, + "execution_count": 19, "metadata": {}, "outputs": [], "source": [ "# randomly pick users and times of day\n", "\n", - "for i in range(500):\n", + "for i in range(2500):\n", " user = choose_user(users)\n", " time_of_day = choose_time_of_day(times_of_day)\n", " picker.run(\n", @@ -115,10 +253,17 @@ " user = learn_to_pick.BasedOn(user),\n", " time_of_day = learn_to_pick.BasedOn(time_of_day),\n", " )\n", + "\n", " random_picker.run(\n", " article = learn_to_pick.ToSelectFrom(articles),\n", " user = learn_to_pick.BasedOn(user),\n", " time_of_day = learn_to_pick.BasedOn(time_of_day),\n", + " )\n", + "\n", + " pytorch_picker.run(\n", + " article = learn_to_pick.ToSelectFrom(articles),\n", + " user = learn_to_pick.BasedOn(user),\n", + " time_of_day = learn_to_pick.BasedOn(time_of_day),\n", " )" ] }, @@ -131,20 +276,21 @@ }, { "cell_type": "code", - "execution_count": 41, + "execution_count": 20, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "The final average score for the default policy, calculated over a rolling window, is: 1.0\n", - "The final average score for the random policy, calculated over a rolling window, is: 0.6\n" + "The final average score for the default policy, calculated over a rolling window, is: 0.95\n", + "The final average score for the default policy, calculated over a rolling window, is: 0.77\n", + "The final average score for the random policy, calculated over a rolling window, is: 0.58\n" ] }, { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiMAAAGdCAYAAADAAnMpAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAACZoUlEQVR4nOzdd3iTZffA8W/S3dJBKR2UQtl7b1G2IgoKDhAQBBUnLtzv6/bnfAH1VXAh41VRXKACgsjee29ooaUbSvdKk+f3x92EFkpp2qRJ2/O5Lq6W5Mnz3F3JyX2fc26dpmkaQgghhBAOonf0AIQQQghRu0kwIoQQQgiHkmBECCGEEA4lwYgQQgghHEqCESGEEEI4lAQjQgghhHAoCUaEEEII4VASjAghhBDCoVwdPYDyMJlMxMfH4+vri06nc/RwhBBCCFEOmqaRmZlJgwYN0OuvPv9RLYKR+Ph4IiIiHD0MIYQQQlRAbGwsDRs2vOr91SIY8fX1BdQX4+fn5+DRCCGEEKI8MjIyiIiIsLyOX43VwciGDRv4z3/+w+7du0lISGDx4sWMHDmyzMesW7eOadOmcfjwYSIiInjllVeYNGlSua9pXprx8/OTYEQIIYSoZq6VYmF1Amt2djadOnVi1qxZ5To+OjqaW2+9lYEDB7Jv3z6efvppHnzwQVauXGntpYUQQghRA1k9MzJs2DCGDRtW7uO/+OILmjRpwowZMwBo06YNmzZt4qOPPmLo0KHWXl4IIYQQNYzdS3u3bt3KkCFDStw2dOhQtm7detXH5Ofnk5GRUeKfEEIIIWomuyewJiYmEhISUuK2kJAQMjIyyM3NxcvL64rHvPfee7z55ptWXcdoNGIwGCo1VmFbLi4uuLq6Sjm2EEKIMjllNc3LL7/MtGnTLP83Z+NeTVZWFufOnUPTtKoYnrCCt7c3YWFhuLu7O3ooQgghnJTdg5HQ0FCSkpJK3JaUlISfn1+psyIAHh4eeHh4lOv8RqORc+fO4e3tTf369eVduJPQNI2CggJSUlKIjo6mRYsWZTa8EUIIUXvZPRjp06cPy5cvL3HbqlWr6NOnj03ObzAY0DSN+vXrXzW4EY7h5eWFm5sbZ8+epaCgAE9PT0cPSQghhBOy+q1qVlYW+/btY9++fYAq3d23bx8xMTGAWmKZOHGi5fhHHnmEqKgoXnjhBY4dO8bs2bP56aefeOaZZ2zzFRSRGRHnJLMhQgghrsXqV4pdu3bRpUsXunTpAsC0adPo0qULr732GgAJCQmWwASgSZMmLFu2jFWrVtGpUydmzJjBnDlzpKxXCCGEEEAFlmkGDBhQZqLo/PnzS33M3r17rb2UEEIIIWoBmUMXQgghhENJMCKEEEIIh5JgRAghhKiG1sasZc7BOZzLPOfooVRajQtGNE0jp6DQIf+sabr21Vdf0aBBA0wmU4nbb7/9diZPnoyLiwu7du0CwGQyERgYSO/evS3Hfffdd2U2ghNCCFEzFRgL+L9t/8eTa5/kkz2fMOy3YTz494Msi1pGXmGeo4dXIU7ZgbUycg1G2r7mmB2Bj7w1FG/38n1L7777bp544gnWrl3L4MGDAUhNTWXFihUsX76cAwcOsG7dOrp3787BgwfR6XTs3buXrKws6tSpw/r16+nfv789vxwhhBBOJj4rnmfXPcuhC4cAaF+vPYcuHGJ7wna2J2zH192XW5rcwqgWo2gb2LbatL2ocTMj1UXdunUZNmwYCxcutNz2yy+/EBQUxMCBAxkwYADr1q0DYN26ddx4442WHY/Nt0kwIoQQVafQVIjB6Lg90Dae28jopaM5dOEQfu5+zBo8ix+G/8CKO1fwaKdHCfMJI7Mgk0XHF3HP0nu4+8+7+f7o96TlpTlszOWl06rBhi4ZGRn4+/uTnp6On59fifvy8vKIjo6mSZMmeHp6omkauQajQ8bp5eZiVRT6888/M2XKFJKSkvDw8KB///50796dGTNm8McffzBx4kQuXLjA3XffzU033cSxY8fw9PTkySefJDw8nBMnTtCiRQs7fkWVd/nPRwghqqPDFw7z/PrnSctP49FOj3JP63tw07tVybWNJiOf7/+crw58hYZGu3rtmDFgBuF1wkscZ9JMbE/YzuKTi1kds5oCUwEAbno3BjUaxKjmo+gd1hsXvUuVjBvKfv0ursYFI9VJXl4eISEhzJs3jx49etC4cWN27dpF165dSUtLo169emzbto1hw4axadMmjh07xvvvv89TTz3Fc889R1xcnKO/hGuqzj8fIYTQNI2fT/zM+zvex2C6NCvSxL8Jz3d/nhsa3mDX66fmpfLihhfZlrANgDGtxvBCjxdwdyl789H0/HSWRy9n8cnFHE09ark91CeU25vdzu3NbyfC1/55hxKMVBOTJ08mIyODXr16MW/ePI4evfRL06VLFzp27Mjff/9NQkICqamphIWFcdddd6FpWoklHmdV3X8+QojaK8eQw/9t+z/+jPoTgIERA+nboC+z988mNS8VgBvCb+D5Hs/TxL+Jza+/L3kfz65/luScZLxcvXitz2sMbzrc6vMcvXCUJaeWsDRqKRkFGZbbe4X2YmSLkQxpNARPV/s8P5c3GKlxCazVzfjx4xk+fDiHDx/m3nvvLXHfgAED+PTTT7nrrrsACAwMpE2bNixatIhZs2Y5YrhCiBrGYDRwKu0UR1OPcuLiCdoEtuH25rc7elgOF50ezbR10ziVdgoXnQtPdn2Sye0mo9PpuKXpLXx14Cu+O/odG+M2sjV+K2PbjOWRTo/g5371F9zy0jSN745+x8xdMynUCon0i+SjAR/RvG7zCp2vTb02tKnXhmndp7E2Zi2LTy1ma/xWtiduZ3vidt51e5dbmt7CvW3uJdI/stLjrwgJRhxs0KBBBAYGcvz4ccaNG1fivv79+/Pxxx8zYMAAy20DBgxg//79JW4TQojyyDZkczz1OEdTj3Is9RjHUo9xKu0UhabCEsfV9axLv4b9HDRKx1t5ZiWvb3mdbEM2QV5BfNjvQ3qE9rDc7+vuy7Pdn+Wulncxfed01p1bx7dHvmXp6aVM7TKVO1vcWeG8jKyCLF7b8hqrzq4CYGjkUN687k183Hwq/XV5uHhwc5ObubnJzSRkJbDk9BJ+P/U7cVlxLDq+iBsb3+iwYESWaYRdyc9HCMdIzUvl2IVjJQKPsxln0bjyKd/P3Y82gW1AB9sTtuPv4c8vI34h1CfUASN3HIPRwMzdM/nu6HcAdA/pzn/6/4cgr6AyH7clbgsf7vyQ0+mnAWhZtyUv9niRnmE9rbr+iYsneHbds5zJOIOr3pXnuj/HuNbj7Fqea9JM7EzcyZqYNbzY80X0OtsW2UrOiHAK8vMRwv5S81LZm7xXBR1FAUhSTlKpxwZ7B9MmsA2tA1ur6fvANoT5hKHT6SgwFjDhrwkcuXCErsFd+WboN7jqa8cEemJ2Is+tf479KfsBuL/9/TzR5Ylyf/0Gk4Gfjv/E7H2zLXkZQxoNYVr3aeVKFP3z9J+8tfUt8ox5hHiHMGPADDrV71TxL8hJSDAinIL8fISwr81xm3lm3TPkFuZecV9jv8a0DmytAo+iAKSeV70yzxebEcvopaPJMmQxpcMUnuz6pL2G7jS2xm/lxQ0vcjH/Ir5uvrxz/TsMbDSwQudKy0tj1r5Z/HziZ4yaEXe9OxPbTeTBDg+WutSSb8zngx0f8POJnwHoE9aH9/u9T6BnYKW+JmchwYhwCvLzEcJ+1sSs4bn1z2EwGWjs15jO9TvTpp4KOlrVbUUd9zoVOu+KMyt4fv3z6NDxxZAvuC78OhuP3DmYNBNfHfiK2ftmo6HRJrANMwbMsEnJ68mLJ/lw54eWktz6XvV5qutTjGg2wrIUci7zHNPWTeNo6lF06Hik0yM83PHhKu0DYm8SjAinID8fIexjRfQKXtr4EkbNyI2Nb+SDGz7AzcV2Tbje3vo2P534iUDPQH4Z8Qv1vevb7NzOIC0vjZc3vcymONXV+s4Wd/Jyr5fxcPGw2TU0TWNd7Dqm75pOTGYMoNq3v9jzRdLz03l508tkFmQS4BHAeze8x/Xh19vs2s5CghHhFOTnI4TtLTm1hNe3vI5JMzG86XDe7vu2zXM78o35jFs2jhMXT9AztCdf3fhVlb5jLzQVMnvfbBKzEy35La0CW9mkdPZgykGeXf8sCdkJeLh48GrvV+1azlxgLOD7o9/z5YEvyTZkl7ivY1BHpvefTlidMLtd35EkGBFOQX4+QtjWomOL+L/t/weod/Ov9XnN5hUQZtHp0YxZOobcwlwe6/QYj3Z+1C7XuZzBaODFjS9ayluLC68TTpvANpblqDaBbco9a6NpGouOL+KDnR9QaCqkkW8jZg6YSavAVrb+Ekp1Pvc8n+79lMUnF6OhMbb1WJ7v/rxNZ7ScjQQjwinIz0cI21lweAHTd00HYHyb8bzY40W778r65+k/+demf6FDx5yb5lhdrmqtfGM+z657lvXn1uOmd+Oe1vcQlxnHsdRjxGfHl/qYep71aF2vNW0D21oClIa+DUt8b3IMOby59U2WRy8HVKXLW33fwtfd165fT2lOXTxFpiGTLsFdqvzaVU06sAohaozYjFj8Pf1tMkVfHWmaxlcHvuKzfZ8B8ED7B3iq61NVsj38iGYj2Jm4k8WnFvPixhf5ZcQv16zIqagcQw5PrX2KbQnb8HDx4JOBn9A3vK/l/vT8dEvPlCMXjnAs9RhnMs5wIe8Cm+M2szlus+XYOm51aBXYijaBbWge0Jxvj3zL6fTTuOhceKbbM0xsO7FKvn+lqWgn1ZpMZkZqgUmTJpGWlsaSJUuq/Nry8xGVteLMCl5YrzYGG9xoMKNajKJnaE+7LU04G03T+GTPJ3xz6BsApnaeykMdH6rSF9IcQw7jlo3jdPpprmtwHZ8P+dzm3/+sgiweX/04e5L34OXqxazBs0p0Pb2a3MJcTlw8YemvcjT1KCcvniyxqZ1ZsFcw/+n/H7qGdLXp2MXVycyIEKLai8mI4Y0tb6ChkW/MZ3n0cpZHLye8Tji3N7+dkc1G1tjEP1CByAc7P+D7o98D8Fz357iv3X1VPg5vN2+m95/O2GVj2RK/hbmH5vJghwdtdv70/HQe/edRDp4/iK+bL7OHzKZzcOdyPdbL1YtO9TuVaBBmMBmISouyzKIcSz1GqE8oz3Z/9prdVIVjSDDiJAoKCnB3L3tLaCFqkwJjAc+tf45sQzZdg7vybPdn+f3U7yyPXk5cVhyz983m832f06dBH0Y1H8WgRoOuua16dWI0GXl729v8evJXAF7p9QpjWo9x2Hia123Ov3r9i9e2vMZnez+ja3BXm8wwXMi9wMOrHub4xeMEeATw5Y1f0rZe20qd003vRqvAVrQKbMXtyKZ/1UHtmOd0QgMGDGDq1Kk8/fTTBAUFMXToUGbOnEmHDh3w8fEhIiKCxx57jKysLMtj5s+fT0BAACtXrqRNmzbUqVOHm2++mYSEBMsxRqORadOmERAQQL169XjhhRe4fCUuPz+fJ598kuDgYDw9Pbn++uvZuXOn5f5169ah0+lYuXIlXbp0wcvLi0GDBpGcnMxff/1FmzZt8PPzY9y4ceTk5Nj/myWqVGJ2Ik+seYKVZ1Y6dBwzds3gaOpRAjwC+KDfB3Ss35FX+7zKmtFrePf6d+kZ2hMNjS3xW3h+w/MM+nkQ721/j2Opxxw6blsoNBXyyuZX+PXkr+h1et7u+7ZDAxGzkc1HMrzpcIyakRc2vEBaXlqlzpeck8z9K+/n+MXj1POsx9yhcysdiIjqqeYFI5oGBdmO+Wdl+s2CBQtwd3dn8+bNfPHFF+j1ev773/9y+PBhFixYwJo1a3jhhRdKPCYnJ4fp06fz7bffsmHDBmJiYnjuuecs98+YMYP58+czd+5cNm3aRGpqKosXLy5xjhdeeIFff/2VBQsWsGfPHpo3b87QoUNJTU0tcdwbb7zBZ599xpYtW4iNjWX06NF8/PHHLFy4kGXLlvH333/z6aefWvkDEs7ugx0fsC52HS9ueJEtcVscMobVZ1ez8NhCAN65/p0SG7Z5uXoxotkIvhn6DcvvWM5DHR8ixDuE9Px0Fh5byN1/3s3oP0fzw7EfSM9Pd8j4K8NgNPDChhdYGrUUV50rH9zwASObj3T0sADQ6XS80vsVIv0iScpJ4t+b/33Fm53yis+KZ9KKSUSlRxHiHcL8m+fTom4LG49YVBc1L4G1IBvebeCYgf4rHtzLt83zgAEDyMjIYM+ePVc95pdffuGRRx7h/PnzgJoZmTx5MqdOnaJZs2YAzJ49m7feeovExEQAGjRowDPPPMPzzz8PQGFhIU2aNKFbt24sWbKE7Oxs6taty/z58xk3bhwABoOByMhInn76aZ5//nnWrVvHwIED+eeffxg8eDAA77//Pi+//DKnT5+madOmADzyyCOcOXOGFStWXPVrkATW6mV7wnYe/PtSLoCPmw8Lbl5QZX0YAOKy4rj7z7vJLMhkUrtJPNv92Ws+xmgysi1hG4tPLWZNzBpL8qK73p3BjQczqvkoeoX1cvqk13xjPtPWTWPDuQ246d2Y3n86gxoNcvSwrnA89Tjjlo2jwFRQoTyWmIwYHvz7QRKyEwivE86cm+bQ0LehnUYrHKm8CazO/ZdZw3Xr1q3E/80v/uHh4fj6+jJhwgQuXLhQYinE29vbEogAhIWFkZycDEB6ejoJCQn06tXLcr+rqyvdu3e3/P/06dMYDAb69r1ULufm5kbPnj05evRoifF07NjR8nlISAje3t6WQMR8m/naovorNBXy/o73AdVMq0doD7IN2Ty++nGSskvfAdbWDEYDz69/nsyCTDrW71juTdpc9C70De/L9P7TWXP3Gl7q+RIt67akwFTAX9F/8dCqhxj26zA+3/c5yTnO+TubY8hh6uqpbDi3AQ8XDz4d9KlTBiIArQJb8WLPFwH4ePfHHEg5UO7Hnk47zaQVk0jITiDSL5L5N8+XQETUwARWN281Q+Goa1vBx+fSLMqZM2cYPnw4jz76KO+88w6BgYFs2rSJBx54gIKCAry91bnd3Ep26tPpdBWeJr2W4tfS6XSlXttkMtnl2qLq/XLiF06lncLfw59nuj0DwIS/JhCdHs3UNVOZf/P8UncdtaVP9nyiKircffmw34e46a3vTBngGcD4NuMZ13ocR1KPsPjkYpZHLSc+O57Z+2cz7/A8Hmj/APe1uw9PV+eYrSte1urt6s1ngz8rV1mrI93d8m62J2zn77N/8/z65/lpxE/4e/iX+Zhjqcd46O+HuJh/kRZ1W/DVjV9JdYsAauLMiE6nlkoc8a8Sdf+7d+/GZDIxY8YMevfuTcuWLYmPty6o8vf3JywsjO3bt1tuKywsZPfu3Zb/N2vWzJKnYmYwGNi5cydt20riWG2Vnp9uaaj1eOfH8ffwx9/Dn9mDZxPoGcix1GM8t/45Ck2FdhvD+tj1LDiyAIC3+75NeJ3wSp1Pp9PRrl47Xun9CmtGr+GDG1QSbG5hLp/t+4zbl9zOyjMr7RbMl1d6fjpT/p7CnuQ9+Lr58tVNXzl9IALq+/vGdW/QsE5D4rPjeX3L62V+Lw+mHOT+lfdzMf8ibeu1Ze5NcyUQERY1Lxipppo3b47BYODTTz8lKiqKb7/9li+++MLq8zz11FO8//77LFmyhGPHjvHYY4+RlpZmud/Hx4dHH32U559/nhUrVnDkyBGmTJlCTk4ODzzwgA2/IlGdzN43m/T8dJoHNOfulndbbm/o25BZg2fh6eLJprhNvLf9Pbu8eCdmJ/Lvzf8GVJvzwY0G2/T8nq6e3NL0Fr4b9h0f9vuQEO8Q4rPjeW79c0xaMYmjF45e+yR2cCH3AvevvJ9DFw4R4BHAnKFzSvTLcHa+7r5M7z8dV70rq2MuJR1fbnfSbqasmkJmQSad63dmzk1zCPAMqNrBCqcmwYiT6NSpEzNnzuSDDz6gffv2fP/997z33ntWn+fZZ59lwoQJ3HffffTp0wdfX19GjRpV4pj333+fO++8kwkTJtC1a1dOnTrFypUrqVu3rq2+HFGNnLp4ikXHFwHwYs8Xr9j9tX1Qez7o9wE6dPx04ifmH55v0+sXmgp5YcMLpOen07ZeW6Z1m2bT8xen0+kY1mQYf476k8c6PYaniyd7kvcwZukY3tjyBhdyL9jt2sVlFGSw6NgiJvw1gRMXT1DPsx7zhs6rlmWt7YLa8Ww3lWQ8Y9cMDl84XOL+rfFbeWTVI2QbsukZ2pMvb/zSIfvBCOdW86pphFORn49z0zSNh1c9zNaErQyKGMQngz656rHfH/3ekuD6n/7/4ebIm20yhk/2fMKcg3Oo41aHn4b/RIRfhE3OWx6J2YnM3D2Tv6L/AtR+Jg93fJjxbcbbfCdVk2ZiZ+JOfjv5G6tjVpNvzAcgxDuEOTfNIdI/0qbXq0qapvHU2qdYG7uWCN8Ifhr+E3Xc67A+dj3T1k2jwFTA9eHX89GAj5wmT0dUDdm1VzgF+fk4t7Uxa3ly7ZO46d34/fbfrxkIfLDjA747+h3uenfmDJ1T6V1HN8dt5pF/HgFsG+BYa2/yXt7f8T5HLhwBoLFfY57r/hz9G/av9B4wCVkJLDm9hN9P/U5cVpzl9uYBzbmjxR3c1uy2ayZ+Vgfp+enc/efdJGQncHPkzQxpPISXNrxEoVbI4EaD+bDfhzWqQ64oHwlGhFOQn4/zKjAWMPL3kcRmxvJghwd5qutT13yM0WTkmXXPsDZ2LQEeAXx3y3c09mtcoeun5KRw1593kZqXyuiWo3m1z6sVOo+tmDQTv5/6nU/2fMKFPLVc0yesDy/0eMHqXVYLjAWsiVnD4lOL2Rq/FQ31NFvHrQ63NLmFO1rcQdt6bR22a6y97E/Zz6S/JlGoXUp0HtZkGO9c/06FKqNE9SfBiHAK8vNxXnMPzeWj3R9R36s+f476s9xlu7mFudy/QiVdNvJtxHe3fEddT+vyjYwmIw+teogdiTtoWbcl39/yvdNM32cVZPH1wa/59si3GEwGXHQujG412lJlVJZjqcdYfHIxy6KXlej+2jO0J6NajGJwo8F4uXrZ+0twqHmH5jFz90wARjUfxet9XsdF7+LgUQlHkWBEOAX5+Tin87nnufW3W8kpzOGd69/htma3Wf34e5ffS1xWnKqOGDoHDxePcj/+832fM3v/bLxcvVg0fBFN/JtY+yXYXWxGLDN2z2B1zGoA/D38eazTY4xuNbpEkm96fjrLo5ez+ORijqZeqsoJ8Q5hZPOR3N78diJ8qy4PxtFMmom5h+birnfn3rb3On3XW2FfEowIpyA/H+f06uZXWXJqCR2COvDdLd9V6AUjKi2Ke/+6l8yCTIZGDuXDfh+W6zw7Enbw4N8PoqHx7vXvMqLZiIp8CVVmW8I2PtjxAafSTgEq1+P57s+j0+lYfHIxq2NWU2AqAMBV78qgiEHc0eIOeof1lhkBUeuVNxipeR1YhRBlOnT+EEtOLQFUKW9F37k2DWjKJwM/4aFVD7HyzEoa1GlwzbLcC7kXeHHji2hojGo+yukDEYDeYb35ecTP/HriVz7b9xmn0k7x8D8PlzimZd2W3NHiDm5pcovVS1ZCCOkzIkStomka7+1Q/WtGNB1R6QZbPUJ78NZ1bwEqV+Cn4z9d9ViTZuJfm/7F+dzzNPNvxks9X6rUtauSq96VMa3HsHTUUu5tcy+uOld83XwZ02oMPw7/kV9G/ML4NuMlEBGigmRmRIhaZFn0Mg6kHMDL1Yunuz1tk3OOaDaCuKw4Zu2bxTvb3yHUJ5R+DftdcdzcQ3PZEr8FTxdPpvefjreVezk5A38Pf17s+SJPdX0KvU4vpapC2IjMjAhRS+QYcvho10cAPNTxIYK9g2127oc7PsztzW7HpJl4bv1zV7RX35O0h8/2qr1v/tXrX1aXyjobT1dPCUSEsCEJRsQ1vfHGG3Tu3NnRwxCV9M2hb0jOTSa8TjgT2k6w6bl1Oh2v93mdXmG9yC3MZerqqSRmJwJwMe8iz294HqNmZHjT4YxsPtKm1xZCVH8SjFRTkyZNYuTIkY4ehqgm4rLimH9oPgDPd3/eqjLc8nJzceOjAR/RPKA5ybnJPLb6MTILMnll8ysk5yQT6RfJK71fqXGNvoQQlSfBSC1XUFDg6CGIKjBj1wwKTAX0Cu3FoEaD7HYdX3dfZg+eTZBXECcvnuSOP+5gw7kNuOvdmd5/erkbqwkhahcJRhxkwIABTJ06lalTp+Lv709QUBCvvvoqmqbx1ltv0b59+yse07lzZ1599VXeeOMNFixYwO+//45Op0On07Fu3ToADh48yKBBg/Dy8qJevXo89NBDZGVlWc5hnlF55513aNCgAa1atQLg3LlzjB07lsDAQHx8fOjevTvbt28vcf1vv/2WyMhI/P39ueeee8jMzLTfN0jYzM7Enaw6uwq9Ts8LPV+w+8xEWJ0wZg2ehZerl2Wp5sWeL9IqsJVdryuEqL5qXDWNpmnkFuY65Nperl5WPdEvWLCABx54gB07drBr1y4eeughGjVqxP3338+bb77Jzp076dGjBwB79+7lwIED/PbbbwQHB3P06FEyMjKYN28eAIGBgWRnZzN06FD69OnDzp07SU5O5sEHH2Tq1KnMnz/fct3Vq1fj5+fHqlWrAMjKyqJ///6Eh4fzxx9/EBoayp49ezCZTJbHnD59miVLlrB06VIuXrzI6NGjef/993nnnXds8J0T9mI0GS077d7d8m5a1m1ZJddtW68t0/tP56WNL3FT45u4u+XdVXJdIUT1VOOCkdzCXHot7OWQa28ft92qcsWIiAg++ugjdDodrVq14uDBg3z00UdMmTKFoUOHMm/ePEswMm/ePPr370/Tpk0B8PLyIj8/n9DQUMv5FixYQF5eHv/73//w8VHT4Z999hkjRozggw8+ICQkBAAfHx/mzJmDu7uqBvjqq69ISUlh586dBAYGAtC8eclqB5PJxPz58/H19QVgwoQJrF69WoIRJ/fryV85cfEEfu5+TO08tUqv3a9hPzaM2VCidboQQpRGlmkcqHfv3iVmUvr06cPJkycxGo1MmTKFH374gby8PAoKCli4cCH3339/mec7evQonTp1sgQiAH379sVkMnH8+HHLbR06dLAEIgD79u2jS5culkCkNJGRkZZABCAsLIzk5GSrvl5RtdLz0/l076cAPN75cQI8A6p8DBKICCHKo8Y9U3i5erF93PZrH2ina9vKiBEj8PDwYPHixbi7u2MwGLjrrrtscu7iwQqoWZZrcXMruf23TqcrsYwjnM8X+78gLT+N5gHNGd1qtKOHI4QQV1XjghGdTldtOjteniC6bds2WrRogYuL2lzrvvvuY968ebi7u3PPPfeUCBrc3d0xGo0lHt+mTRvmz59Pdna2JeDYvHkzer3ekqhamo4dOzJnzhxSU1PLnB0R1cfptNP8cOwHAF7o8YLMUAghnJos0zhQTEwM06ZN4/jx4/zwww98+umnPPXUU5b7H3zwQdasWcOKFSuuWKKJjIzkwIEDHD9+nPPnz2MwGBg/fjyenp7cd999HDp0iLVr1/LEE08wYcIES75IacaOHUtoaCgjR45k8+bNREVF8euvv7J161a7fe3CfjRN48OdH2LUjAyMGEifBn0cPSQhhCiTBCMONHHiRHJzc+nZsyePP/44Tz31FA899JDl/hYtWnDdddfRunVrevUqmZQ7ZcoUWrVqRffu3alfvz6bN2/G29ublStXkpqaSo8ePbjrrrsYPHgwn332WZnjcHd35++//yY4OJhbbrmFDh068P7771tmaET1suHcBrbEb8FN78Zz3Z9z9HCEEOKadJqmaY4exLVkZGTg7+9Peno6fn5+Je7Ly8sjOjqaJk2a4Onp6aARWm/AgAF07tyZjz/++KrHaJpGixYteOyxx5g2reyt2Z1Vdf35VFcGo4GRv48kJjOG+9vfzzPdnnH0kIQQtVhZr9/FyUKyk0pJSeHHH38kMTGRyZMnO3o4opr4/uj3xGTGEOQVxEMdH7r2A4QQwglIMOKkgoODCQoK4quvvqJu3bqOHo5wcpqmsSF2G//dMxuAp7s+La3XhRDVhgQjDmJu33411WD1TDiBpOwkfj/9O0tOLSE2MxYALS+CIK5z8MiEEKL8JBgRopoxGA2sjV3L4lOL2RK/BZNW1O/F5EFBeicKzg/h/vm7+HJCNwa0CnbsYIUQohwkGBGimjhx8QSLTy5mWdQyLuZftNzeLaQbofp+/Li2LhF1/WnVwpd/jiYz5X+7+GxcV4a2Cy3jrEII4XgVKu2dNWsWkZGReHp60qtXL3bs2FHm8R9//DGtWrXCy8uLiIgInnnmGfLy8io04KuRZQ3nJD+XyskoyOCn4z9xz9J7uPOPO/nu6HdczL9IsFcwD3Z4kKWjljJv6Dx2H2oGmjuTrmvC7PHduLVDGAajxmPf7+GP/fGO/jKEEKJMVs+MLFq0iGnTpvHFF1/Qq1cvPv74Y4YOHcrx48cJDr5ySnjhwoW89NJLzJ07l+uuu44TJ04wadIkdDodM2fOrPQXYO6FUVBQUK625qJq5eTkAFe2kxdXZ9JM7ErcxW+nfuOfs/+Qb8wH1D4vAyMGMrL5SK5rcJ2lq+rGkymcTM7Cx92Fu7s3xN1Vzyf3dMbDVc9ve+N46se95BmMjO4e4cgvSwghrsrqYGTmzJlMmTLFUm76xRdfsGzZMubOnctLL710xfFbtmyhb9++jBs3DlCdQ8eOHXtFK/SKcnV1xdvbm5SUFNzc3NDrpY+bM9A0jZycHJKTkwkICJAGauWQmJ3IklNLWHJqCXFZcZbbmwc0Z1TzUQxvNpxAzyvb9c/bfAaAu7tH4Oepgj5XFz3T7+6Ep7sLC7fH8MIvB8gzGJnYJ7IqvhQhhLCKVcFIQUEBu3fv5uWXX7bcptfrGTJkyFVbh1933XV899137Nixg549exIVFcXy5cuZMGHCVa+Tn59Pfn6+5f8ZGRlXPVan0xEWFkZ0dDRnz5615ssRVSAgIIDQUMlZuJoCYwFrYtew5OQStsRvQUMta9Vxq8OwJsMY1XwU7YPal9jdubjo89msOZaMTgf3XRdZ4j69Xsc7I9vj6erC3M3RvPb7YfIMRh7q18zeX5YQQljFqmDk/PnzGI3GK/Y5CQkJ4dixY6U+Zty4cZw/f57rr78eTdMoLCzkkUce4V//+tdVr/Pee+/x5ptvlntc7u7utGjRgoKCgnI/Rtifm5ubzIhcxfHU4yw+tZilUUtJz0+33N4jtAejmo9iSOMh5doFesGWMwAMbBVMk6Ar+4rodDpeHd4GL3c9s9ae5t3lx8gtMPHk4OZXDXCEEKKq2b2aZt26dbz77rvMnj2bXr16cerUKZ566inefvttXn311VIf8/LLL5dof56RkUFERNnr3Xq9XtqNC6eWnp/OX9F/sfjUYo5cOGK5Pdg7mNub3c6o5qOI8Ct/XkdGnoGfd6neIpP7Rl71OJ1Ox/NDW+Pl5sL0v0/w0T8nyDUYefHmVhKQCCGcglXBSFBQEC4uLiQlJZW4PSkp6apT8a+++ioTJkzgwQcfBKBDhw5kZ2fz0EMP8e9//7vUHA8PDw88PDysGZoQTsmkmdiRuIPFJxezOmb1Fcmod7S4gz5hfXDRWz+D9NPOWLILjLQIrsP1zYOuefzUQS3wcnfl7aVH+GL9afIMRl4b3ha9XgISIYRjWRWMuLu7061bN1avXs3IkSMBMJlMrF69mqlTp5b6mJycnCsCDvPUvZR9ipoqISuBJaeX8Pup30sko7ao24I7mt/BrU1vpa5nxdv8G00aC7aeAWBS38hyz3A8cH0TPN30/HvxIeZvOUOewcg7ozrgIgGJEMKBrF6mmTZtGvfddx/du3enZ8+efPzxx2RnZ1uqayZOnEh4eDjvvfceACNGjGDmzJl06dLFskzz6quvMmLECMknEDVKvjGftTFr+e3kb2xL2GZJRvV18+WWprcwqvko2tZra5OlkdVHk4hNzcXfy407ujS06rHjezXG09WF53/Zz487Y8k1GJlxdydcXaQSTQjhGFYHI2PGjCElJYXXXnuNxMREOnfuzIoVKyxJrTExMSVmQl555RV0Oh2vvPIKcXFx1K9fnxEjRvDOO+/Y7qsQwoGOpR7jt5O/sSxqGRkFlyq/eob2ZFSLUQxuNLhcyajWMJfz3tMzAi9364P6O7s1xNPNhad+3Mvv++LJN5j479guuLtKQCKEqHo6rRqslWRkZODv7096ejp+fn6OHo7T2x51ge+3x/CvW9oQ6i9JvfZyNuMsL2x4oUQyaoh3CCObj+T25rcT4WufJmNHEzIY9slGXPQ6NrwwkPCAigc6/xxJ4rHv91BgNDGwVX0+v7cbnm4Vn7E0mjSiz2dzOD6dI/EZnErOonWYL3d3iyCylGofIZzd+ax8DsdncCgunSMJGYQHePHSza2dItfqu21n2XAihVahvrRr4E+7Bn40rOvlVInp5X39lr1pahhN03hlySFOJmdh0jQ+G9fV0UOqsX47+RtHLhzBTe/GoEaDGNV8FL3DelcoGdUa84tmRW5uF1qpQARgSNsQvpnUnSn/28Xa4yncP38nc+7rjrf7tZ8a8guNnEzK4nB8OofiMjgcn87RhExyDcYSx60+lsystafp2SSQMd0jGNYhtFznF6IqaZrGuYu5HI5Xv8vmj0kZ+Vcce33zIPq1rO+AUV6SnJnHG38cptCk8feRS0Ul/l5utA3zo10DP9qF+9G+gT9N69dx+rwweUaoYXafvcjJ5CwAlh5I4NEB6bRr4O/gUdVMUWlRADzX/TnGtRlXJddMzS5gyT6VEFtWOa81bmhRnwWTe3L//J1sOX2Bid/sYO7kHpZurgBZ+YUcTcjgcFw6h+IzOByfwcmkTApNV06serm50DrMl/YN/IkM8mHjyRQ2nEhhR3QqO6JTef2Pw4zo1IDR3RvSOSLAqd7FidrBaNKISsniUHw6h+PU7/ORhAzScw1XHKvTQZMgH9o18Od8Zj5boy7ww44Yhwcjv+w+R6FJo1l9H7o1rsvh+AxOJGWSnmtga9QFtkZdsBzr6aandWhRgFI0g9Iq1LdSs6C2JsFIDbNwewwArnodhSaNmX+f4JtJPRw8KueiaRpHEjJoHlwHD9eK/zGeTj8NqHbtVeWHHTHkF5roEO5Pt8YVr8a5XK+m9fjuwV7cN3cHu85e5N452xnWPoxDRcstZy5kU9qCboC3W4knuHYN/GgSVPJd2APXNyEhPZdfd5/jp13niEnN4YcdMfywI4YWwXUY3T2CUV3DCaoj5fzCPk6nZLE9KtUy43EsMYM8g+mK49xcdLQM8S3xO90mzA8fD/VSeTwxk6Efb2DVkSSSM/MI9nXMMrjJpPHjDtVj6OH+zSz7ThUUmjiRlMmRYrM7RxIyyCkwsi82jX2xaZZzuOh1tAiuQ9tiX2vHhv4Om7WUnJEaJC2ngJ7vrqag0MRHYzrx3M8HMJo0fn30Opu+cFV3n605yfS/T9C4njf/vqUNN7YNsfrdeV5hHr0W9sKkmVg7ei1BXtfu81FZBqOJGz5YS2JGHjNHd+KOrtZV0ZTH4fh0Jnyzg9TsK7sZh/l70q6BH22Lnrjah/vTwN/Tqu+dyaSxPTqVn3fFsvxQguUFwVWvY3CbYEZ3j6B/y/pS2SMqLSu/kKX74/lpVyx7YtKuuN/b3eXSckYDf9o28KNliO81k7jv/HwLu89e5PmhrXh8YNW9ESlu48kUJnyzA19PV3b8a0iZSewmk0b0hWzLstORopnN0v7G503uwcBWV254WxmSM1IL/bYnjoJCE23C/BjZOZxtp1NZtCuW6SuP88NDvR09PKeQmWfgqw1qeeXshRwe+nY31zcP4tXhbWkV6lvu85zNOItJM+Hn7kc9z3r2Gm4Jfx1KJDEjj6A6HtzaMcwu12jXwJ9FD/XmraVH8Pdyo324CjzahvlRzwYzF3q9jj7N6tGnWT3euL0dS/cnsGhXLPtj01h5OImVh5MI9vXgzm4NubtbQ5rWr2ODr0rUFpqmsfPMRX7aFcuyAwmW/CUXvY5eTQLp0NDfMgvQpJ5PhZJQx/ZsxO6zF/lxZwyP9m/mkERW8wz4qC7h16ym0+t1NKtfh2b163BbpwaA+j4lpOeVyI85Ep9BuwaOe7MvwUgNoWkaP+xQv6DjejVCp9Px5JAWLN4bx9aoC2w+dZ6+5ejSWdMt3B5DRl4hTev7MKx9KF9vjGbTqfPc8t+NjO/ViGeGtKSuj/s1z3M6TS3RNAtoVmU5D/M2RwNwb+9GlVpeupYWIb58+0Avu53fzM/TjXG9GjGuVyOOJ2by065YFu+NIzkzn8/XnebzdafpGRnI3d0bckuHMMtUuRCXS8rI49c95/h51zmiz2dbbm9a34cxRcuAtlpSGd4xjLf+PExsai6bTp2v8tyR5Mw8VhUlrI7r1ahC59DpdDQI8KJBgBc3tg259gOqgPx11xC7ihJXvdxcuL2zin7DA7wY16sR87ec4T8rj3Nds3q1Olkwz2Bkzib1gv5o/2bc3T2CMd0b8e7yo6w4nMj/tp7l933xPDOkBeN7N8atjKWCqHQ1u9LUv2mVjH1vzEX2xqTh7qJnfK/GVXLNqtQq1JdXh7flxZtbs+ZYEj/tOse648nsOJPKjjOpvPHHYZ69qRX3X9/E0UMVTqKg0MSaY8n8tCuWdceTMedSe7u7MLxjGGN6RNC1UV2bP+d5urlwR9eGzN9yhoXbqz6R9eddKnG1S6MAWofWnLQFCUZqiB+Kpu1u69SgRBXEYwObsWhnLPti0/jnaLLTRMGO8Mvuc6Rk5tPA35PbO4cD0KieN19M6MaW0+d5688jHEvM5I0/j/D99hheHd72qk80VR2MmJucDe8URn3fmpvo6e6q5+b2YdzcPozEdPO73VjOXMixLB3d2c32uTKi+jiRlMlPO9Us2oVieQ/dG9dldI8Ibq2CWbSxPdWbvH+OJpGckUewX9UksppMGj/uLJoB71mxWRFnJVliNUBaTgFLDyYAMPayabtgX08mFZWAzvj7OKZSSjFrg0KjiS83qKWVKf2aXpGkdl2zIJY9eQPvjGpPoI87J5OzmDh3Bw/M30lUStYV5yu+TGNviel5LC/6+d7ft/bMDIT6e/L4wOasfW4AD/dXQd9Lvx1gy+nzDh6ZqGoZeQYWbo9h5KzN3PTRBuZsiuZCdgH1fT14pH8zVj/bn18evY7R3SOqZDmvVagv3RrXpdCk8fPuc3a/ntmmU+eJTc3F19OV4R0bVNl1q4IEIzWAOXG1bZgfnRpe2VPk4X5N8fVw5VhipiVoqW2WHUwgNjWXQB937ulR+jsKF72O8b0as/a5ATxwfRNc9TpWH0tm6McbeGfZETLyVA8Cg8lATIZ6d1IVMyPfbTtLoUmjR2Rd2ofXvp4xOp2OF4e2ZnjHMAxGjYe/3c3JpExHD0tUgT0xF5n20z56vvMP/1p8kH2xabjqddzUNoQ5E7uz9aVBvDSsNc0ckOhsnpn4YUdMlb3JM+cF3lGOxNXqRoKRak7TNBYW/YKOLUpcvVyAtztT+qkXzY9WnaDQeGV9fU1mMmnMXqtmMu7vG3nNP2J/LzdeHd6Wlc/0Y2Cr+hiMGl9vjGbgf9bx444YzqTHUKgV4u3qTahPqF3HnmcwWn6+k2vRrMjl9Hod0+/uRPfGdcnMK2TSvJ0kZ+Y5eljCTs5dzOHxhXu4Y/YWftsTR57BRLP6PvzrltZsfXkwX03szpC2IQ4tAb+1Yxh+nq6cu5jLxlP2n60rnrh6+Qx4TSDBSDW36+xFThUlro7sfPVpu/uvb0KgjzvR57P5dU/VTSs6gzXHkjmelEkdD1cm9Iks9+Oa1a/DvMk9mTe5B03r+3Ahu4CXfjvIlB+WAWpWxN4JwX/siyc1u4DwAC9uqsX5PqASB7+a2J0mQT7EpeXy4IJd5BQUOnpYwoZyCgqZ+fdxBs9Yz7IDCeh0cEfXcH599Dr+mdafh/o1c5qcKXMiK8DC7Wftfj1z4mrXGpa4aibBSDW3sFjiqm+xxNXL1fFw5bEBKr/hk39Okl9ovOqxNYmmacxedwqA8b0b4e919e/R1QxsFczKp/vx2vC2+Hm6Ep99BoDkVH9iU3NsOdwSNE1jblE578Q+jaURGBDo4868ST2o6+3GgXPpPPnDPoy1NA+qJtE0jSV74xg0fT3/XXOK/EITvZsGsuyJG5g5ujPdGtu+KsYWzKW1/xxNJjnDfjN1JRJXa2A1HUg1TbV2MbuAZUU5IOWpN7+3d2O+3hhFfHoeC7fH1Ipp/+3RqeyJScPdVc8DlSgLdXPRc//1TRjZJZxxv/9GnAFik3wZPHM9LwxtxQPXN7H5k+W2qFSOJWbi5eZy1TyX2igyyIc593Vn7Nfb+edoEm8vPcIbt7Vz9LCslppdwDOL9nEsMcMm5wv29bS05G/bwJ82Yb7VYkPCfbFpvPnnYfYWdUltWNeLf9/ShpvbhzplAFJcyxBfujeuy66zqtHa1EEt7HKd4omrt3awT8NDR3P+31RxVb/tvZS42rGUxNXLebq58OTgFvx78SFmrT3FmB4R1eLJqjJmr1O5Ind3a2iTpkeBPu74+qZCKrSs25xDF0z837Kj7D57kQ/v6ljm7JS1zE3O7ugajr+37c5bE3RrHMhHozvz+MI9zN9yhkaB3tWqB4nJpDHtp32sP5Fis3MmZeRzMC7d8n+9DprWr2MJUMydRwO8r93UryokZeTx4YrjlmVjb3cXHh/YnAeub+JUG7hdy9iejdh19iI/7IjlsQHN7dKR1TwDfmfXhjUucdWsZr8S1WCaplnWKcddJXG1NKO7R/Dl+ihiUnOYv+UMjw1wzN4KVeFQXDobTqTgotfxcD/blOAaTUai01WQMOvum9lwROOtpUf461AixxIzmT2+K23CKr+eG5uaw6qjKlnNVrvz1jS3dgwjLq017y4/xtvLjtAgwIub29s3odhW5myKYt3xFDxc9XwxoRv1K9lqX9Mg9mKOpbX3obgMzmflcyo5i1PJWfy+L95ybHiAV8nNDcP9CPWzbo+hysgzGPlmUzSz1p4ip0AtF9/RNZwXb25NSBX167ClWzuG8eafh4lLy2XDyRQG2Hhvl+SMPP4pei4YW8N6ixQnwUg1tfPMRU6nZOPtfqnjanm4ueh5ekgLpv20ny/WnWZ8r8YVyqOwRnquga2nzzOwdbBd25hfzpwrMqJjGI3qedvknPFZ8eQb83HXu9PQtyET+rjQoWEAj3+/h+jz2YyavZn/G9mBuyrZmGvBljNoGtzQIojmweXfM6e2mXJDU2JSc/huWwxPL9rLD3696dLIuTeF3BNzkQ9XHAfg9RHtbLYxWYeG/txSbAo/OaPk3iOH4zOISc0hLi2XuLRc/i6qzAA143f57suRFdy75Wo0TWPFoUTeWX6UcxdzAejSKIDXR7Sjc0SAza5T1Yp3ZP1hR4zNg5Gfd6vE1W6N61q1f1Z1I8FINWWeFblW4mppbu8czufrTnMyOYs5G6N49qZW9hgioBp2jZuzjaiUbG7pEMqscV2r5B3Y6ZQs/jqUCMCjNpz9MXdebeLfBBe9Cqw6RwSw9InreXqRmnZ/7uf97DqTyhu3tavQdHN2fiGLdqntwWtTk7OK0Ol0vDGiHXEXc1l7PIUHF+xi8WN9bRZ82lp6joEnFu6l0KQxolMDxvaMsNu1gv08CfbzZGDrSy+O6bkGy/by5t1bT6VkkZpdwMaT59l48lKJqo+7i2V7+bZFAUqL4GvvaluaI/EZvLX0MNuiUgEI9fPkpWGtub1zA6fPCymP8b3MHVmTScrIs9kMj8l0ac+xmjwrAhKMVEsXswtYXvRCW5FfUBe9jmdvaskj3+1h7qZoJl0XaZMdWS8Xm5rD+DnbiSmqOFl+MJHvt8dwb2/7Z4N/uf40mgZD2gTb9N3E6XSVg3J5s7O6RVUen609xUf/nODHnbEcjEvn8/HdrH5h/HXPOTLzCmka5EP/Kt73ojpyddHz2biujP5yK4fjM5g0fwe/PXqd0+RGmGmaxnO/7CcuLZfIet68O6p9lb8Q+3u5WXZNNsszGDmemMmhYjMoxxIyyC4wsvPMRXaeuWg51t1FT4uQOrRv4E+7cBWgtAnzu2ru2YWsfGasOsGPO2IwaeDhqufhfk15ZECzGpWv1iLElx6Rddl55iI/2zCRdeOp85y7mIufpyvD7bRTt7OoOb8Ntcive85RUGiiXYPyJa6WZmi7UDqE+6sXzHWneWV4W5uOMfp8NuO/3kZ8eh6NAr0Z1j6ULzdE8dbSI3RpFEC7BvbrJJqQnsvivXGAbWdF4FIb+KYBV3Ze1et1PDm4BV0aBfDUj/s4HJ/B8E83MmN053LvCWQyaZZ9aO67LtIh25NXRz4ersyd1IORszYTlZLNw9/u5n8P9KzSZcFrmb/lDKuOJOFeFDzZMtm5MjzdXOgUEUCnYkslhUYTUeezORyfzqG4S0s9mXmFloCFXepYnQ6aBPlYlnjaN/CnZWgd/tgXzyerT5KZp3rB3NoxjJeHtaZhXeectaqssT0bsfOMSmR9dEBzXGzwt2vec+yOrg2rVVJvRUgwUs1o2qVpO2sSVy+n06nZkUnzdvK/bWd54IYmhPl72WSMJ5IyGT9nOymZ+TSr78P3D/YmxM+DU8lZrD6WzBML9/LHE9dTx057SHy9IRqDUaN300C6NbZt/oA5ebWsPWluaFGfZU9ez+Pf72FPTBpT/reLR/o347mbWl6zV8j6EylEn8/G18NVNoSzUoifJ/Mm9+Cuz7eyPTqVF385wEdjOjvFMsCBc2m8u/woAP++tY3Tt/V3ddHTMsSXliG+jOqibtM0jXMXc0vkoByOTycpI5+olGyiUrL5c3/8Fedq18CP10e0o2eTwCr+KqrWLR3CePPPI8Sl5bLRBomsyRl5liT28rRuqO6ki1I1syM61ZK4elunym2U1L9lfXpGBlJQaOLTNadsMr5DcemM+XIrKZn5tA71ZdHDfQj1V5n60+/uRJi/J1Hns3ll8UE0zfbNqlKzCyzBmq0rhTRNuzQzco09acL8vfjxoT6WSpgv1p9m/Jzt12xhbm5yNqZHhN2CtZqsdagfn9/bFVe9jiX74pm56oSjh0RGnoGpC/diMGrc3C6UiX2qZ9MqnU5HRKA3N7cP49mbWjF3Ug+2/2sIO/89hPmTe/D80Fbc2iGMyKJlyaA67nxwZwf+mHp9jQ9EwJzIqnYDN5fiVsbPu89hNGl0b1yXliE1N3HVTIKRasb8Qnt7Z+sTVy+n0+l4bqhKXv1pZyxnL2RX6nx7Yi4y9uttXMwx0LGhPz8+1JugYrkodX3c+XRsF1yKXih+3mX7tvTzN0eTazDSPtyPG1oE2fTcSTlJ5BTm4KpzpZHvtd+puLvqeX1EO2aN64qPuwvbo1O59b+b2B51odTjTyVnsvHkefQ6tUQjKuaGFvV5Z1R7AD5dc4qfdsY6bCyapvHybweJSc2hYV0vPriro1PM1NhSfV8PBrQK5vGBzZk1vivrnh/I4TeHsv1fQxjTo5FNliuqC/PmeauPqUTWiqpNiatmEoxUI5VNXC1NzyaB9GtZn0KTxsf/nKzwebZFXWDCnO1k5hXSvXFdvnuwV6kJhN0jA3n2ppYAvPbHIU7YcPfVrPxC5m85A6hZEVs/6UelqUqaRn6NcHMpfyB4a8cw/njielqG1CElM59xc7bzxfrTV8wMmXNFhrQJISKwZq6rV5UxPRoxdaCaGfvX4oNsPGm75mLW+H57DMsOJOCq1/HZuK52L6N3Fj4errUqCDEzJ7IaTVqlguANJ1Msiau31vDEVTMJRqoRc+Jq+3A/OjYMsNl5nysKDpbsi6tQcLD+RAqT5u0gu8DIdc3q8b8HeuJXxqzNI/2a0a9lffIMJh7/fo/NNjtbuP0sGUVVKEPb2b751dUqacqjWf06LHm8L3d0Ccdo0nj/r2M89O1u0nMNgCr5/G2PSrqtDW36q8KzN7Xk9s4NKDRpPPbdHpu1XS8vVc56BICXhrWu1r00RPmZ8zt+3Blb4X2TzLMitSFx1UyCkWpC0zTLVvK2nrbr2DCAm9uFomkw82/r1thXHUliyoJd5BlMDGxVn7mTelyzZE+v1zFzdCeCfT04mZzFG38crszwAcgvNDJno8q3eGRAM7u8KyurkqY8vN1dmTG6E++Mao+7i55VR5K47bNNHI5P58edMeQajLQO9aV305q/vl4VdDodH97VkZ5NAsnML+T+eTsrNXVujaz8QqYu3ENBoYnBrYMrtS+SqF6GtQ/D38vN0pHVWkkZefxzNBmoHYmrZhKMVBM7olOJsnRcDbf5+afd1BKdDlYcTuTAubRyPebP/fE8+t1uCowmVbo7oXu5o/igOh58ck8X9Dr4adc5Fu+tXP7Ir7vjSM7MJ8zfk5F2+P5AsUoa/4q3ltfpdIzv1ZhfHu1DeIAXZy/kMGr2Fr5YrwKd+/vafsO92szD1YWvJnSjaX0f4tPzmDxvJ1n5tpmJuxpN03hl8UGizmcT5u/J9Ls7yc+0FvF0c+HOrqoSriKJrD/viq1ViatmEoxUEwuLJa7ao8qiZYiv5UV8ejlmR37ZfY6nflSdJEd2bsCnY7tY3ZmxT7N6PDlYNQf69+JDnE7Jsn7gqJ4I5hfzKTc0rVCHyGvRNI1TaariqKIzI8V1bBjAsievZ1DrYAoKTVzMMRDo485tVrT2F+UT4O3O/Ek9qefjzpGEDMZ+tY29MRev/cAK+nnXOZbsi8dFr+PTsV2o6+NczdeE/Y3rpTrrrjmWTGJ6+WfjjCaNH3bEFp2j9syKgAQj1cLF7AL+OqgSV8f1tF9Z4NNDWuCq17HhRMpVKz4Avtt2lud+3o9Jg3t6RDBjdOdr9s+4micGtaBP03rkFBh5/Ps95BmMVp9j2cEEYlJzqOvtxj12aq99Ie8CGQUZ6NAR6Rdpk3MGeLszZ2J3nh/aCn8vN567qVWtWR+uao3qeTPnvu74erhyMC6dUbO3MG3RPqteKMrjRFImr/1xCFA5K90jZcmtNmoe7EvPyECVyLqr/ImsG0+mEJeWi7+XW4l9hmoDCUaqgV/3nKPAqBJXO1Sw42p5NK7nw+ge6sV8+t/HS+0DMmdjFK8sUU+2k66L5L07OlQqP8NFr+OTezpTz8edY4mZvF2U8Fdemqbx+To1KzK5bxO7tZg2L9GE1wnH09V2O4vq9ToeH9icfa/dWOveCVW1Lo3qsvrZ/pZNDH/bG8fA6ev4bM3JCgXBl8u1BNQm+rWszyM22ilaVE9ji2ZHFlmRyLrQ0nE1vNa9MZFgxMkVT1y156yI2RODmuPuqmfnmYusP1Ey+eqzNSf5v2Wqi+SjA5rx+oi2NlkLD/bzLOqUqUohlx64sovj1aw9nsyxxEx83F24r09kpcdyNebk1bI6r1aG5BRUjWA/lcPx++N96doogFyDkel/n2DIzPUsP5hQqUZ8r/9xiJPJWQT7ejBzdCdp5V/LlUhkPXHtRNakjDxWHytKXK0lvUWKk2DEyW0vSlz1cXepknyCMH8vJhRtZGeeHdE0jQ9XHLPkkky7sSUvDG1l0xfQfi3r89gA9UL/8q8Hy92AbfZaFSTc27sx/t726+FQ2Uoa4Vw6RQTw66PX8ck9nQnz9+TcxVwe+34P93y1jcPx6Vafb/Hec/y06xx6HXxyT5cSzf5E7VQikXXHtRNZfyqaQekRWZcWtShx1UyCESdnnra7rXN4lbUHf2xAM3zcXTgUl8FfhxJ5a+kRZhcthfz7ljY8ObiFXd7JPzOkJT0i65KZX8jUhXvJLyx76nxHdCq7zl7E3VVv99JJ8zJNRXqMCOek0+m4vXM4q5/tz5ODW+Dhqmd7dCrDP93Ey78d5HxWfrnOczoli38vVkuXTw5uUWJHXFG7lTeR1WjS+HFn7UxcNZNgxImlZhew4pA5cbXqfkHr1fHg/qIX92cW7bN0Bn379nZM6We/F2NXFz3/HduFut5uHIxL5/2/jpV5/Ky1qrrlrm4NCfazXR5HacwNzypT1iuck7e7K9NubMma5wYwolMDNE01nRr4n3XM2RhFQaHpqo/NMxiLGvcZ6dO0Hk/YaOt4UTMUT2RdVEZH1g3FEleHta9diatmEow4sV93q8TVDuH+dk1cLc2DNzTFz9OV/EITeh38566OTLBjToZZmL8XM0Z3AlR79JWHE0s97lBcOutPpKDXwcN2DJAA0vPTOZ97HpBlmposPMCLT8d24aeH+9A+3I/M/EL+b9lRbv54A2uOJZWaT/L20iMcS8wkqI47n9zTuVa2QBdlM890LNoZc9VE1h+KZsDvrEUdVy8nwYiT0rRLGyU5YtrO38uNt0e2p0mQD5/c04W7u9unZLY0g1qHMOUGNTPz/M/7OXcx54pjPi/qKzK8YwMa1/Ox63jMSzQh3iH4uNn3WsLxejYJ5PfHr+fDOzsSVMedqPPZ3D9/F5Pm7eRU8qXtEpYeiOf77THodPDRmM52n50T1dPN7UMJ8HYjPj2P9SeSr7i/ROJqr6p7nnU2Eow4qW1RqUSdV4mrIzo5phHW7Z3DWVs0dV3Vnh+q9vLIyCvkiR/2YjBemiqPPp/NXwcTAFXVY2/2rqQRzsdFr2N0jwjWPjeAh/s3xc1Fx/oTKQz9eCNv/HGYA+fSeOnXg4DKsbqhRX0Hj1g4q5IdWa9cqjEnrvaMDKR5cO1LXDWTYMRJmWdFbu9SdYmrzsTdVc+nY7vg5+nK3pg0pq88brnvy/WnMWkwuHUwbcL87D6WymyQJ6o3X083Xh7WhlXP9OfGtiEYTRrzt5zhts82k5VfSI/IujwzpKWjhymc3Nie5kTWJBLScy23F09cHVuLZ0VAghGn5KjEVWcTEejNh3ep/JEvN0Sx9lgyCem5/LpH7WPz2MCqmamISo8CJF+kNosM8uHrid357oFetAypA0Bdbzf+O7ZLhbsPi9qjebAvPZsEYtLgp52X9uGSxNVL5K/ICZkTVzs29Kd9eNUmrjqbm9uHMum6SACm/bSP9/86hsGo0bNJIN0aV02r7ag0FYxIJY24vkUQy5+8gS8ndOO3x/oS5u/l6CGJasL8xrJ4IutCSVy1kGDEyRRPXB1bi2dFinv5lta0D/fjYo6B3/ep7qyPVUGuCECOIYeEbJWfIss0AlQJ+tB2oTQJkmRmUX43tw+lbrFE1sT0PNZI4qqFBCNOpnji6m0OSlx1Nh6uLnw2tqsld6ZdAz/6t6yahEFzJU2gZyABngFVck0hRM1TMpE1hp92SeJqcRKMOJmFxRJXfWph4urVRAb58Mk9nWkV4strw22zJ055WJqdSSWNEKKS7ima7V5zLJn/bT0L1N6Oq5eTVzsnciErn5WSuHpVg9uEMLhNSJVe05wvIks0QojKah5ch15NAtkencr5rHwCvN24uX2oo4flFGRmxIn8ukcSV52NlPUKIWyp+EyIJK5eIsGIE/nniEpmGl2F3U5F2SyVNLJMI4SwgZvbhxLs64Gbi06KFIqRZRonYTRpHCraurxnk6opWRVlyzfmcy5L9QSQYEQIYQseri78+uh1ZOQZaB5cx9HDcRoSjDiJ6PNZ5BQY8XJzoVl9+QV1BmfSz2DSTPi6+1LPU7aFF0LYRkSgt6OH4HRkmcZJHIxTsyLtGvjJzp9Owtx5tZl/syqr3hFCiNpIghEnceCcCkYkcdV5WIIRWaIRQgi7kmDESRwqmhnpIMGI0zDv1tvEv4mDRyKEEDWbBCNOwGjSOByfAUDHhhKMOAuppBFCiKohwYgTMCeveru70FSSV52CwWTgbKbqkCgb5AkhhH1JMOIEzPkibcMkedVZxGbGUmgqxMvVi1Af6ZAohBD2JMGIEzBX0kjyahUxmSBmGxgNVz2keBt4qaQRQgj7kmDECZiTVyVfpIpsnAFzh8Kmj656iFTSCCFE1ZFgxMGKJ69KJU0VMBpg59fq86N/XvUwqaQRQoiqI8GIg0WlSPJqlTqxArKS1OeJByEntdTDijc8E0IIYV8VCkZmzZpFZGQknp6e9OrVix07dpR5fFpaGo8//jhhYWF4eHjQsmVLli9fXqEB1zTmfBFJXq0iu+YV+48GZzZecYjRZCQ6PRqQZRohhKgKVgcjixYtYtq0abz++uvs2bOHTp06MXToUJKTk0s9vqCggBtvvJEzZ87wyy+/cPz4cb7++mvCw8MrPfiawByMdJB8Efu7eAZOr1Gft7hJfYxaf8Vh8dnx5Bvzcde7E15Hfk+FEMLerN4ob+bMmUyZMoXJkycD8MUXX7Bs2TLmzp3LSy+9dMXxc+fOJTU1lS1btuDm5gZAZGRk5UZdg0jn1Sq053+ABk0HQtf74OTfEL3hisPMlTSR/pG46F2qeJBCCFH7WDUzUlBQwO7duxkyZMilE+j1DBkyhK1bt5b6mD/++IM+ffrw+OOPExISQvv27Xn33XcxGo2VG3kNYDRpHIqT5NUqYTTA3u/U590mQeT1oNPDhZOQEV/iUMkXEUKIqmVVMHL+/HmMRiMhISElbg8JCSExMbHUx0RFRfHLL79gNBpZvnw5r776KjNmzOD//u//rnqd/Px8MjIySvyriaJSssg1SPJqlTj+l0pc9QmG1reCVwCEdVb3XTY7YqmkCZBKGiGEqAp2r6YxmUwEBwfz1Vdf0a1bN8aMGcO///1vvvjii6s+5r333sPf39/yLyIiwt7DdAhzvki7BpK8ane7ixJXu4wHF7VcSJN+6uNleSMyMyKEEFXLqmAkKCgIFxcXkpKSStyelJREaGjpLbPDwsJo2bIlLi6X1t7btGlDYmIiBQUFpT7m5ZdfJj093fIvNjbWmmFWG+Y28NJ51c6KJ652ve/S7U37q4/R60HTANA0TRqeCSFEFbMqGHF3d6dbt26sXr3acpvJZGL16tX06dOn1Mf07duXU6dOYTKZLLedOHGCsLAw3N3dS32Mh4cHfn5+Jf7VRJK8WkV2L1Afmw6EwGJLLxG9wcUdMuIgVQUgSTlJZBuycdG50Mi3kQMGK4QQtY/VyzTTpk3j66+/ZsGCBRw9epRHH32U7OxsS3XNxIkTefnlly3HP/roo6SmpvLUU09x4sQJli1bxrvvvsvjjz9uu6+iGireeVXawNtR8cTV7pNL3ufuDQ17qs+j1qkPRZU0jfwa4WZezhFCCGFXVpf2jhkzhpSUFF577TUSExPp3LkzK1assCS1xsTEoNdfinEiIiJYuXIlzzzzDB07diQ8PJynnnqKF1980XZfRTVUPHm1SZAkr9rN8eWQnawSV1vdcuX9TfvD2U1qqabHA5Ylmqb+Tat4oEIIUXtZHYwATJ06lalTp5Z637p16664rU+fPmzbtq0il6qxzPkidklezUqGU/9Ah9HgUqEfcc2xe7762OXeS4mrxTXpB2vfgeiNYDJxOl1V0kgwYgOFBXBkCTTsUXJ5TAjhXM5sgoO/wPCPwEG7lNfyVyrHMVfS2CV5dcljcGoVZCbADc/a/vzVRWr0pcTVbveVfkx4N3CvA7mpkHTIskwjyauVZMiDn+9TewF5BsCE39T3WgjhPC6ehVWvwpHf1f+b9IP2dzhkKLJRnoOYk1dtni9y8YyaFQHY8bXKmait9vxPfWw2COpGln6Mixs0vg4ALWqdzIzYQkE2/DBGBSIAeWmw4HY4W3pjRCFEFcvPgtVvwWc9VCCi00OPB6FJf4cNSYIRByievGrzShpzy3NQMyPmiLe2KdFxdXLZxxb1G0mNXkt6fjo6dET6R9p3fDVVXgZ8d5dKCHbzgbGLIPIGKMiE7+6wJAoLIRzAZIJ9P8Cn3WDjDDDmq+e/RzbBrTPAp57DhibBiAOctlfyavEX4PDu6uO2z213/urEnLhaJwRaDSv72KJ3A1GJewAIrxOOl6uXvUdY8+SkwrcjIWYLePjDxN+h1c0w7idoNhgMOfD9aDix0tEjFaL2id0J3wyBJY9AVqKaLR7zPUz8A0LaOXp0Eow4wkFzs7MG/rZNXi3e8nzMt6qHRtwu9UtY2+wyd1y9SuJqcSHtwSuQKF0hAE0DZInGalkpsOA2iNsNXoFw3x8Q0UPd5+4NY3+AVreqd2I/jq+9M3ZCVLWMePjtIRWIxO1WOXJD3oDHd0Cb4Q5LWL2cBCMOYLfk1d3FXoD9GkD7u9T/t9ey2ZHUaIhaC+ig68RrH6/XQ5MbOF20q7S0gbdSRgLMvxWSDqpAeNIyaNC55DGuHjB6AbS/E0wG+HkyHPjJIcMVolYw5ML6/6glmQOLAB10vhee2A3XP6P+Jp2IBCMOYOm82tCGnWWLtzw3V470fkR9PPL7FTvT1mh7ijqulpW4erkm/YlyV8GIzIxYIS0G5g2D88fBLxwm/wUhbUs/1sUN7vhaPSFqRvVuzVx6XRXy0mHbF+rdoRA1labB4cXwWU9Y+39qeTSiF0xZAyNngW/pW7c4mgQjVcxuyau7S3kBDusEja4DUyHsnGO7azmzwoJiiauTyv+4pgOIclOV7k29G9h+XDXRhdMw7xa4GA0BjVUgEtS87MfoXeC2T1XmPhr8+ZQKEOzJZFRBz3+7wooXVWVPUft/IWqUhP1qlvLnSZAeo94g3PkN3L8Swrs6enRlkmCkipmTV31smbxaVuWIeXZk1zw1bVfTHV8O2SnlS1wtJqNOECmuRcFI5nl7ja7mSD6mApH0WKjXAu5fAXUbl++xej3cMh2ue0L9f8WLsHGmfcZ5ZjN81V8FPTnnQe+qKnt+ngyF+fa5phBVLSsF/ngCvuwPZzeDqxf0fwmm7oIOdzlNXkhZJBipYgctnVdtmLxaVuVIq1vBP0I19Tr4s22u58x2W5G4WkxUejQAIYWF1InZbo+R1RwJB2D+LSojP7gdTF6ucpSsodPBjW+rJ0yA1W/CmncsuydX2sWz8NNENc7Eg+DpDze/r56cvepCwj5Y9bptriWEoxQWwJZP4dOul9o6tL8LntgFA19WyePVhAQjVcwuyatlVY64uELPKerzbV/Y7sneGaVGFfWxKGfiajGWPWkMBojeYPux1RTndsOC4ZBzARp0gUlLoU5wxc6l06knzCFvqP9v+BD+fqVyv6P5WbD67ZLNnLo/AE/shd6Pqrb0I4sSurd/DkeXVvxaQjhSQbbK1/r7FcjPgLDOMHkF3PUN+Dd09OisJsFIFTto6+TV8lSOdJ0Ibt6QfBjObLTNdZ1RaXkz5XQ6TXVebVZgUO+ac9NsOrQa4ewW+N/tKhE0opfqI+IdWPnzXv8MDPtQfb71M1j2rGrOZA2TCfYvgs+6w8bpJZs5DZ9ZsplTq2HQp2hvrd8fU0m4QlQnJiP88oBq3eAZALfPgilroXEfR4+swiQYqUJGk8YRS/JqgG1OWp7KEa+60Gms+tzeyYKOUlgA+75Xn3e/RsfVUlhmRtwDQTOpjaPEJafXwLd3qHyLJv3g3t/U0oet9HoYRvwX0MGub+CPqeoJtzzO7YJvboTFD6muw+Vp5jT4dbVXTl46/HJ/7d42QVQvmgYrXoITf4GrJ4z/Wc2K66v3y3n1Hn01Uzx5tWmQT+VPaE3lSK+iRNbjy9VsSk1zfFlR4mootLzZ6oebN8hrGtpF3SBLNZcc/wsWjoHCXGh+o+qo6mHDzsFm3e6DO74CnYsKLH99sOwgISMefnsY5gxW7xDd66gg47Ht127m5OoOd81VnWLP7VT7dAjnYjLCzm9g7/eOHolz2TYbdnwF6NTfS0RPR4/IJiQYqUIHiiWv6m2RvGpN5Uj9lqolN5raQK+mMfersDJxFSDHkEN8turD0qzpjerG6PU2HFw1dngxLLoXjAXQejjc8z242bFVfsfRcPd80LvB4d/gp/uurHox5MIGczOnH9VtncerZk43TAM3z/Jdq24k3P6Z+nzLf+HE37b6KkRlZaXAt6Ng2TS1lHagFiTfl8eRP2Dlv9XnN70NbW937HhsSIKRKnSp2ZmNpretfQHu/aj6uPdbyM+0zRicwYXTFU5cBYjOUDNFgZ6BBDQfqs6TcgwyE206zGpn/49qCcNUCB3uhrsXVE3Xxra3wT0LwcVDzXj9cA8U5BQ1c1qimjmtKd7MaS2MnF2xZk5tb4OeD6nPFz8M6XE2/VJEBcRshy/7Fb0hKHrTtvRp9Xdem53bBb9NATTVp8ec91RDSDBShSzJq7aopEmNsq7lOaiZkXrNVeb1voWVH4M18jLsd+49/1Mfmw8uf6+LYixLNP5NVUJmWEd1R3QNTva9ll3zYPEjKn+mywQY9aWqzKoqLW+C8T+pxOvTa+C7O4uaOd1n+2ZON/2fahCYm1q0NFRom6+hPAy5zpWvUpDtuPFoGmydrcqxM+MhqKVKQG7cFwqy1M/ekOeYsTlaanTRUmmeWoa++YNq0TvEGhKMVJFCo8mSvGqTsl7zC7A1lSN6/aXcke1fWl+xUFH/vAHvR8CSx9U7XFsqnrh6ecO3crJU0gQU7UnTpJ/6GL2ukoOrprbOVu9E0aBnUWKp3qXqx9F0AExYDB5+aifgs5tVwl7/l2DqTts1c3L1gLvmgbuvus669yp/zmvRNFX99UETWDCi/Mm69pQRD590hhmtYNfcqh1TXoYKNla+rGbi2t2h2peHtoc754B3PdUv5u9Xqm5MziInFb6/WzXtC+ukgvCqfGNQRSQYqSKnU7Jtl7xaPHHV2sqRTmNV0l7qaTi1qnLjKI+jS2HTR+rzfd+pqgdbTreWSFwdWqFTWCpp/Iv2pGkyoOiODTW7L0tpNkxXLwgAfZ+CYR84Nku/UW9VQhzcTi0VTTU3c7JBAnhx9ZrBiI/V5xtnXNrnyR4KcmDJY/DnkyopOGbrpao4R/rnDdU8MecCLH2maKmkChK5kw7D1wNVXxi9Gwz7T1Fysa+636+BmpkD2Pm1WqqrLQqLdrm+cBL8GtovedwJSDBSRcxLNO3CbZC8Wjxx1drKEY860HWC+nybnXfzTYtRyWcAbW4Dn/qQdAi+GqASsWzB3PCt6wSrE1fNLMGIeYO8xn1U2/D0GLUBYW2gaapZ2Jq31f8H/AuGvOkcU8HhXeGxLeodckCE/a7T4a6iqjRNbeKXmWT7a5w/BXOGwP6FqiFbs0Hq9tVvQ+5F21+vvGJ3FO3sCvR9WvWuSDqkZm0W3Wu/Crx9P8DXg+HCKfViO/kv6PXQlb93LW5UwTGotuc1sSLwciaTClpjtqjZwfE/O+0md7YgwUgVOWTLfBFLy/MKvgD3nKKeCKPWqj1G7MFoUMmPeemqn8Od38DDGyCit8pZ+WmCygqvzPr0hdOXktwqkLgKkG/MJzYzFoBm/kXLNO4+0LCH+rw2VNVomvpZbJyu/n/j2zDgRecIRKraze+rWZjsFPjtQdsuVRz5XQXiyYdVYD7xd/VOt35rla+y7gPbXcsaJhP89aL6vPO9cOOb8ORe6DFFlVkf/RNm9YJ/3rRd4rshT+0XtOQRNTvUbFDR80OPqz9m0KvQsKd6/vjlfjVDXJOtfQcO/aLeGI3+39V3w64hJBipIjZLXq1Ey3OLupHQ6hb1+XY7NUFb87bq3+Dhr9bjXd3VdOukpZeywLd+pt55ZSRU7Brmqe3mQyCgUYVOcTbjLCbNhK+7L0FeQZfuaNJffYyq4cGIyaTKJ7fNUv+/ZTr0fdKxY3IkNy9VWuzmrZYoNs6o/DmNBljxL7VXTkEmNOoDD29UuUkubnBzUY7Kjq/s9+agLPt/gPg9Kmdm8GvqNu9AuHW6SiBtOkB1tN00Ez7trpLfK5NvdvEMzL2pqBpQBwNehvG/lOySWxoXN9Xq3DNAjfefNyo+Bme353+X3hyM+C80G+jY8VQBCUaqQKHRxOF4G+1JY255XsHKEQtzme/+H1WClC2d+Bs2f6I+Hzmr5Dhd3GDoOzD626LExK3w5Q3Wr00XFlxqhnSthm9lKF5Joys+E2BJYq3BeSPGQrWMtmsuoIPbPru0j1FtVr8l3Fq0i/C69yrXjTcjHuYPvxTsXfcE3Pcn+IVdOqbZIPXmQDOqfJ2q/H3Ly7j0ot7/efANKXl/SFuYsATu+QHqNlGbIy55VDWai91h/fWO/6VyURL2g1cg3PsLDHip/AnSAY1UGTeo7+mx5daPwdmdWg1/Pq0+7/8idBnv0OFUFQlGqsDplGzyDKbKJ6/aoHLEonFfCOmgpkjNlTm2kB6n+jWAqsRoM6L049reBg+tg5D2akr8f7er5MnyvuM6tlRll/uGVajjqtnp9Msqacwa9lDvjnPOQ/KRCp/faRkN8OsD6l2xzkXlY5hziQR0HqsaqWkmtQdI9nnrzxG1Tr3wxm5TgfeY71QZcWlLqzf9H7i4q8TZEysrPfxy2zhDJa0GNr1UaXc5nQ5a3wKPb4cb31IzKPF7VDL6r1PK15vFWKiCnh/uKVq67Q6PbFSzmtZqfSv0LspFW/IopMVaf46KykmF9HP2O3/iIdXoTzNCx3vUrFEtIcFIFbBZ8qoNKkcsdDroXfTks+Nr2/RWMBaqPg25qaoE7aa3yz6+XjN4YNWlJ/01b8OPY8uXyGdp+DahUmVuJXqMFOfqrqbToea1hjfkwaIJcGSJql4YvUAlb4qSbvkPBLVSswGLHy5/oGwyqQ6x345Sf68h7VXgfbXAHNTfgvkFduXLVZMPceG0ai0OMPTdaze0c/VQSaRP7FZ/d+jg4E9qc8J1H1y9bD8zCb4deamqrufDKlG1MjvLDnlT7Rqdl6aC6qrojXL8L/hvZ/ioHcy7RSXfFmTb7vwZ8bBwtFrKi7wBbvu0VuVtSTBSBQ6eSwNskC9ig8qREtrfBd5BkHFOzTRU1vr3Vea3u29Rnkg5unW6e6sdJ2/7VHXcPLFCvZuM33v1x5RIXK3cu/krynqLMy/V1KS8kYIc9e7UvMnW2B/LfpGszdx9VP6Iqyec+ge2fHLtx+Skwg9jVIdYzaQSQh/8RwUb19LvOVUhlxplv1yu4v5+VbX5bzbIutlF3xDVRv+hdSpgN+TAundhVk849GvJZaazW9Tf85mN4OajEtlv+VAF+5Xh6q6eYzz8IHa7Sva0l8tndUD1vFnyCExvpRJxz+2q3PJafqYKRDLiVLO3Md9W/ntUzUgwUgVskrxqg8qRK7h5XupTUtknv9Nr1TILqH4N5XnyNdMVfU0PrlLJtWkx8M1NKpehtD9w86xIixsrnLgKUGgq5EzGGaCUZRqApkVJrGc3V21XTnvJz1SdTKPWqheG8T9DiwpMk9cmIW1h2Ifq89Vvq1blVxO3B77sDyf/VgHMbZ+pnKny7uXj4as2+gNY/yFkJVdu7GU5vUbNtOpcYOh7FXsH3qCzmuG4a64qy02PVVUu84apNxOb/6vyZbISVcXQQ2ttOwMX2ES9iQE163LyH9ud2+zyWZ1ej8KT+2DgKxDQWM1i7J6vcmhm94Etn6l9daxhLISfJ6umbj711d+lV10bfyHOT4IROys0mjiSoDqvVmpPGhtUjpSq+wOqdCxma9mzEWXJTFJ9GdBUMmlFn3DCOsFD61Uyn7FANV5a/EjJqdDC/GJ5M5Mqdp0isZmxFJoK8XL1ItSnlPr90I4qcz8/AxL2VepaZUqNUr0c1n9ov/Xv3IsqL8fcs2DC4kszP6JsXSeqWUTNqF5sL0/41jTYOQfmDlW9aepGquXHiszadRqrlh8KMu23k7CxEFYU5SL0nALBrSt+Lp0O2t+pOuIO+Be4eqnnkq8GwKpX1fesw93w4Gqo38omwy+h3Ui1TwvA4ocqXplXmuKzOu511EzMsPdVENT/eRWU3PcndByjgs+Uo/D3v2Fma9Wo7MTKa7+J0TT463nVgNLVC8YuKn9H7RpGghE7Myev1vFwpUm9Ciav2qhypFR+YdBulPp8WwVmR0xG1Y8hO1n1Z7j5/cqNxytAbZI25E31ru3Aj6pJ1PmT6v5jS1WHSN8waFG5vBlzvkgT/ybodaX8KehdIPL6ooPXVepaV2UyqiTAo3+qqeaPO8C3d8Ch367crbaiss+rEuq43eod131/QKNetjl3baDTqdm+wKZqSXPJY5dm7AqyVSC+7FkVQLe6VQXU5v2NrKXXX5qJ2ftdxd8glGXXXLURpFegqmSxBXdv1ZvmiV0q+ACVkHvrDLjja/t2Db3pHQjtoJ4XbLG3kKZdNqvTRm3G2P6Oksfp9Sqgv+MrePa4qsBq0FW1sz+2VC27fNxe9We5WtfpzZ9cqma76xto2K1yY6/GJBixswNF+SJtG/hVPHnVXDlSJ7RSlSNX1auozPfQr9Z3ndw4QyV4unkX9WewwfbyOh1c/7R60awToqpZvhqo2kDbKHEVilXS+JexpNR0gPpor+Zn27+AuF1qtiLyBkCD06vhl8lqj5DlL6jp24rKTFQbzCUeBJ9gmLRcvfMW1vHwVb/fLu4q32bb5ypA/nqwSuLUuahKk3u+VwF1ZUT0hA6jAU01I7NlqW9O6qX8ikH/tv1ygH9DVZn16FZ4bJuatbB3EqabJ9w1X81enN0EGz6s+Lly09QspWVWZzRMWa3KvcviFQA9HlBLUY9uUcnIXoGQmVDUn6UrzB2merSYZ3oP/Qb/FC3L3fy+qhKqxSQYsTNz59WOlckXMb8Ad638C3CpGnZTpawmQ1GUXk5nNl3aVOzWmdf+g7VW5PWqK2Pjvmra+uf7iipbbJM3c0Ub+NKYm5/FbLf9jqGpUSoPAVRp56SlqvNlv+fVrrS5F2HHl/DF9Wq6eMfX1rUMT4tV6/cpx8C3AUxeXuO7ONpVWCdVdQKw6jW1FJFyVAXM9/2pKk1s9cI75A0V4MduV28SbGXtu6oCJbgddJ1ku/NeLqStdXljlRXUHIZ/rD5f/2HFks4TDqif6bGlRbM6M9Wsh7X7IIW0U43snj2uOqc2v1F1vI7ZokqRp7dUs2mLi6oZez16qbKxFpNgxM4syasVzRexR+Jqacw9BnZ9U77lgezzakpUM6nS3M5j7TMu31CY+MelfSmgKHG18nuUXLWst7igFmpGypivXhhsRdPgj6KN0pr0u/SzDWwKg16Bpw/C+F+h7UhVfpuwH5Y/p7L3f3lALRuVVWqaGqUCkdQolWN0/1/qaxGV0+NBaHu7CtwLsqDx9aqbamRf217HPxxumKY+X/WabUpIkw6rv29QuQ81befXjncXlRxr8NsU6xKA93yr+qZcjAb/RnD/SjXTUZng0tVd/a7c+ws8fUi1s6/bRP3eHFiknlNa3aqaQAoJRuypePJqhTuv2itx9XJtb1fvnrNT1PRhWUwm1XchM0H1YbjlP/YbF6gnzRvfUmWobW9Xa8SVZNJMRKerzbZKraQx0+kuVdXYcqlmz4Kickdv1e758ic9vYuqdBm9QL3DMu+ZYsxX+1X873b4pBOse19VHxWXclxNCafHQr3mMHlFrU2KszmdTv28Ot6jgsaJv1/ZtdRW+kxVf/MZcZc6GleUpsGKl9Sbhza31dzk5WEfqhyPrCQVkFyrN4whF35/HP6YCoV50OImeHi92pzRlvzDVen2E3tg0jL1Bq7TOLjz6/J3n63hJBixo1MpWZVLXi2euGouwbUXFzfoWZSVvv3zstept3yi+i64eqp1dFtv5341rYapaU8bLAfFZ8WTZ8zDXe9OeJ3wsg82L9XYqvlZepzq8QDq3VJgk7KP96mn2vc/ulkl0nV/QO35kx6jlsk+7gj/GwkHf4Fzu1VDpqxECG5b1FzqGl+fsI5XANzxpVpOs+fsgpuXWr4DFYxcHnRa49hS9fvr4nHtZoTVmbv3pb2FotbBpjL2FrpwGubcqBKFdXr1tzh2kdqXx170erX8PHI2jPq86p47qwEJRuzo4LmizqsVTV4t3vK8kpUj5dJtsgowEvZDzLbSj4nZfinPYdiH1TYHwZwv0ti/Ma76a7ygmN9Fxu1Re3lUhqapjenyM1SeTq+Hy/9YnU69Yxs+E547rqoUmvQDNNU75NcHYM4g9TsT1km9A6sTXLnxCsdqc5tKbC7MU8s1FWHIU7syg9obp6bPkgW3Vhs+gsqRObvlymOOLlX5IUkHVePHCYvVzIVeXhIdRb7zdnSoss3Odhd1XLVB5Ui5eAdCx9Hq8+2fX3l/Tqrqs6AZVd8Fe+aw2Jk5X6TMShqzgAiVy6EZVQO0yjj0q+oy6+KummJVdIrWzUv9rO77U/U76PeCSnoFtc36xD/s+w5PVA2dTiVD6vRweDGcqcDv37ZZkHZWvam5/hnbj9EZdR6nltIsewtdULcbDfD3K7BovHpDENFb7ZFjrpoTDiPBiB1VKnn1wulilSNVuIGZOZH16NKSDbg0Ta2tZpxTL8wjPq7W+yaYy3rLrKQpzhZLNdnn4a8X1Of9nq9cs6niApuoMs2nD6pkysnLK19eKpxHaIdL/YX+elH1pimvjATYULRUMeRN+/b7cCY6nepxUq8FZMar1u0Z8bDgNthS1LW1z1RVwebXwLFjFYAEI3ZT6eRVG7U8t1pIOzX1rxlh59eXbt/2ORxfrt7R3z1f9V2oxspVSVOcLfap+etF1ZgppL193qHqXVSzLVvsWyScy8B/g6e/WlawZpft1W+CIVstCZqbkdUWHnUu7S108m/4b9dLe2eN/p+qYpG/FachwYidVCp51YYtzyvE3ARt93xVUhi3+9J69dB3VT5CNaZpmiVnpFzLNHApGEk+bP3eE6B2/Dz0i5puv/0zeRIU1vEJurSd/Jq3VXOuazm3C/b/oD6/+YPamQ8R2v5SV+jCXFWR9vB6VZUnnEot/O2sGpVKXrW0PG9QNYmrl2s5VCW55aXDjq/UJk4mg0qmM+8DUY0l5ySTZcjCRedCY7/G5XuQTxCEdFCfn7FyqSY3Te2zAyqBUDqgioro8aAqpc+5oBp7lcVkUjNxoMpIa3GbcbpNUktUNzxX/h2URZWTYMROKrVT766ixFV7dVy9Fr0L9Cyq8vjnDZX8FtBY7ZBZjfNEzMz5IhG+EbhZM0NR0aWaVa+pniyBzS69uxXCWi5ucHNRB9gdX0LKiasfe/Antc2Aex0YXMEqnJrCvL3E4FdV6a9wShKM2EmFk1fPn1LNsHT6om6CDtJlvHoiA9UB9O55NSYp0lJJU1azs9I0rUASa9T6S43rbv/MNnv3iNqr+RBoOUxtxrbyX6Ufk58Fq4r2POn3nOpiLISTk2DEDgqNJo4WJa9aPTOyZ7762Nw2Lc8rzNP/UmXN0HcgvOZM825PUG3dWwdaWc3SqI/aEO1idPkaUBVkw59Pqs97PAiNr7NypEKUYug76g3CqVVw4u8r7980UzW9q9tEbdgmRDUgwYgdFE9ejbQmebUwX+3qCI5JXL3cwH/Dsyesa8zl5LIN2WyJV02QBjcabN2DPf0uBWXlWapZ8w5cPAN+DdXGZ0LYQr1mqiMvwMqXVadms9Ro2PKZ+nzoO+DqUfXjE6ICathOSQ6SHqeSTk2FAOTFpvGASzyN/LzRbz9V/vNcOF0scfUmOw3WCnq9/fbdcJAN5zZQYCog0i+S5gHNrT9B0/5wbodaqimr/0vsTtg2W30+4pNqXwotnEy/51WlzIVTKn/kuifU7X+/ovYvajoAWt3i0CEKYQ0JRmxh+XOqB0eRzkBnNyATWFmB8zkqcbUWWHV2FQBDGg9BV5Fk3Cb9YMN/1KZ5mlZ6Qm9hvtp4Cw06jVUb3glhS55+MPh19Xu2/kPoOAaSj6g3RToXGPpejUg2F7WHvOLZQspx9bHZIPCux/oTKVzMKaBb47pE1LUye9szAPo8bvMhCsgtzGVT3CYAbmx8Y8VO0rCnaqKUlaR+7qV1Ud0wHVKOgU991ZdFCHvoPB52zoGEfarqLX6vur3HA9V2zyhRe0kwUlmaprb4Bhj+EYV+jXjo9ZXkF5pYc3t/qF9L2i9XA5vjNpNbmEt4nXDaBLap2EncPKFRb7UjaPSGK4ORxIMqgRDUZl2yP4ywF70ehn0Ac4deapLoVVfKx0W1JAmslZVzQe2oiQ58G3AyOYv8wgokrwq7syzRNKrgEo2Zud9I9GVJrMZC+H2qyh1qMwLajaz4NYQoj0a9S7Z5H/hvCYBFtSTBSGWlF20mVycEXN0t/UXah1eg86qwmwJjAevPqeDhxsgKLtGYNRmgPp7ZWHLTsq2fqSlzT/9LW5gLYW9D3gSfYLWE2G2yo0cjRIXIMk1lpRct0fir7dsPVabzqrCbrfFbyTZkE+wdTIegDpU7WVgn8PBX7fIT9kN4V9Wsbt176v6h70mjKVF1/MPhmcOqc7LexdGjEaJCZGakstLPqY/+DQGKzYxIMOJMii/R6HWV/LV3cYXIvurz6PVqH5A/nlDLdc0GQedxlRytEFZydZdARFRrMjNSWeZlGv8ICo0mjsSrzqsdGwY4bkyiBIPJwNrYtYAq6bWJJv1VOXfUetU2P2YLuPnA8I+lpFIIIawkwUhlmStp/MItyau+Hq40DpQNmZzFzoSdZBRkEOgZSNfgrrY5qXmfmpitcG6n+nzIG1C3nLsACyGEsJBlmsoqtkxjXqJpJ8mrTmVVjFqiGdxoMC62msqu31olDRbmQUEWRPRW+88IIYSwmgQjlWVJYG3IwXOSvOpsjCYja2LWADZcogG1FGMu8XXxUDvy6uXPSQghKkKePSvDaIDMBPV5sZmRDpIv4jT2JO8hNS8Vfw9/eoT2sO3Ju04ADz+4+V0IamHbcwshRC0iOSOVkREPaODiQaFnIEcTVPKqzIw4D3MVzcCIgbjp3Wx78qYD4KUYSVgVQohKkpmRyrAkrzbgZEqOJK86GZNm4p+z/wCV2IvmWiQQEUKISqtQMDJr1iwiIyPx9PSkV69e7Nixo1yP+/HHH9HpdIwcObIil3U+xZNXz0nyqrM5kHKAlNwU6rjVoXdYb0cPRwghxFVYHYwsWrSIadOm8frrr7Nnzx46derE0KFDSU5OLvNxZ86c4bnnnuOGG26o8GCdTrEeI+Z8Eekv4jzMSzT9I/rj7uLu4NEIIYS4GquDkZkzZzJlyhQmT55M27Zt+eKLL/D29mbu3LlXfYzRaGT8+PG8+eabNG3atFIDdirFWsFL51XnomnapSWaRnZaohFCCGETVgUjBQUF7N69myFDLpVI6vV6hgwZwtatW6/6uLfeeovg4GAeeOCBcl0nPz+fjIyMEv+cUtEyTaFvuCSvOpkjF44Qnx2Pl6sXfcP7Ono4QgghymBVMHL+/HmMRiMhISElbg8JCSExMbHUx2zatIlvvvmGr7/+utzXee+99/D397f8i4iIsGaYVacogTXOVE8lr3pK8qqzMC/R3BB+A56ung4ejRBCiLLYtZomMzOTCRMm8PXXXxMUFFTux7388sukp6db/sXGxtpxlJVQlDNyNNsPgPYN/CV51QlommYJRuxWRSOEEMJmrOozEhQUhIuLC0lJSSVuT0pKIjT0yi3TT58+zZkzZxgxYoTlNpPJpC7s6srx48dp1qzZFY/z8PDAw8PDmqFVvfxMtYU8sPOiF5BNh4Y1a4nmTPoZfjnxC1M6TsHfo/p8bScuniAmMwZ3vTs3NKxBCdNCCFFDWTUz4u7uTrdu3Vi9erXlNpPJxOrVq+nTp88Vx7du3ZqDBw+yb98+y7/bbruNgQMHsm/fPuddfikPc/Kqpz8HUowAtGvg58AB2d5Huz9iwZEFfHPwG0cPxSr/xKjE1b7hffFx83HwaIQQQlyL1R1Yp02bxn333Uf37t3p2bMnH3/8MdnZ2UyePBmAiRMnEh4eznvvvYenpyft27cv8fiAgACAK26vdiw9RiI4eyEHgCZBNeeFz6SZ2JO8B4C1sWuZ1n2ag0dUfnZvdCaEEMKmrA5GxowZQ0pKCq+99hqJiYl07tyZFStWWJJaY2Ji0NeGDcOK8kWMvuEkn80HoFENSl6NTo8mLT8NgDMZZ4hOj6aJfxPHDqocotKjOJV2Cle9K/0j+jt6OEIIIcqhQnvTTJ06lalTp5Z637p168p87Pz58ytySedTVEmT6aGCMF9PV/y9bLz3iQOZZ0XM1sWuqxbBiHlWpHdYb/zca9aymRBC1FS1YArDToqWac671AfUrIiuBu1TsidJBSPB3sGACkaqA1miEUKI6keCkYoqCkbiTIFAzVqiAdibvBeAxzs/DsC+lH2k5qU6ckjXFJsZy9HUo7joXBgYMdDRwxFCCFFOEoxUVFEwElVQF4BG9WpOMJKYnUhcVhx6nZ6hkUNpE9gGk2Ziw7kNjh5amcyzIt1Du1PXs66DRyOEEKK8JBipCJPJkjNyNEf136hJMyPmWZFWdVvh4+bDgIgBAKyNWevAUV2b7EUjhBDVkwQjFZFzHowFgI4D6V5AzQpGdiftBqBbSDcAy5LH1oSt5BXmOWxcZUnMTuTA+QPo0DG48WBHD0cIIYQVJBipiKKyXs03jOiLBUDNCkbMlTRdgrsA0DqwNSHeIeQW5rIjcYcjh3ZV5lmRLsFdCPIq/9YDQgghHE+CkYow79ZbpwH5hSb0OmgQ4OXgQdlGen46py6eAqBrSFcAdDqdZalmTcwaRw2tTLIXjRBCVF8SjFREeskeIw0CvHBzqRnfyv0p+9HQaOzXuMQMw6CIQQCsP7cek2Zy1PBKdT73vCXPZUjjIQ4ejRBCCGvVjFfQqmbpMaJ6cDSuQZU05v4i5iUas+6h3fFx8+F87nkOnT/kiKFd1eqzq9HQ6BDUgVCfKzdsFEII4dwkGKmIjJrbY8ScL9I1uGuJ291d3Lk+/HrA+RqgrYqRJRohhKjOJBipiKKZkWiD6mURUUOCkXxjvmXWw5wvUpylxDfWeUp8L+ZdZFfiLkCWaIQQorqSYKQiioKRmtZj5ND5QxhMBup51qORb6Mr7r8h/AZcdC6cSjtFbGasA0Z4pbWxazFqRloHtibCN8LRwxFCCFEBEoxYqzAfspIA2J/hA9ScYMScL9I1pGup++z4e/hbeo84y1KNVNEIIUT1J8GItTLiAdBcPTmR5QFA40AfR47IZq6WL1KcMy3VZBRksC1hGyBLNEIIUZ1JMGKtojbwBp8wQIefpyv+3m6OHZMNGE1G9iXvA0rPFzEzByN7kvaQnp9eBSO7uvWx6yk0FdLMvxlN/Zs6dCxCCCEqToIRaxXli2R6qBLSmrJB3qm0U2QZsvB29aZl3ZZXPS7CN4LmAc0xakY2xm2swhFeybJEEylLNEIIUZ1JMGKtolbwF4p6jNSUfBHzfjSdgzvjqnct81jzXjWO3Dgv25DN5rjNAAxpJEs0QghRnUkwYq2i7qvxWj2g5pT1lidfxMwcjGyO30yBscCu47qajec2UmAqoJFvozJncoQQQjg/CUasdVmPkZowM6JpGnuTVDv1svJFzNoFtaO+V32yDdnsTNxp7+GVqngVTWmVP0IIIaoPCUasZe4xkusH1IxKmnNZ50jOTcZV70r7oPbXPF6v09M/oj/gmKqa3MJcS76KlPQKIUT1J8GItYqqaQ5m1AFqxsyIeZO5tvXa4uVavt2HzUs162LXoWmavYZWqi1xW8gtzKWBTwPa1mtbpdcWQghhexKMWCMvHfIzADhTWBcXvY6wAE8HD6ryzM3OugV3K/djeob2xMvVi6ScJI6mHrXX0Epl3otmcOPBskQjhBA1gAQj1ihKXi30CCAXTxoEeOLmUv2/heZKmvLki5h5unpyXYPrgKrtxlpgLGB97HoAbmp8U5VdVwghhP1U/1fSqlSUL5Jl7jFSA5ZoUvNSOZNxBoDO9Ttb9VhHdGPdlrCNLEMWwV7BdKzfscquK4QQwn4kGLGGuceIa83pMWKuomke0JwAzwCrHtuvYT/0Oj3HUo+RkJVgh9FdyVxFM6jRIPQ6+fUVQoiaQJ7NrZFRssdIoxpQSWPuL9IluIvVjw30DLTMpqw7t86GoyqdwWSwzMLcFClLNEIIUVNIMGKNGthjpPhOvRVhWaqpgm6suxJ3kZ6fTqBnYLmaswkhhKgeJBixRlEwcizXH6j+wUiOIcdSCVPRF3dzie/OpJ1kFmTabGyX0zSN+YfnW67ponex27WEEEJULQlGrFEUjBzPUQ3PqnswcuD8AYyakVCfUBrUaVChc0T6RxLpF0mhqdCyV4w9/HH6D7bEb8Fd786kdpPsdh0hhBBVT4KR8jKZICMegHgtCD9PV/y93Rw8qMqxLNFUcsljYKOijfPsVFVzPvc8H+78EIDHOj9GpH+kXa4jhBDCMSQYKa/sZDAZ0HR6kgmgUb3qPSsC1m2OVxbzUs3GuI0YTIZKj+ty725/l4yCDNoEtuG+dvfZ/PxCCCEcS4KR8ipaosl2D8aIS7Xfk8ZgMnAg5QBQ8eRVs45BHQn0DCSzINMy22Irq86uYtXZVbjqXHm779u46l1ten4hhBCOJ8FIeRX1GEkt6jESUc3zRY6nHie3MBc/dz+aBTSr1Llc9C70a9gPsG031vT8dN7Z9g4Ak9tPplVgK5udWwghhPOQYKS8ilrBJ2DuMWL7YORsxlkWHF5AgbHA5ue+nLkFfJfgLjZpHla8G6utNs77cOeHXMi7QFP/pjzS6RGbnFMIIYTzkTnv8rJzjxFN03h+/fMcTT1KjiGHRzs/atPzX66y/UUu1yesDx4uHsRlxXEy7SQt67as1Pk2xW3ij9N/oEPHm9e9ibuLu03GKYQQwvnIzEh5FS3TnMi1T1nv3uS9lp4f3x/7nhxDjk3PX5ymaexNVm3gbdU8zNvNm95hvYHKN0DLNmTz1ta3ABjfZjydgztXdnhCCCGcmAQj5VXUCj7GWA8XvY4GAZ42Pf13R7+zfJ6en87PJ3626fmLi86I5mL+RTxcPGhbr63Nzmuuqqls3sjHuz8mITuB8DrhPNHlicoPTAghhFOTYKS8ipZp4rV6hAd44epiu29dfFY8q2NWA3Bvm3sB+N/h/9ktd8S8OV77oPY2Xf7oH9EfgEMXDpGck1yhc+xO2s2Px38E4I3r3sDbrXonCgshhLg2CUbKw5AH2SmACkZsvUTz47EfMWkmeoX24pluzxDsFUxybjJ/nv7Tptcxs1V/kcsFeQXRMagjULHZkbzCPF7f8joAd7S4w7LsI4QQomaTYKQ8ipZoDHpP0qhj07LeHEMOv5z8BYB7296Lu4u7pbHXvMPzMJqMNruWmbmSpltIN5uf29yNtSLByOf7P+dsxlnqe9Xn2e7P2nZgQgghnJYEI+VRtESjeozobDozsjRqKZkFmUT4Rlh6ddzV8i78Pfw5m3GWVTGrbHYtgKTsJOKy4tDr9HSq38mm5wYY0HAAANsTtluVhHv4wmEWHF4AwCu9X8HP3c/mYxNCCOGcJBgpjwz79BjRNI3vj34PwLjW4yz9PrzdvBnfejwAcw7MsVnfDsBSRdOqbivquNex2XnNmgU0I8I3ggJTAVvit5TrMQaTgdc3v45RM3Jz5M0MajTI5uMSQgjhvCQYKY+imZEzhkAAGttoX5qt8VuJSo/Cx82Hkc1HlrhvXJtxeLl6cfzicTbFbbLJ9eBSvkiX4C42O2dxOp2uRAO08ph7cC7HLx4nwCOAl3q+ZJdxCSGEcF4SjJRHUY+R6IIAwHat4M3lvCObj7xilsLfw5+7W94NwJyDc2xyPbB9s7PSmEt8N5zbQKGpsMxjT6ed5ssDXwLwYs8XqedVz27jEkII4ZwkGCmPolbw8dTD38sNfy+3Sp/yTPoZNsZtRIeOca3HlXrMxLYTcdW7sid5j2V5pTIyCzI5cfEEYPtKmuK6BHfBz92PtPw09qfsv+pxRpOR17a8hsFkoF/Dftza5Fa7jUkIIYTzkmCkPIqWaeK0IJvliyw8thCAfg370civUanHhPiEcHuz2wHbzI7sS96HhkaEbwT1vetX+nxX46p3tSTjltWNdeGxhRxIOYCPmw+v9n4VnU5ntzEJIYRwXhKMXIumXUpgtVGPkYyCDJacWgKodudlub/9/eh1ejac28Dx1OOVuq69+ouUxrxUc7WN82IzY/l076cATOs2jVCfULuPSQghhHOSYORa8tKgIAtQDc9skS+y+ORicgtzaR7Q/JqNvRr5NeKmxjcB8M3Bbyp13arIFzHrG94XN70bMZkxRGdEl7hP0zTe3PomuYW59AjtwV0t77L7eIQQQjgvCUaupWiJJlPvTz7ula6kMZqM/HDsB0BVzJRnaeKBDg8AsPLsSmIyYip03QJjAYfOHwKqZmbEx82HnqE9gSuXahafWsz2hO14unjyRp83LCXNQgghaid5FbiWdHOPkSCg8j1G1p1bR1xWHP4e/gxvOrxcj2kd2Jrrw6/HpJmYd3heha57+MJhCkwFBHoG0tivcYXOYa3SNs5Lzklm+s7pAEztMvWq+TJCCCFqDwlGrqWorPdsoeoxUtlgxNzk7K4Wd+Hl6lXuxz3Y4UEAfj/1e4U2oTO3gO8a3LXKEkXNG+ftT9nP+dzzaJrG29veJtOQSYegDpZNAYUQQtRuEoxcS1Hy6jlTIC56HWH+nhU+1fHU4+xM3ImLzoV7Wt9j1WO7hXSja3BXDCYD3x751uprV2W+iFmoTyht67VFQ2PjuY2sPLOSdbHrcNW78uZ1b+Kid6mysQghhHBeEoxcS1HOSLxWj/AAL1xdKv4tM8+KDGk8pELVI+bckUXHF5Gen17ux5k0E/uS9wFVky9SnLkb6++nf+e9He8B8FCHh2hRt0WVjkMIIYTzkmDkWizBSFClkldT81JZFrUMoMLLEzeE30Cruq3ILcy19Ckpj5MXT5JpyMTL1YtWga0qdO2KMueN7E7aTWpeKs0DmluWnIQQQgiQYOTazAmsWmClynp/OfELBaYC2tVrV+HdcnU6nWV2ZOHRheXeFdfcvbVT/U646l0rdO2KalW3FWE+YQDodXre7vs2bi6V72ArhBCi5pBgpCwmoyVnpDLdVw0mA4uOLQJUk7PKJJDe2PhGInwjSMtP49eTv5brMY7IFzHT6XQMazIMgPva3Uf7oPZVPgYhhBDOTYKRsmQmgmakEBdSCKhwMLLqzCqSc5MJ8gri5sibKzUkV70r97e/H4AFhxdgMBrKPF7TNHYnq0qabsHdKnXtinq88+N8d8t3PNP1GYdcXwghhHOTYKQsRbMiyQRiQl/hYMS8O+/oVqNtskRxW7PbCPYKJikniaVRS8s8Nj47nuScZFx1rnSo36HS164Idxd3OtXvJHvPCCGEKFWFgpFZs2YRGRmJp6cnvXr1YseOHVc99uuvv+aGG26gbt261K1blyFDhpR5vFMp6jESa1Lb2lckZ2R/yn4Onj+Im96Nu1vebZNhubu4M7HdRAC+OfQNRpPxqseal2ja1mtrVV8TIYQQoqpYHYwsWrSIadOm8frrr7Nnzx46derE0KFDSU4uvRHXunXrGDt2LGvXrmXr1q1ERERw0003ERcXV+nB212x5NUAbzf8vayf1fj+iCrnvaXJLQR5BdlsaHe1vAs/dz/OZpzln5h/rnqceXO8LsFdbHZtIYQQwpasDkZmzpzJlClTmDx5Mm3btuWLL77A29ubuXPnlnr8999/z2OPPUbnzp1p3bo1c+bMwWQysXr16koP3u6KlfVWZIkmKTuJVWdXAXBvW9t2G/Vx82Fcm3GA2kCvtJ1xwbHJq0IIIUR5WBWMFBQUsHv3boYMGXLpBHo9Q4YMYevWreU6R05ODgaDgcDAwKsek5+fT0ZGRol/DlGs4VlFlmgWHV9EoVZIt5ButA5sbevRMb71eLxcvTiaepQt8VuuuP9i3kWi0qMAmRkRQgjhvKwKRs6fP4/RaCQkJKTE7SEhISQmJpbrHC+++CINGjQoEdBc7r333sPf39/yLyIiwpph2k7GpWDE2pmRvMI8fj7xM1DxJmfXEuAZwF0t7wJgzsE5V9xv7i/S1L8pdT3r2mUMQgghRGVVaTXN+++/z48//sjixYvx9Lz6Hi8vv/wy6enpln+xsbFVOMpiKrFMszx6OWn5aTTwaWDpQmoPE9tOxFXvyq6kXZaW72ayRCOEEKI6sCoYCQoKwsXFhaSkpBK3JyUlERpa9l4r06dP5/333+fvv/+mY8eOZR7r4eGBn59fiX9VriAHci4AEK8FWhWMaJpmKecd23qsXTeEC/UJ5bZmtwFXzo6YZ0aqej8aIYQQwhpWBSPu7u5069atRPKpORm1T58+V33chx9+yNtvv82KFSvo3r17xUdblTLiAcjSPMnAx6pgZGfiTk5ePImXqxejWoyy1wgtJrebjA4d68+t58TFEwDkGHI4cuEIIDMjQgghnJvVyzTTpk3j66+/ZsGCBRw9epRHH32U7OxsJk+eDMDEiRN5+eWXLcd/8MEHvPrqq8ydO5fIyEgSExNJTEwkKyvLdl+FPRT1GInX6uGq1xPmf/VlpcuZZ0Vua3Yb/h7+dhlecZH+kdzY+EZAVdYAHDp/iEKtkBDvEBr4NLD7GIQQQoiKsjoYGTNmDNOnT+e1116jc+fO7Nu3jxUrVliSWmNiYkhISLAc//nnn1NQUMBdd91FWFiY5d/06dNt91XYQ4a5x0g9wut64epSvm9VbEYs62LXAVhKb6uCeSfcFWdWEJsZa2kB3zW4q3Q+FUII4dQqtIXr1KlTmTp1aqn3rVu3rsT/z5w5U5FLOF5R8mqclZU0C48tREOjb4O+NPVvaq/RXaFNvTb0De/L5rjNzD80n5jMGECWaIQQQjg/2ZvmaoqWaRKs6DGSbchmyaklgO2bnJXHg+3V7MjiU4vZn7IfkP4iQgghnJ8EI1dT1AremrLeJaeWkGXIItIvkusaXGfP0ZWqW0g3OtfvjMFkILcwF183X1rUbVHl4xBCCCGsIcHI1Zh7jFCPxuUIRkyaiR+O/QDA+Dbj0euq/lur0+ksuSMAnYM7O2QcQgghhDXklao0mmZ1K/hNcZs4m3EWXzdfS98PR+jXsJ9lNqRbSDeHjUMIIYQorwolsNZ4uRehMBeARC2QRvWuHYx8d0SV897R4g683azfx8ZWdDod0/tN5/fTvzO29ViHjUMIIYQoLwlGSlOUvJqi+ePl7YOfp1uZh59OO83WhK3odXrGtnF8ANA0oCnPdHvG0cMQQgghykWWaUpjSV4tX1nvwqMLARgYMZDwOuF2HZoQQghR00gwUpr08u/WazAZWHl2JQBjWo2x+9CEEEKImkaCkdIU6zFyrWBkV+Iu0vPTCfQMpEdoj6oYnRBCCFGjSDBSmqJW8OXpvvrP2X8AtUTjqpcUHCGEEMJaEoyUxrJMU3bDM6PJyD8xKhgxb1QnhBBCCOtIMFIKrSgYuVYr+L3Je0nNS8XP3Y+eYT2ranhCCCFEjSLByOWMhZCpdh1O0gUR5u951UPNsyIDIgbgpi+7/FcIIYQQpZNg5HKZCeg0EwWaC54Bobi6lP4tMmkmVp1dBcgSjRBCCFEZEoxcrih5NVELpGG9Olc97OD5gyTnJOPt6k2fBn2qanRCCCFEjSPByOUsG+SVnbxqrqLpH9EfDxePKhmaEEIIURNJMHK5oh4jZTU80zRNlmiEEEIIG5Fg5HLlaAV/NPUocVlxeLp40rdB36ocnRBCCFHjSDByuWI9Rq5W1mteormh4Q0O3aFXCCGEqAkkGLmM0RKMBNKo3pWBRvElmiGNhlTp2IQQQoiaSIKRy2hpKmckyyMUP88re4ecSjvFmYwzuOnd6NewX1UPTwghhKhxJBgpriAb1/w0ANzqRpR6iHmJpm+DvtRxv3rprxBCCCHKR4KR4oqSVzM0L+oF1S/1kFUxRUs0jWWJRgghhLAFCUaKs5T1lt5j5Ez6GU5ePImrzpUBEQOqeHBCCCFEzSTBSHGWDfICaVxK8qp5L5qeYT3x9/Cv0qEJIYQQNZUEI8VlmHuMlF7WK43OhBBCCNuTYKQYU1ElTVwpDc/OZZ7jyIUj6HV6BjUa5IjhCSGEEDWSBCPFGFJVMJKsCyLM36vEfatjVgPQLaQbgZ6BVT42IYQQoqaSYKQY88yIoU4DXPS6EvfJEo0QQghhHxKMmGkabtkJALhc1mMkMTuR/Sn7ARjcaHCVD00IIYSoySQYMcu5gKspH5Omw7d+yWDEvETTuX5ngr2DHTE6IYQQosaSYMSsqMdICv6EBwWUuMvcdVWWaIQQQgjbk2DEzNJjpGQlzfnc8+xO2g1I11UhhBDCHiQYMStqBR+n1SvRY2RNzBo0NNrVa0eDOg0cNTohhBCixpJgpEhB6llAzYwUD0bMSzQyKyKEEELYhwQjRXLPxwBw0S0EP083ANLy0tiRuAOQfBEhhBDCXiQYKaKlqZyRQt9wy21rY9di1Iy0rNuSxn6NHTU0IYQQokaTYKSIW5bKGXENuFTWa94YT5ZohBBCCPuRYATAaMCr4DwA3vUbAZBZkMnW+K0A3NT4JocNTQghhKjpJBgByIhHj0a+5kZQiFqmWX9uPQaTgSb+TWgW0MzBAxRCCCFqLglGoFiPkUAi6tUBilXRNJIlGiGEEMKeJBgBTEXBSHxRw7McQw6b4jYBUkUjhBBC2JsEI0Bm0hkAEnX1CPP3YmPcRvKN+TSs05DWga0dOzghhBCihpNgBMg9rxqeZXmE4aLXldiLRqfTOXJoQgghRI0nwQhgSlOb5BX6hpNXmMeGcxsAKekVQgghqoIEI4BbVjwALgHhbInfQk5hDqE+oXQI6uDgkQkhhBA1nwQjgE9eIgBe9SNLVNHIEo0QQghhfxKM5GfibcoCwDe4Ieti1wGyRCOEEEJUFQlG0lUb+HTNm1S3GDINmQR5BdG5fmfHjksIIYSoJWp9MJJz/gwA8VoQh9NUb5HBjQbjondx4KiEEEKI2qPWByNpCVEAJOnrsTF+HSBLNEIIIURVqvXBSE5KDAAH/PxIy08jwCOA7iHdHTwqIYQQovao9cGIucfIft9CAAY1GoSr3tWRQxJCCCFqlVofjLhmxWEEjrqfB2RjPCGEEKKq1fpgxCcviX0eHmSSi6+bL73Dejt6SEIIIUStUruDEZOJuoXJ/OPjBcCAiAG4ubg5eFBCCCFE7VKrgxFjVgquFLLKxxuQKhohhBDCEWp1pub5uNMkebiT5OqKl6sX1zW4ztFDEkIIIWqdCs2MzJo1i8jISDw9PenVqxc7duwo8/iff/6Z1q1b4+npSYcOHVi+fHmFBmtrFxOi+MdbzYr0b9gfT1dPB49ICCGEqH2sDkYWLVrEtGnTeP3119mzZw+dOnVi6NChJCcnl3r8li1bGDt2LA888AB79+5l5MiRjBw5kkOHDlV68JWVk3KGVUX5IrJEI4QQQjiGTtM0zZoH9OrVix49evDZZ58BYDKZiIiI4IknnuCll1664vgxY8aQnZ3N0qVLLbf17t2bzp0788UXX5TrmhkZGfj7+5Oeno6fn581wy3Tr1/dy/+3d+8hTf57HMDfm7h1m6u12qXU7ConLx0sl0UXjqNZEVn+YRfIRIxqRSVdKCoLAqEIpAiif+qf7CJ0of4IwtQIVpHhkaCkhgcLnaXgtUx/7nv+6LQfK8vWcfv2bO8XPDCffff49sMH/Pj47Nkx7b8RLdR4tNGFUdGjhu3YREREke5Xf38HdGakr68PNTU1sNv/PougVqtht9vhcrkGfY3L5fJbDwAOh+OH6wHg8+fP6Ozs9NuC4flf/wEAzFZbOIgQERFJEtAw0traioGBAZhMJr/9JpMJHo9n0Nd4PJ6A1gNASUkJ9Hq9b4uNjQ0k5i+r0XwZcmwx/wzK8YmIiGhof+Rbew8ePIiOjg7f9vbt22H/HkIIZOv+BdtfRjj+kTPsxyciIqJfE9Bbe41GI6KiotDS0uK3v6WlBWazedDXmM3mgNYDgFarhVarDSRawFQqFbbmlgb1exAREdHQAjozotFokJaWhoqKCt8+r9eLiooKZGRkDPqajIwMv/UAcP/+/R+uJyIiosgS8E3PioqKkJeXh7lz5yI9PR2lpaXo6elBfn4+AGDTpk2YNGkSSkpKAAC7du3CkiVLcPr0aaxcuRJXr17Fs2fPcOHCheH9SYiIiEiRAh5GcnNz8eHDBxw9ehQejwdz5szBvXv3fBepNjY2Qq3++4TLggULUFZWhsOHD+PQoUOYMWMGbt26haSkpOH7KYiIiEixAr7PiAzBus8IERERBU9Q7jNCRERENNw4jBAREZFUHEaIiIhIKg4jREREJBWHESIiIpKKwwgRERFJxWGEiIiIpOIwQkRERFJxGCEiIiKpAr4dvAxfbxLb2dkpOQkRERH9qq+/t4e62bsihpGuri4AQGxsrOQkREREFKiuri7o9fofPq+Iz6bxer1oamqCTqeDSqUatuN2dnYiNjYWb9++5WfeBBHrHDqsdWiwzqHBOodGMOsshEBXVxesVqvfh+h+SxFnRtRqNSZPnhy048fExLDRQ4B1Dh3WOjRY59BgnUMjWHX+2RmRr3gBKxEREUnFYYSIiIikiuhhRKvVori4GFqtVnaUsMY6hw5rHRqsc2iwzqHxJ9RZERewEhERUfiK6DMjREREJB+HESIiIpKKwwgRERFJxWGEiIiIpIroYeTcuXOYMmUKRowYAZvNhqdPn8qOFFaOHTsGlUrltyUmJsqOpXgPHz7EqlWrYLVaoVKpcOvWLb/nhRA4evQoLBYLRo4cCbvdjtevX8sJq3BD1Xrz5s3f9XhWVpacsApVUlKCefPmQafTYeLEicjOzkZ9fb3fmt7eXjidTowfPx5jxoxBTk4OWlpaJCVWpl+p89KlS7/r561bt4YkX8QOI9euXUNRURGKi4vx/PlzpKamwuFw4P3797KjhZXZs2ejubnZtz169Eh2JMXr6elBamoqzp07N+jzJ0+exJkzZ3D+/Hk8efIEo0ePhsPhQG9vb4iTKt9QtQaArKwsvx6/cuVKCBMqX3V1NZxOJx4/foz79++jv78fy5YtQ09Pj2/Nnj17cOfOHZSXl6O6uhpNTU1Yu3atxNTK8yt1BoDCwkK/fj558mRoAooIlZ6eLpxOp+/rgYEBYbVaRUlJicRU4aW4uFikpqbKjhHWAIibN2/6vvZ6vcJsNotTp0759rW3twutViuuXLkiIWH4+LbWQgiRl5cnVq9eLSVPuHr//r0AIKqrq4UQX/o3OjpalJeX+9a8fPlSABAul0tWTMX7ts5CCLFkyRKxa9cuKXki8sxIX18fampqYLfbffvUajXsdjtcLpfEZOHn9evXsFqtmDp1KjZu3IjGxkbZkcJaQ0MDPB6PX2/r9XrYbDb2dpBUVVVh4sSJmDVrFrZt24a2tjbZkRSto6MDAGAwGAAANTU16O/v9+vpxMRExMXFsaf/D9/W+avLly/DaDQiKSkJBw8exMePH0OSRxEflDfcWltbMTAwAJPJ5LffZDLh1atXklKFH5vNhkuXLmHWrFlobm7G8ePHsWjRIrx48QI6nU52vLDk8XgAYNDe/vocDZ+srCysXbsWCQkJcLvdOHToEJYvXw6Xy4WoqCjZ8RTH6/Vi9+7dWLhwIZKSkgB86WmNRoOxY8f6rWVP/77B6gwAGzZsQHx8PKxWK+rq6nDgwAHU19fjxo0bQc8UkcMIhcby5ct9j1NSUmCz2RAfH4/r16+joKBAYjKi4bFu3Trf4+TkZKSkpGDatGmoqqpCZmamxGTK5HQ68eLFC15bFmQ/qvOWLVt8j5OTk2GxWJCZmQm3241p06YFNVNE/pvGaDQiKirqu6uxW1paYDabJaUKf2PHjsXMmTPx5s0b2VHC1tf+ZW/LMXXqVBiNRvb4b9ixYwfu3r2LyspKTJ482bffbDajr68P7e3tfuvZ07/nR3UejM1mA4CQ9HNEDiMajQZpaWmoqKjw7fN6vaioqEBGRobEZOGtu7sbbrcbFotFdpSwlZCQALPZ7NfbnZ2dePLkCXs7BN69e4e2tjb2eACEENixYwdu3ryJBw8eICEhwe/5tLQ0REdH+/V0fX09Ghsb2dMBGKrOg6mtrQWAkPRzxP6bpqioCHl5eZg7dy7S09NRWlqKnp4e5Ofny44WNvbu3YtVq1YhPj4eTU1NKC4uRlRUFNavXy87mqJ1d3f7/aXS0NCA2tpaGAwGxMXFYffu3Thx4gRmzJiBhIQEHDlyBFarFdnZ2fJCK9TPam0wGHD8+HHk5OTAbDbD7XZj//79mD59OhwOh8TUyuJ0OlFWVobbt29Dp9P5rgPR6/UYOXIk9Ho9CgoKUFRUBIPBgJiYGOzcuRMZGRmYP3++5PTKMVSd3W43ysrKsGLFCowfPx51dXXYs2cPFi9ejJSUlOAHlPIenj/E2bNnRVxcnNBoNCI9PV08fvxYdqSwkpubKywWi9BoNGLSpEkiNzdXvHnzRnYsxausrBQAvtvy8vKEEF/e3nvkyBFhMpmEVqsVmZmZor6+Xm5ohfpZrT9+/CiWLVsmJkyYIKKjo0V8fLwoLCwUHo9HdmxFGay+AMTFixd9az59+iS2b98uxo0bJ0aNGiXWrFkjmpub5YVWoKHq3NjYKBYvXiwMBoPQarVi+vTpYt++faKjoyMk+VT/C0lEREQkRUReM0JERER/Dg4jREREJBWHESIiIpKKwwgRERFJxWGEiIiIpOIwQkRERFJxGCEiIiKpOIwQERGRVBxGiIiISCoOI0RERCQVhxEiIiKSisMIERERSfVfCn53bZR3s54AAAAASUVORK5CYII=", "text/plain": [ "
" ] @@ -157,8 +303,11 @@ "from matplotlib import pyplot as plt\n", "picker.metrics.to_pandas()['score'].plot(label=\"vw\")\n", "random_picker.metrics.to_pandas()['score'].plot(label=\"random\")\n", + "pytorch_picker.metrics.to_pandas()['score'].plot(label=\"pytorch\")\n", + "\n", "plt.legend()\n", "\n", + "print(f\"The final average score for the default policy, calculated over a rolling window, is: {pytorch_picker.metrics.to_pandas()['score'].iloc[-1]}\")\n", "print(f\"The final average score for the default policy, calculated over a rolling window, is: {picker.metrics.to_pandas()['score'].iloc[-1]}\")\n", "print(f\"The final average score for the random policy, calculated over a rolling window, is: {random_picker.metrics.to_pandas()['score'].iloc[-1]}\")\n" ] @@ -180,7 +329,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.5" + "version": "3.10.13" } }, "nbformat": 4, diff --git a/setup.py b/setup.py index 880aa4f..c2a8676 100644 --- a/setup.py +++ b/setup.py @@ -1,5 +1,4 @@ from setuptools import setup, find_packages -import os with open("README.md", "r", encoding="UTF-8") as fh: long_description = fh.read() diff --git a/src/learn_to_pick/__init__.py b/src/learn_to_pick/__init__.py index a6894b3..11f0b59 100644 --- a/src/learn_to_pick/__init__.py +++ b/src/learn_to_pick/__init__.py @@ -21,6 +21,13 @@ PickBestSelected, ) +from learn_to_pick.byom.pytorch_policy import ( + PyTorchPolicy +) + +from learn_to_pick.byom.pytorch_feature_embedder import ( + PyTorchFeatureEmbedder +) def configure_logger() -> None: logger = logging.getLogger(__name__) @@ -50,6 +57,8 @@ def configure_logger() -> None: "Featurizer", "ModelRepository", "Policy", + "PyTorchPolicy", + "PyTorchFeatureEmbedder", "VwPolicy", "VwLogger", "embed", diff --git a/src/learn_to_pick/byom/__init__.py b/src/learn_to_pick/byom/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/src/learn_to_pick/byom/igw.py b/src/learn_to_pick/byom/igw.py new file mode 100644 index 0000000..80369a3 --- /dev/null +++ b/src/learn_to_pick/byom/igw.py @@ -0,0 +1,16 @@ +import torch + +def IGW(fhat, gamma): + from math import sqrt + fhatahat, ahat = fhat.max(dim=1) + A = fhat.shape[1] + gamma *= sqrt(A) + p = 1 / (A + gamma * (fhatahat.unsqueeze(1) - fhat)) + sump = p.sum(dim=1) + p[range(p.shape[0]), ahat] += torch.clamp(1 - sump, min=0, max=None) + return torch.multinomial(p, num_samples=1).squeeze(1), ahat + +def SamplingIGW(A, P, gamma): + exploreind, _ = IGW(P, gamma) + explore = [ ind for _, ind in zip(A, exploreind) ] + return explore diff --git a/src/learn_to_pick/byom/logistic_regression.py b/src/learn_to_pick/byom/logistic_regression.py new file mode 100644 index 0000000..e2a8981 --- /dev/null +++ b/src/learn_to_pick/byom/logistic_regression.py @@ -0,0 +1,70 @@ +import parameterfree +import torch +import torch.nn.functional as F + +class MLP(torch.nn.Module): + @staticmethod + def new_gelu(x): + import math + return 0.5 * x * (1.0 + torch.tanh(math.sqrt(2.0 / math.pi) * (x + 0.044715 * torch.pow(x, 3.0)))) + + def __init__(self, dim): + super().__init__() + self.c_fc = torch.nn.Linear(dim, 4 * dim) + self.c_proj = torch.nn.Linear(4 * dim, dim) + self.dropout = torch.nn.Dropout(0.5) + + def forward(self, x): + x = self.c_fc(x) + x = self.new_gelu(x) + x = self.c_proj(x) + x = self.dropout(x) + return x + +class Block(torch.nn.Module): + def __init__(self, dim): + super().__init__() + self.layer = MLP(dim) + + def forward(self, x): + return x + self.layer(x) + +class ResidualLogisticRegressor(torch.nn.Module): + def __init__(self, in_features, depth): + super().__init__() + self._in_features = in_features + self._depth = depth + self.blocks = torch.nn.Sequential(*[ Block(in_features) for _ in range(depth) ]) + self.linear = torch.nn.Linear(in_features=in_features, out_features=1) + self.optim = parameterfree.COCOB(self.parameters()) + + def clone(self): + other = ResidualLogisticRegressor(self._in_features, self._depth) + other.load_state_dict(self.state_dict()) + other.optim = parameterfree.COCOB(other.parameters()) + other.optim.load_state_dict(self.optim.state_dict()) + return other + + def forward(self, X, A): + return self.logits(X, A) + + def logits(self, X, A): + # X = batch x features + # A = batch x actionbatch x actionfeatures + + Xreshap = X.unsqueeze(1).expand(-1, A.shape[1], -1) # batch x actionbatch x features + XA = torch.cat((Xreshap, A), dim=-1).reshape(X.shape[0], A.shape[1], -1) # batch x actionbatch x (features + actionfeatures) + return self.linear(self.blocks(XA)).squeeze(2) # batch x actionbatch + + def predict(self, X, A): + self.eval() + return torch.special.expit(self.logits(X, A)) + + def bandit_learn(self, X, A, R): + self.train() + self.optim.zero_grad() + output = self(X, A) + loss = F.binary_cross_entropy_with_logits(output, R) + loss.backward() + self.optim.step() + return loss.item() diff --git a/src/learn_to_pick/byom/pytorch_feature_embedder.py b/src/learn_to_pick/byom/pytorch_feature_embedder.py new file mode 100644 index 0000000..09491ac --- /dev/null +++ b/src/learn_to_pick/byom/pytorch_feature_embedder.py @@ -0,0 +1,87 @@ +import learn_to_pick as rl_chain +from sentence_transformers import SentenceTransformer +import torch + +class PyTorchFeatureEmbedder(): #rl_chain.Embedder[rl_chain.PickBestEvent] + def __init__( + self, auto_embed, model = None, *args, **kwargs + ): + if model is None: + model = model = SentenceTransformer('all-MiniLM-L6-v2') + + self.model = model + self.auto_embed = auto_embed + + def encode(self, stuff): + embeddings = self.model.encode(stuff, convert_to_tensor=True) + normalized = torch.nn.functional.normalize(embeddings) + return normalized + + def get_label(self, event: rl_chain.PickBestEvent) -> tuple: + cost = None + if event.selected: + chosen_action = event.selected.index + cost = ( + -1.0 * event.selected.score + if event.selected.score is not None + else None + ) + prob = event.selected.probability + return chosen_action, cost, prob + else: + return None, None, None + + def get_context_and_action_embeddings(self, event: rl_chain.PickBestEvent) -> tuple: + context_emb = rl_chain.embed(event.based_on, self) if event.based_on else None + to_select_from_var_name, to_select_from = next( + iter(event.to_select_from.items()), (None, None) + ) + + action_embs = ( + ( + rl_chain.embed(to_select_from, self, to_select_from_var_name) + if event.to_select_from + else None + ) + if to_select_from + else None + ) + + if not context_emb or not action_embs: + raise ValueError( + "Context and to_select_from must be provided in the inputs dictionary" + ) + return context_emb, action_embs + + def format(self, event: rl_chain.PickBestEvent): + chosen_action, cost, prob = self.get_label(event) + context_emb, action_embs = self.get_context_and_action_embeddings(event) + + context = "" + for context_item in context_emb: + for ns, based_on in context_item.items(): + e = " ".join(based_on) if isinstance(based_on, list) else based_on + context += f"{ns}={e} " + + if self.auto_embed: + context = self.encode([context]) + + actions = [] + for action in action_embs: + action_str = "" + for ns, action_embedding in action.items(): + e = ( + " ".join(action_embedding) + if isinstance(action_embedding, list) + else action_embedding + ) + action_str += f"{ns}={e} " + actions.append(action_str) + + if self.auto_embed: + actions = self.encode(actions).unsqueeze(0) + + if cost is None: + return context, actions + else: + return torch.Tensor([[-1.0 * cost]]), context, actions[:,chosen_action,:].unsqueeze(1) diff --git a/src/learn_to_pick/byom/pytorch_policy.py b/src/learn_to_pick/byom/pytorch_policy.py new file mode 100644 index 0000000..985f454 --- /dev/null +++ b/src/learn_to_pick/byom/pytorch_policy.py @@ -0,0 +1,54 @@ +from learn_to_pick import base, PickBestEvent +from learn_to_pick.byom.logistic_regression import ResidualLogisticRegressor +from learn_to_pick.byom.igw import SamplingIGW + +class PyTorchPolicy(base.Policy[PickBestEvent]): + def __init__( + self, + feature_embedder, + depth: int = 2, + device: str = 'cuda', + *args, + **kwargs, + ): + super().__init__(*args, **kwargs) + self.workspace = ResidualLogisticRegressor(feature_embedder.model.get_sentence_embedding_dimension() * 2, depth).to(device) + self.feature_embedder = feature_embedder + self.device = device + self.index = 0 + + def predict(self, event): + X, A = self.feature_embedder.format(event) + # print(f"X shape: {X.shape}") + # print(f"A shape: {A.shape}") + # TODO IGW sampling then create the distro so that the one + # that was sampled here is the one that will def be sampled by + # the base sampler, and in the future replace the sampler so that it + # is something that can be plugged in + p = self.workspace.predict(X, A) + # print(f"p: {p}") + import math + explore = SamplingIGW(A, p, math.sqrt(self.index)) + self.index += 1 + # print(f"explore: {explore}") + r = [] + for index in range(p.shape[1]): + if index == explore[0]: + r.append((index, 1)) + else: + r.append((index, 0)) + # print(f"returning: {r}") + return r + return [(index, val) for index, val in enumerate(p[0].tolist())] + + def learn(self, event): + R, X, A = self.feature_embedder.format(event) + # print(f"R: {R}") + R, X, A = R.to(self.device), X.to(self.device), A.to(self.device) + self.workspace.bandit_learn(X, A, R) + + def log(self, event): + pass + + def save(self) -> None: + pass \ No newline at end of file diff --git a/src/learn_to_pick/pick_best.py b/src/learn_to_pick/pick_best.py index dee6e80..e0b53fc 100644 --- a/src/learn_to_pick/pick_best.py +++ b/src/learn_to_pick/pick_best.py @@ -325,7 +325,7 @@ def _call_after_scoring_before_learning( @classmethod def create( - # cls: Type[PickBest], + cls: Type[PickBest], policy: Optional[base.Policy] = None, llm=None, selection_scorer: Union[base.AutoSelectionScorer, object] = SENTINEL, From 063faaf3a1e066b884cae619f49a271685d58173 Mon Sep 17 00:00:00 2001 From: cheng Date: Tue, 14 Nov 2023 18:02:26 +0000 Subject: [PATCH 03/16] Save resume model --- src/learn_to_pick/byom/logistic_regression.py | 11 +- src/learn_to_pick/byom/pytorch_policy.py | 43 +++++- tests/unit_tests/test_byom.py | 130 ++++++++++++++++++ 3 files changed, 174 insertions(+), 10 deletions(-) create mode 100644 tests/unit_tests/test_byom.py diff --git a/src/learn_to_pick/byom/logistic_regression.py b/src/learn_to_pick/byom/logistic_regression.py index e2a8981..ccbe386 100644 --- a/src/learn_to_pick/byom/logistic_regression.py +++ b/src/learn_to_pick/byom/logistic_regression.py @@ -30,16 +30,17 @@ def forward(self, x): return x + self.layer(x) class ResidualLogisticRegressor(torch.nn.Module): - def __init__(self, in_features, depth): + def __init__(self, in_features, depth, device): super().__init__() self._in_features = in_features self._depth = depth self.blocks = torch.nn.Sequential(*[ Block(in_features) for _ in range(depth) ]) self.linear = torch.nn.Linear(in_features=in_features, out_features=1) self.optim = parameterfree.COCOB(self.parameters()) + self._device = device def clone(self): - other = ResidualLogisticRegressor(self._in_features, self._depth) + other = ResidualLogisticRegressor(self._in_features, self._depth, self._device) other.load_state_dict(self.state_dict()) other.optim = parameterfree.COCOB(other.parameters()) other.optim.load_state_dict(self.optim.state_dict()) @@ -52,9 +53,9 @@ def logits(self, X, A): # X = batch x features # A = batch x actionbatch x actionfeatures - Xreshap = X.unsqueeze(1).expand(-1, A.shape[1], -1) # batch x actionbatch x features - XA = torch.cat((Xreshap, A), dim=-1).reshape(X.shape[0], A.shape[1], -1) # batch x actionbatch x (features + actionfeatures) - return self.linear(self.blocks(XA)).squeeze(2) # batch x actionbatch + Xreshap = X.unsqueeze(1).expand(-1, A.shape[1], -1) # batch x actionbatch x features + XA = torch.cat((Xreshap, A), dim=-1).reshape(X.shape[0], A.shape[1], -1).to(self._device) # batch x actionbatch x (features + actionfeatures) + return self.linear(self.blocks(XA)).squeeze(2) # batch x actionbatch def predict(self, X, A): self.eval() diff --git a/src/learn_to_pick/byom/pytorch_policy.py b/src/learn_to_pick/byom/pytorch_policy.py index 985f454..604b993 100644 --- a/src/learn_to_pick/byom/pytorch_policy.py +++ b/src/learn_to_pick/byom/pytorch_policy.py @@ -1,21 +1,27 @@ from learn_to_pick import base, PickBestEvent from learn_to_pick.byom.logistic_regression import ResidualLogisticRegressor from learn_to_pick.byom.igw import SamplingIGW +import torch +import os + class PyTorchPolicy(base.Policy[PickBestEvent]): def __init__( self, feature_embedder, depth: int = 2, - device: str = 'cuda', + device: str = 'cuda' if torch.cuda.is_available() else 'cpu', *args, **kwargs, ): + print(f"Device: {device}") super().__init__(*args, **kwargs) - self.workspace = ResidualLogisticRegressor(feature_embedder.model.get_sentence_embedding_dimension() * 2, depth).to(device) + self.workspace = ResidualLogisticRegressor( + feature_embedder.model.get_sentence_embedding_dimension() * 2, depth, device).to(device) self.feature_embedder = feature_embedder self.device = device self.index = 0 + self.loss = None def predict(self, event): X, A = self.feature_embedder.format(event) @@ -45,10 +51,37 @@ def learn(self, event): R, X, A = self.feature_embedder.format(event) # print(f"R: {R}") R, X, A = R.to(self.device), X.to(self.device), A.to(self.device) - self.workspace.bandit_learn(X, A, R) + self.loss = self.workspace.bandit_learn(X, A, R) def log(self, event): pass - def save(self) -> None: - pass \ No newline at end of file + def save(self, path) -> None: + state = { + 'workspace_state_dict': self.workspace.state_dict(), + 'optimizer_state_dict': self.workspace.optim.state_dict(), + 'device': self.device, + 'index': self.index, + 'loss': self.loss + } + print(f"Saving model to {path}") + dir, _ = os.path.split(path) + if dir and not os.path.exists(dir): + os.makedirs(dir, exist_ok=True) + torch.save(state, path) + + + def load(self, path) -> None: + import parameterfree + + if os.path.exists(path): + print(f"Loading model from {path}") + checkpoint = torch.load(path, map_location=self.device) + + self.workspace.load_state_dict(checkpoint['workspace_state_dict']) + self.workspace.optim = parameterfree.COCOB(self.workspace.parameters()) + self.workspace.optim.load_state_dict(checkpoint['optimizer_state_dict']) + self.device = checkpoint['device'] + self.workspace.to(self.device) + self.index = checkpoint['index'] + self.loss = checkpoint['loss'] diff --git a/tests/unit_tests/test_byom.py b/tests/unit_tests/test_byom.py new file mode 100644 index 0000000..06a71b7 --- /dev/null +++ b/tests/unit_tests/test_byom.py @@ -0,0 +1,130 @@ +import random +import torch +import os +import pytest +import shutil + +import learn_to_pick + + +CHECKPOINT_DIR = 'test_models' + +@pytest.fixture +def remove_checkpoint(): + yield + if os.path.isdir(CHECKPOINT_DIR): + shutil.rmtree(CHECKPOINT_DIR) + +class CustomSelectionScorer(learn_to_pick.SelectionScorer): + def get_score(self, user, time_of_day, article): + preferences = { + 'Tom': { + 'morning': 'politics', + 'afternoon': 'music' + }, + 'Anna': { + 'morning': 'sports', + 'afternoon': 'politics' + } + } + + return int(preferences[user][time_of_day] == article) + + def score_response( + self, inputs, picked, event: learn_to_pick.PickBestEvent + ) -> float: + chosen_article = picked["article"] + user = event.based_on["user"] + time_of_day = event.based_on["time_of_day"] + score = self.get_score(user[0], time_of_day[0], chosen_article) + return score + + +class Simulator: + def __init__(self, seed=7492381): + self.random = random.Random(seed) + self.users = ["Tom", "Anna"] + self.times_of_day = ["morning", "afternoon"] + self.articles = ["politics", "sports", "music"] + + def _choose_user(self): + return self.random.choice(self.users) + + def _choose_time_of_day(self): + return self.random.choice(self.times_of_day) + + def run(self, pytorch_picker, T): + for i in range(T): + user = self._choose_user() + time_of_day = self._choose_time_of_day() + pytorch_picker.run( + article = learn_to_pick.ToSelectFrom(self.articles), + user = learn_to_pick.BasedOn(user), + time_of_day = learn_to_pick.BasedOn(time_of_day), + ) + +def verify_same_models(model1, model2): + for p1, p2 in zip(model1.parameters(), model2.parameters()): + assert torch.equal(p1, p2), "The models' parameters are not equal." + + for (name1, buffer1), (name2, buffer2) in zip(model1.named_buffers(), model2.named_buffers()): + assert name1 == name2, "Buffer names do not match." + assert torch.equal(buffer1, buffer2), f"The buffers {name1} are not equal." + + +def verify_same_optimizers(optimizer1, optimizer2): + if type(optimizer1) != type(optimizer2): + return False + + if optimizer1.defaults != optimizer2.defaults: + return False + + state_dict1 = optimizer1.state_dict() + state_dict2 = optimizer2.state_dict() + + if state_dict1.keys() != state_dict2.keys(): + return False + + for key in state_dict1: + if key == 'state': + if state_dict1[key].keys() != state_dict2[key].keys(): + return False + for subkey in state_dict1[key]: + if not torch.equal(state_dict1[key][subkey], state_dict2[key][subkey]): + return False + else: + if state_dict1[key] != state_dict2[key]: + return False + + return True + + +def test_save_load(remove_checkpoint): + sim1 = Simulator() + sim2 = Simulator() + + fe = learn_to_pick.PyTorchFeatureEmbedder(auto_embed=True) + first_model_path = f'{CHECKPOINT_DIR}/first.checkpoint' + + torch.manual_seed(0) + first_byom = learn_to_pick.PyTorchPolicy(feature_embedder=fe) + second_byom = learn_to_pick.PyTorchPolicy(feature_embedder=fe) + + torch.manual_seed(0) + + first_picker = learn_to_pick.PickBest.create(policy=first_byom, selection_scorer=CustomSelectionScorer()) + sim1.run(first_picker, 5) + first_byom.save(first_model_path) + + second_byom.load(first_model_path) + second_picker = learn_to_pick.PickBest.create(policy=second_byom, selection_scorer=CustomSelectionScorer()) + sim1.run(second_picker, 5) + + torch.manual_seed(0) + all_byom = learn_to_pick.PyTorchPolicy(feature_embedder=fe) + torch.manual_seed(0) + all_picker = learn_to_pick.PickBest.create(policy=all_byom, selection_scorer=CustomSelectionScorer()) + sim2.run(all_picker, 10) + + verify_same_models(second_byom.workspace, all_byom.workspace) + verify_same_optimizers(second_byom.workspace.optim, all_byom.workspace.optim) From 2ec66ab2eaf23a11adf6bb81d51d3e98fc920883 Mon Sep 17 00:00:00 2001 From: cheng Date: Tue, 14 Nov 2023 18:14:13 +0000 Subject: [PATCH 04/16] fix format --- src/learn_to_pick/__init__.py | 9 ++-- src/learn_to_pick/byom/igw.py | 7 +++- src/learn_to_pick/byom/logistic_regression.py | 35 ++++++++++++---- .../byom/pytorch_feature_embedder.py | 15 ++++--- src/learn_to_pick/byom/pytorch_policy.py | 27 ++++++------ tests/unit_tests/test_byom.py | 41 +++++++++++-------- 6 files changed, 81 insertions(+), 53 deletions(-) diff --git a/src/learn_to_pick/__init__.py b/src/learn_to_pick/__init__.py index 11f0b59..844c133 100644 --- a/src/learn_to_pick/__init__.py +++ b/src/learn_to_pick/__init__.py @@ -21,13 +21,10 @@ PickBestSelected, ) -from learn_to_pick.byom.pytorch_policy import ( - PyTorchPolicy -) +from learn_to_pick.byom.pytorch_policy import PyTorchPolicy + +from learn_to_pick.byom.pytorch_feature_embedder import PyTorchFeatureEmbedder -from learn_to_pick.byom.pytorch_feature_embedder import ( - PyTorchFeatureEmbedder -) def configure_logger() -> None: logger = logging.getLogger(__name__) diff --git a/src/learn_to_pick/byom/igw.py b/src/learn_to_pick/byom/igw.py index 80369a3..e7d4011 100644 --- a/src/learn_to_pick/byom/igw.py +++ b/src/learn_to_pick/byom/igw.py @@ -1,16 +1,19 @@ import torch + def IGW(fhat, gamma): from math import sqrt + fhatahat, ahat = fhat.max(dim=1) A = fhat.shape[1] gamma *= sqrt(A) - p = 1 / (A + gamma * (fhatahat.unsqueeze(1) - fhat)) + p = 1 / (A + gamma * (fhatahat.unsqueeze(1) - fhat)) sump = p.sum(dim=1) p[range(p.shape[0]), ahat] += torch.clamp(1 - sump, min=0, max=None) return torch.multinomial(p, num_samples=1).squeeze(1), ahat + def SamplingIGW(A, P, gamma): exploreind, _ = IGW(P, gamma) - explore = [ ind for _, ind in zip(A, exploreind) ] + explore = [ind for _, ind in zip(A, exploreind)] return explore diff --git a/src/learn_to_pick/byom/logistic_regression.py b/src/learn_to_pick/byom/logistic_regression.py index ccbe386..d345567 100644 --- a/src/learn_to_pick/byom/logistic_regression.py +++ b/src/learn_to_pick/byom/logistic_regression.py @@ -2,16 +2,27 @@ import torch import torch.nn.functional as F + class MLP(torch.nn.Module): @staticmethod def new_gelu(x): import math - return 0.5 * x * (1.0 + torch.tanh(math.sqrt(2.0 / math.pi) * (x + 0.044715 * torch.pow(x, 3.0)))) + + return ( + 0.5 + * x + * ( + 1.0 + + torch.tanh( + math.sqrt(2.0 / math.pi) * (x + 0.044715 * torch.pow(x, 3.0)) + ) + ) + ) def __init__(self, dim): super().__init__() - self.c_fc = torch.nn.Linear(dim, 4 * dim) - self.c_proj = torch.nn.Linear(4 * dim, dim) + self.c_fc = torch.nn.Linear(dim, 4 * dim) + self.c_proj = torch.nn.Linear(4 * dim, dim) self.dropout = torch.nn.Dropout(0.5) def forward(self, x): @@ -21,6 +32,7 @@ def forward(self, x): x = self.dropout(x) return x + class Block(torch.nn.Module): def __init__(self, dim): super().__init__() @@ -29,13 +41,14 @@ def __init__(self, dim): def forward(self, x): return x + self.layer(x) + class ResidualLogisticRegressor(torch.nn.Module): def __init__(self, in_features, depth, device): super().__init__() self._in_features = in_features self._depth = depth - self.blocks = torch.nn.Sequential(*[ Block(in_features) for _ in range(depth) ]) - self.linear = torch.nn.Linear(in_features=in_features, out_features=1) + self.blocks = torch.nn.Sequential(*[Block(in_features) for _ in range(depth)]) + self.linear = torch.nn.Linear(in_features=in_features, out_features=1) self.optim = parameterfree.COCOB(self.parameters()) self._device = device @@ -53,9 +66,15 @@ def logits(self, X, A): # X = batch x features # A = batch x actionbatch x actionfeatures - Xreshap = X.unsqueeze(1).expand(-1, A.shape[1], -1) # batch x actionbatch x features - XA = torch.cat((Xreshap, A), dim=-1).reshape(X.shape[0], A.shape[1], -1).to(self._device) # batch x actionbatch x (features + actionfeatures) - return self.linear(self.blocks(XA)).squeeze(2) # batch x actionbatch + Xreshap = X.unsqueeze(1).expand( + -1, A.shape[1], -1 + ) # batch x actionbatch x features + XA = ( + torch.cat((Xreshap, A), dim=-1) + .reshape(X.shape[0], A.shape[1], -1) + .to(self._device) + ) # batch x actionbatch x (features + actionfeatures) + return self.linear(self.blocks(XA)).squeeze(2) # batch x actionbatch def predict(self, X, A): self.eval() diff --git a/src/learn_to_pick/byom/pytorch_feature_embedder.py b/src/learn_to_pick/byom/pytorch_feature_embedder.py index 09491ac..9e7cf14 100644 --- a/src/learn_to_pick/byom/pytorch_feature_embedder.py +++ b/src/learn_to_pick/byom/pytorch_feature_embedder.py @@ -2,12 +2,11 @@ from sentence_transformers import SentenceTransformer import torch -class PyTorchFeatureEmbedder(): #rl_chain.Embedder[rl_chain.PickBestEvent] - def __init__( - self, auto_embed, model = None, *args, **kwargs - ): + +class PyTorchFeatureEmbedder: + def __init__(self, auto_embed, model=None, *args, **kwargs): if model is None: - model = model = SentenceTransformer('all-MiniLM-L6-v2') + model = model = SentenceTransformer("all-MiniLM-L6-v2") self.model = model self.auto_embed = auto_embed @@ -84,4 +83,8 @@ def format(self, event: rl_chain.PickBestEvent): if cost is None: return context, actions else: - return torch.Tensor([[-1.0 * cost]]), context, actions[:,chosen_action,:].unsqueeze(1) + return ( + torch.Tensor([[-1.0 * cost]]), + context, + actions[:, chosen_action, :].unsqueeze(1), + ) diff --git a/src/learn_to_pick/byom/pytorch_policy.py b/src/learn_to_pick/byom/pytorch_policy.py index 604b993..37eb51c 100644 --- a/src/learn_to_pick/byom/pytorch_policy.py +++ b/src/learn_to_pick/byom/pytorch_policy.py @@ -10,14 +10,15 @@ def __init__( self, feature_embedder, depth: int = 2, - device: str = 'cuda' if torch.cuda.is_available() else 'cpu', + device: str = "cuda" if torch.cuda.is_available() else "cpu", *args, **kwargs, ): print(f"Device: {device}") super().__init__(*args, **kwargs) self.workspace = ResidualLogisticRegressor( - feature_embedder.model.get_sentence_embedding_dimension() * 2, depth, device).to(device) + feature_embedder.model.get_sentence_embedding_dimension() * 2, depth, device + ).to(device) self.feature_embedder = feature_embedder self.device = device self.index = 0 @@ -34,6 +35,7 @@ def predict(self, event): p = self.workspace.predict(X, A) # print(f"p: {p}") import math + explore = SamplingIGW(A, p, math.sqrt(self.index)) self.index += 1 # print(f"explore: {explore}") @@ -58,11 +60,11 @@ def log(self, event): def save(self, path) -> None: state = { - 'workspace_state_dict': self.workspace.state_dict(), - 'optimizer_state_dict': self.workspace.optim.state_dict(), - 'device': self.device, - 'index': self.index, - 'loss': self.loss + "workspace_state_dict": self.workspace.state_dict(), + "optimizer_state_dict": self.workspace.optim.state_dict(), + "device": self.device, + "index": self.index, + "loss": self.loss, } print(f"Saving model to {path}") dir, _ = os.path.split(path) @@ -70,7 +72,6 @@ def save(self, path) -> None: os.makedirs(dir, exist_ok=True) torch.save(state, path) - def load(self, path) -> None: import parameterfree @@ -78,10 +79,10 @@ def load(self, path) -> None: print(f"Loading model from {path}") checkpoint = torch.load(path, map_location=self.device) - self.workspace.load_state_dict(checkpoint['workspace_state_dict']) + self.workspace.load_state_dict(checkpoint["workspace_state_dict"]) self.workspace.optim = parameterfree.COCOB(self.workspace.parameters()) - self.workspace.optim.load_state_dict(checkpoint['optimizer_state_dict']) - self.device = checkpoint['device'] + self.workspace.optim.load_state_dict(checkpoint["optimizer_state_dict"]) + self.device = checkpoint["device"] self.workspace.to(self.device) - self.index = checkpoint['index'] - self.loss = checkpoint['loss'] + self.index = checkpoint["index"] + self.loss = checkpoint["loss"] diff --git a/tests/unit_tests/test_byom.py b/tests/unit_tests/test_byom.py index 06a71b7..75c633d 100644 --- a/tests/unit_tests/test_byom.py +++ b/tests/unit_tests/test_byom.py @@ -7,7 +7,8 @@ import learn_to_pick -CHECKPOINT_DIR = 'test_models' +CHECKPOINT_DIR = "test_models" + @pytest.fixture def remove_checkpoint(): @@ -15,17 +16,12 @@ def remove_checkpoint(): if os.path.isdir(CHECKPOINT_DIR): shutil.rmtree(CHECKPOINT_DIR) + class CustomSelectionScorer(learn_to_pick.SelectionScorer): def get_score(self, user, time_of_day, article): preferences = { - 'Tom': { - 'morning': 'politics', - 'afternoon': 'music' - }, - 'Anna': { - 'morning': 'sports', - 'afternoon': 'politics' - } + "Tom": {"morning": "politics", "afternoon": "music"}, + "Anna": {"morning": "sports", "afternoon": "politics"}, } return int(preferences[user][time_of_day] == article) @@ -58,16 +54,19 @@ def run(self, pytorch_picker, T): user = self._choose_user() time_of_day = self._choose_time_of_day() pytorch_picker.run( - article = learn_to_pick.ToSelectFrom(self.articles), - user = learn_to_pick.BasedOn(user), - time_of_day = learn_to_pick.BasedOn(time_of_day), + article=learn_to_pick.ToSelectFrom(self.articles), + user=learn_to_pick.BasedOn(user), + time_of_day=learn_to_pick.BasedOn(time_of_day), ) + def verify_same_models(model1, model2): for p1, p2 in zip(model1.parameters(), model2.parameters()): assert torch.equal(p1, p2), "The models' parameters are not equal." - for (name1, buffer1), (name2, buffer2) in zip(model1.named_buffers(), model2.named_buffers()): + for (name1, buffer1), (name2, buffer2) in zip( + model1.named_buffers(), model2.named_buffers() + ): assert name1 == name2, "Buffer names do not match." assert torch.equal(buffer1, buffer2), f"The buffers {name1} are not equal." @@ -86,7 +85,7 @@ def verify_same_optimizers(optimizer1, optimizer2): return False for key in state_dict1: - if key == 'state': + if key == "state": if state_dict1[key].keys() != state_dict2[key].keys(): return False for subkey in state_dict1[key]: @@ -104,7 +103,7 @@ def test_save_load(remove_checkpoint): sim2 = Simulator() fe = learn_to_pick.PyTorchFeatureEmbedder(auto_embed=True) - first_model_path = f'{CHECKPOINT_DIR}/first.checkpoint' + first_model_path = f"{CHECKPOINT_DIR}/first.checkpoint" torch.manual_seed(0) first_byom = learn_to_pick.PyTorchPolicy(feature_embedder=fe) @@ -112,18 +111,24 @@ def test_save_load(remove_checkpoint): torch.manual_seed(0) - first_picker = learn_to_pick.PickBest.create(policy=first_byom, selection_scorer=CustomSelectionScorer()) + first_picker = learn_to_pick.PickBest.create( + policy=first_byom, selection_scorer=CustomSelectionScorer() + ) sim1.run(first_picker, 5) first_byom.save(first_model_path) second_byom.load(first_model_path) - second_picker = learn_to_pick.PickBest.create(policy=second_byom, selection_scorer=CustomSelectionScorer()) + second_picker = learn_to_pick.PickBest.create( + policy=second_byom, selection_scorer=CustomSelectionScorer() + ) sim1.run(second_picker, 5) torch.manual_seed(0) all_byom = learn_to_pick.PyTorchPolicy(feature_embedder=fe) torch.manual_seed(0) - all_picker = learn_to_pick.PickBest.create(policy=all_byom, selection_scorer=CustomSelectionScorer()) + all_picker = learn_to_pick.PickBest.create( + policy=all_byom, selection_scorer=CustomSelectionScorer() + ) sim2.run(all_picker, 10) verify_same_models(second_byom.workspace, all_byom.workspace) From 8bb09a1a6b21400a3117d200fe2859f7422ff9d4 Mon Sep 17 00:00:00 2001 From: cheng Date: Thu, 16 Nov 2023 03:53:29 +0000 Subject: [PATCH 05/16] WIP --- notebooks/news_recommendation_byom.ipynb | 92 +++++++++++------- .../byom/pytorch_feature_embedder.py | 96 ++++++------------- src/learn_to_pick/byom/pytorch_policy.py | 2 +- 3 files changed, 85 insertions(+), 105 deletions(-) diff --git a/notebooks/news_recommendation_byom.ipynb b/notebooks/news_recommendation_byom.ipynb index 1d35c41..a0037ba 100644 --- a/notebooks/news_recommendation_byom.ipynb +++ b/notebooks/news_recommendation_byom.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 12, + "execution_count": 10, "metadata": {}, "outputs": [ { @@ -21,7 +21,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 11, "metadata": {}, "outputs": [ { @@ -99,8 +99,8 @@ "Requirement already satisfied: certifi>=2017.4.17 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from requests->huggingface-hub>=0.4.0->sentence-transformers>=2.2.2->learn-to-pick==0.0.3) (2023.7.22)\n", "Building wheels for collected packages: learn-to-pick\n", " Building wheel for learn-to-pick (setup.py) ... \u001b[?25ldone\n", - "\u001b[?25h Created wheel for learn-to-pick: filename=learn_to_pick-0.0.3-py3-none-any.whl size=22905 sha256=212caafaac49093734f8b40ad0fbc03ac97fa9af06f7166aaa7252166a0c4395\n", - " Stored in directory: /tmp/pip-ephem-wheel-cache-qsmxj9e8/wheels/18/bf/25/d8dda8a9a6b5284eaed510a4708ef9b22b9894a5e94b329ea2\n", + "\u001b[?25h Created wheel for learn-to-pick: filename=learn_to_pick-0.0.3-py3-none-any.whl size=23183 sha256=c440095cf98c3e38f6cb6539c62fd4764ccc46f0554a5416fbcc4e07b34a949a\n", + " Stored in directory: /tmp/pip-ephem-wheel-cache-wmr6btmi/wheels/18/bf/25/d8dda8a9a6b5284eaed510a4708ef9b22b9894a5e94b329ea2\n", "Successfully built learn-to-pick\n", "Installing collected packages: learn-to-pick\n", " Attempting uninstall: learn-to-pick\n", @@ -118,7 +118,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 12, "metadata": {}, "outputs": [ { @@ -149,7 +149,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 13, "metadata": {}, "outputs": [], "source": [ @@ -169,7 +169,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 14, "metadata": {}, "outputs": [], "source": [ @@ -198,7 +198,7 @@ " chosen_article = picked[\"article\"]\n", " user = event.based_on[\"user\"]\n", " time_of_day = event.based_on[\"time_of_day\"]\n", - " score = self.get_score(user[0], time_of_day[0], chosen_article)\n", + " score = self.get_score(user, time_of_day, chosen_article)\n", " return score" ] }, @@ -213,7 +213,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 15, "metadata": {}, "outputs": [], "source": [ @@ -223,42 +223,64 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 16, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Device: cuda\n" + ] + } + ], "source": [ "from learn_to_pick import PyTorchPolicy\n", "\n", - "picker = learn_to_pick.PickBest.create(\n", - " metrics_step=100, metrics_window_size=100, selection_scorer=CustomSelectionScorer())\n", + "# picker = learn_to_pick.PickBest.create(\n", + "# metrics_step=100, metrics_window_size=100, selection_scorer=CustomSelectionScorer())\n", "pytorch_picker = learn_to_pick.PickBest.create(\n", " metrics_step=100, metrics_window_size=100, policy=PyTorchPolicy(feature_embedder=fe), selection_scorer=CustomSelectionScorer())\n", - "random_picker = learn_to_pick.PickBest.create(\n", - " metrics_step=100, metrics_window_size=100, policy=learn_to_pick.PickBestRandomPolicy(), selection_scorer=CustomSelectionScorer())" + "# random_picker = learn_to_pick.PickBest.create(\n", + "# metrics_step=100, metrics_window_size=100, policy=learn_to_pick.PickBestRandomPolicy(), selection_scorer=CustomSelectionScorer())" ] }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 17, "metadata": {}, - "outputs": [], + "outputs": [ + { + "ename": "KeyboardInterrupt", + "evalue": "", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m/home/chetan/dev/learn_to_pick/notebooks/news_recommendation_byom.ipynb Cell 10\u001b[0m line \u001b[0;36m1\n\u001b[1;32m 5\u001b[0m time_of_day \u001b[39m=\u001b[39m choose_time_of_day(times_of_day)\n\u001b[1;32m 6\u001b[0m \u001b[39m# picker.run(\u001b[39;00m\n\u001b[1;32m 7\u001b[0m \u001b[39m# article = learn_to_pick.ToSelectFrom(articles),\u001b[39;00m\n\u001b[1;32m 8\u001b[0m \u001b[39m# user = learn_to_pick.BasedOn(user),\u001b[39;00m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 15\u001b[0m \u001b[39m# time_of_day = learn_to_pick.BasedOn(time_of_day),\u001b[39;00m\n\u001b[1;32m 16\u001b[0m \u001b[39m# )\u001b[39;00m\n\u001b[0;32m---> 18\u001b[0m pytorch_picker\u001b[39m.\u001b[39;49mrun(\n\u001b[1;32m 19\u001b[0m article \u001b[39m=\u001b[39;49m learn_to_pick\u001b[39m.\u001b[39;49mToSelectFrom(articles),\n\u001b[1;32m 20\u001b[0m user \u001b[39m=\u001b[39;49m learn_to_pick\u001b[39m.\u001b[39;49mBasedOn(user),\n\u001b[1;32m 21\u001b[0m time_of_day \u001b[39m=\u001b[39;49m learn_to_pick\u001b[39m.\u001b[39;49mBasedOn(time_of_day),\n\u001b[1;32m 22\u001b[0m )\n", + "File \u001b[0;32m/anaconda/envs/learn_to_pick/lib/python3.10/site-packages/learn_to_pick/base.py:452\u001b[0m, in \u001b[0;36mRLLoop.run\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 447\u001b[0m \u001b[39mraise\u001b[39;00m \u001b[39mValueError\u001b[39;00m(\n\u001b[1;32m 448\u001b[0m \u001b[39mf\u001b[39m\u001b[39m\"\u001b[39m\u001b[39mThe input key \u001b[39m\u001b[39m{\u001b[39;00m\u001b[39mself\u001b[39m\u001b[39m.\u001b[39mselected_input_key\u001b[39m}\u001b[39;00m\u001b[39m is reserved. Please use a different key.\u001b[39m\u001b[39m\"\u001b[39m\n\u001b[1;32m 449\u001b[0m )\n\u001b[1;32m 451\u001b[0m event: TEvent \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_call_before_predict(inputs\u001b[39m=\u001b[39minputs)\n\u001b[0;32m--> 452\u001b[0m prediction \u001b[39m=\u001b[39m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mpolicy\u001b[39m.\u001b[39;49mpredict(event\u001b[39m=\u001b[39;49mevent)\n\u001b[1;32m 453\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mmetrics:\n\u001b[1;32m 454\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mmetrics\u001b[39m.\u001b[39mon_decision()\n", + "File \u001b[0;32m/anaconda/envs/learn_to_pick/lib/python3.10/site-packages/learn_to_pick/byom/pytorch_policy.py:44\u001b[0m, in \u001b[0;36mPyTorchPolicy.predict\u001b[0;34m(self, event)\u001b[0m\n\u001b[1;32m 42\u001b[0m r \u001b[39m=\u001b[39m []\n\u001b[1;32m 43\u001b[0m \u001b[39mfor\u001b[39;00m index \u001b[39min\u001b[39;00m \u001b[39mrange\u001b[39m(p\u001b[39m.\u001b[39mshape[\u001b[39m1\u001b[39m]):\n\u001b[0;32m---> 44\u001b[0m \u001b[39mif\u001b[39;00m index \u001b[39m==\u001b[39m explore[\u001b[39m0\u001b[39m]:\n\u001b[1;32m 45\u001b[0m r\u001b[39m.\u001b[39mappend((index, \u001b[39m1\u001b[39m))\n\u001b[1;32m 46\u001b[0m \u001b[39melse\u001b[39;00m:\n", + "\u001b[0;31mKeyboardInterrupt\u001b[0m: " + ] + } + ], "source": [ "# randomly pick users and times of day\n", "\n", "for i in range(2500):\n", " user = choose_user(users)\n", " time_of_day = choose_time_of_day(times_of_day)\n", - " picker.run(\n", - " article = learn_to_pick.ToSelectFrom(articles),\n", - " user = learn_to_pick.BasedOn(user),\n", - " time_of_day = learn_to_pick.BasedOn(time_of_day),\n", - " )\n", + " # picker.run(\n", + " # article = learn_to_pick.ToSelectFrom(articles),\n", + " # user = learn_to_pick.BasedOn(user),\n", + " # time_of_day = learn_to_pick.BasedOn(time_of_day),\n", + " # )\n", "\n", - " random_picker.run(\n", - " article = learn_to_pick.ToSelectFrom(articles),\n", - " user = learn_to_pick.BasedOn(user),\n", - " time_of_day = learn_to_pick.BasedOn(time_of_day),\n", - " )\n", + " # random_picker.run(\n", + " # article = learn_to_pick.ToSelectFrom(articles),\n", + " # user = learn_to_pick.BasedOn(user),\n", + " # time_of_day = learn_to_pick.BasedOn(time_of_day),\n", + " # )\n", "\n", " pytorch_picker.run(\n", " article = learn_to_pick.ToSelectFrom(articles),\n", @@ -276,21 +298,19 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": null, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "The final average score for the default policy, calculated over a rolling window, is: 0.95\n", - "The final average score for the default policy, calculated over a rolling window, is: 0.77\n", - "The final average score for the random policy, calculated over a rolling window, is: 0.58\n" + "The final average score for the default policy, calculated over a rolling window, is: 0.86\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -301,15 +321,15 @@ ], "source": [ "from matplotlib import pyplot as plt\n", - "picker.metrics.to_pandas()['score'].plot(label=\"vw\")\n", - "random_picker.metrics.to_pandas()['score'].plot(label=\"random\")\n", + "# picker.metrics.to_pandas()['score'].plot(label=\"vw\")\n", + "# random_picker.metrics.to_pandas()['score'].plot(label=\"random\")\n", "pytorch_picker.metrics.to_pandas()['score'].plot(label=\"pytorch\")\n", "\n", "plt.legend()\n", "\n", "print(f\"The final average score for the default policy, calculated over a rolling window, is: {pytorch_picker.metrics.to_pandas()['score'].iloc[-1]}\")\n", - "print(f\"The final average score for the default policy, calculated over a rolling window, is: {picker.metrics.to_pandas()['score'].iloc[-1]}\")\n", - "print(f\"The final average score for the random policy, calculated over a rolling window, is: {random_picker.metrics.to_pandas()['score'].iloc[-1]}\")\n" + "# print(f\"The final average score for the default policy, calculated over a rolling window, is: {picker.metrics.to_pandas()['score'].iloc[-1]}\")\n", + "# print(f\"The final average score for the random policy, calculated over a rolling window, is: {random_picker.metrics.to_pandas()['score'].iloc[-1]}\")\n" ] } ], diff --git a/src/learn_to_pick/byom/pytorch_feature_embedder.py b/src/learn_to_pick/byom/pytorch_feature_embedder.py index 9e7cf14..0ae9299 100644 --- a/src/learn_to_pick/byom/pytorch_feature_embedder.py +++ b/src/learn_to_pick/byom/pytorch_feature_embedder.py @@ -1,90 +1,50 @@ -import learn_to_pick as rl_chain from sentence_transformers import SentenceTransformer import torch - +from learn_to_pick import PickBestFeaturizer class PyTorchFeatureEmbedder: - def __init__(self, auto_embed, model=None, *args, **kwargs): + def __init__(self, auto_embed=False, model=None, *args, **kwargs): if model is None: - model = model = SentenceTransformer("all-MiniLM-L6-v2") + model = SentenceTransformer("all-MiniLM-L6-v2") self.model = model - self.auto_embed = auto_embed + self.featurizer = PickBestFeaturizer(auto_embed=auto_embed) + def encode(self, stuff): embeddings = self.model.encode(stuff, convert_to_tensor=True) normalized = torch.nn.functional.normalize(embeddings) return normalized - def get_label(self, event: rl_chain.PickBestEvent) -> tuple: - cost = None - if event.selected: - chosen_action = event.selected.index - cost = ( - -1.0 * event.selected.score - if event.selected.score is not None - else None - ) - prob = event.selected.probability - return chosen_action, cost, prob - else: - return None, None, None - - def get_context_and_action_embeddings(self, event: rl_chain.PickBestEvent) -> tuple: - context_emb = rl_chain.embed(event.based_on, self) if event.based_on else None - to_select_from_var_name, to_select_from = next( - iter(event.to_select_from.items()), (None, None) - ) - action_embs = ( - ( - rl_chain.embed(to_select_from, self, to_select_from_var_name) - if event.to_select_from - else None - ) - if to_select_from - else None - ) - - if not context_emb or not action_embs: - raise ValueError( - "Context and to_select_from must be provided in the inputs dictionary" - ) - return context_emb, action_embs + def convert_features_to_text(self, features): + def process_feature(feature): + if isinstance(feature, dict): + return " ".join([f"{k}_{process_feature(v)}" for k, v in feature.items()]) + elif isinstance(feature, list): + return " ".join([process_feature(elem) for elem in feature]) + else: + return str(feature) - def format(self, event: rl_chain.PickBestEvent): - chosen_action, cost, prob = self.get_label(event) - context_emb, action_embs = self.get_context_and_action_embeddings(event) + return process_feature(features) - context = "" - for context_item in context_emb: - for ns, based_on in context_item.items(): - e = " ".join(based_on) if isinstance(based_on, list) else based_on - context += f"{ns}={e} " - if self.auto_embed: - context = self.encode([context]) + def format(self, event): + # TODO: handle dense + context_featurized, actions_featurized, selected = self.featurizer.featurize(event) - actions = [] - for action in action_embs: - action_str = "" - for ns, action_embedding in action.items(): - e = ( - " ".join(action_embedding) - if isinstance(action_embedding, list) - else action_embedding - ) - action_str += f"{ns}={e} " - actions.append(action_str) + context_sparse = self.encode([self.convert_features_to_text(context_featurized.sparse)]) - if self.auto_embed: - actions = self.encode(actions).unsqueeze(0) + actions_sparse = [] + for action_featurized in actions_featurized: + actions_sparse.append(self.convert_features_to_text(action_featurized.sparse)) + actions_sparse = self.encode(actions_sparse).unsqueeze(0) - if cost is None: - return context, actions - else: + if selected.score is not None: return ( - torch.Tensor([[-1.0 * cost]]), - context, - actions[:, chosen_action, :].unsqueeze(1), + torch.Tensor([[selected.score]]), + context_sparse, + actions_sparse[:, selected.index, :].unsqueeze(1), ) + else: + return context_sparse, actions_sparse diff --git a/src/learn_to_pick/byom/pytorch_policy.py b/src/learn_to_pick/byom/pytorch_policy.py index 37eb51c..93c2ba5 100644 --- a/src/learn_to_pick/byom/pytorch_policy.py +++ b/src/learn_to_pick/byom/pytorch_policy.py @@ -47,7 +47,7 @@ def predict(self, event): r.append((index, 0)) # print(f"returning: {r}") return r - return [(index, val) for index, val in enumerate(p[0].tolist())] + def learn(self, event): R, X, A = self.feature_embedder.format(event) From b093e1b49151b8e92376975c7391c55c71701b16 Mon Sep 17 00:00:00 2001 From: cheng Date: Fri, 17 Nov 2023 18:22:32 +0000 Subject: [PATCH 06/16] Fix test --- notebooks/news_recommendation_byom.ipynb | 169 +++++------------------ tests/unit_tests/test_byom.py | 2 +- 2 files changed, 36 insertions(+), 135 deletions(-) diff --git a/notebooks/news_recommendation_byom.ipynb b/notebooks/news_recommendation_byom.ipynb index a0037ba..b74f4ca 100644 --- a/notebooks/news_recommendation_byom.ipynb +++ b/notebooks/news_recommendation_byom.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 10, + "execution_count": 37, "metadata": {}, "outputs": [ { @@ -21,104 +21,17 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "huggingface/tokenizers: The current process just got forked, after parallelism has already been used. Disabling parallelism to avoid deadlocks...\n", - "To disable this warning, you can either:\n", - "\t- Avoid using `tokenizers` before the fork if possible\n", - "\t- Explicitly set the environment variable TOKENIZERS_PARALLELISM=(true | false)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Processing /home/chetan/dev/learn_to_pick\n", - " Preparing metadata (setup.py) ... \u001b[?25ldone\n", - "\u001b[?25hRequirement already satisfied: numpy>=1.24.4 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from learn-to-pick==0.0.3) (1.26.1)\n", - "Requirement already satisfied: pandas>=2.0.3 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from learn-to-pick==0.0.3) (2.1.1)\n", - "Requirement already satisfied: vowpal-wabbit-next==0.7.0 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from learn-to-pick==0.0.3) (0.7.0)\n", - "Requirement already satisfied: sentence-transformers>=2.2.2 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from learn-to-pick==0.0.3) (2.2.2)\n", - "Requirement already satisfied: torch==2.0.1 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from learn-to-pick==0.0.3) (2.0.1)\n", - "Requirement already satisfied: pyskiplist in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from learn-to-pick==0.0.3) (1.0.0)\n", - "Requirement already satisfied: parameterfree in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from learn-to-pick==0.0.3) (0.0.1)\n", - "Requirement already satisfied: filelock in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from torch==2.0.1->learn-to-pick==0.0.3) (3.12.4)\n", - "Requirement already satisfied: typing-extensions in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from torch==2.0.1->learn-to-pick==0.0.3) (4.8.0)\n", - "Requirement already satisfied: sympy in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from torch==2.0.1->learn-to-pick==0.0.3) (1.12)\n", - "Requirement already satisfied: networkx in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from torch==2.0.1->learn-to-pick==0.0.3) (3.2)\n", - "Requirement already satisfied: jinja2 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from torch==2.0.1->learn-to-pick==0.0.3) (3.1.2)\n", - "Requirement already satisfied: nvidia-cuda-nvrtc-cu11==11.7.99 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from torch==2.0.1->learn-to-pick==0.0.3) (11.7.99)\n", - "Requirement already satisfied: nvidia-cuda-runtime-cu11==11.7.99 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from torch==2.0.1->learn-to-pick==0.0.3) (11.7.99)\n", - "Requirement already satisfied: nvidia-cuda-cupti-cu11==11.7.101 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from torch==2.0.1->learn-to-pick==0.0.3) (11.7.101)\n", - "Requirement already satisfied: nvidia-cudnn-cu11==8.5.0.96 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from torch==2.0.1->learn-to-pick==0.0.3) (8.5.0.96)\n", - "Requirement already satisfied: nvidia-cublas-cu11==11.10.3.66 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from torch==2.0.1->learn-to-pick==0.0.3) (11.10.3.66)\n", - "Requirement already satisfied: nvidia-cufft-cu11==10.9.0.58 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from torch==2.0.1->learn-to-pick==0.0.3) (10.9.0.58)\n", - "Requirement already satisfied: nvidia-curand-cu11==10.2.10.91 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from torch==2.0.1->learn-to-pick==0.0.3) (10.2.10.91)\n", - "Requirement already satisfied: nvidia-cusolver-cu11==11.4.0.1 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from torch==2.0.1->learn-to-pick==0.0.3) (11.4.0.1)\n", - "Requirement already satisfied: nvidia-cusparse-cu11==11.7.4.91 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from torch==2.0.1->learn-to-pick==0.0.3) (11.7.4.91)\n", - "Requirement already satisfied: nvidia-nccl-cu11==2.14.3 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from torch==2.0.1->learn-to-pick==0.0.3) (2.14.3)\n", - "Requirement already satisfied: nvidia-nvtx-cu11==11.7.91 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from torch==2.0.1->learn-to-pick==0.0.3) (11.7.91)\n", - "Requirement already satisfied: triton==2.0.0 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from torch==2.0.1->learn-to-pick==0.0.3) (2.0.0)\n", - "Requirement already satisfied: setuptools in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from nvidia-cublas-cu11==11.10.3.66->torch==2.0.1->learn-to-pick==0.0.3) (68.0.0)\n", - "Requirement already satisfied: wheel in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from nvidia-cublas-cu11==11.10.3.66->torch==2.0.1->learn-to-pick==0.0.3) (0.41.2)\n", - "Requirement already satisfied: cmake in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from triton==2.0.0->torch==2.0.1->learn-to-pick==0.0.3) (3.27.7)\n", - "Requirement already satisfied: lit in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from triton==2.0.0->torch==2.0.1->learn-to-pick==0.0.3) (17.0.4)\n", - "Requirement already satisfied: python-dateutil>=2.8.2 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from pandas>=2.0.3->learn-to-pick==0.0.3) (2.8.2)\n", - "Requirement already satisfied: pytz>=2020.1 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from pandas>=2.0.3->learn-to-pick==0.0.3) (2023.3.post1)\n", - "Requirement already satisfied: tzdata>=2022.1 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from pandas>=2.0.3->learn-to-pick==0.0.3) (2023.3)\n", - "Requirement already satisfied: transformers<5.0.0,>=4.6.0 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from sentence-transformers>=2.2.2->learn-to-pick==0.0.3) (4.34.1)\n", - "Requirement already satisfied: tqdm in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from sentence-transformers>=2.2.2->learn-to-pick==0.0.3) (4.66.1)\n", - "Requirement already satisfied: torchvision in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from sentence-transformers>=2.2.2->learn-to-pick==0.0.3) (0.15.2)\n", - "Requirement already satisfied: scikit-learn in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from sentence-transformers>=2.2.2->learn-to-pick==0.0.3) (1.3.2)\n", - "Requirement already satisfied: scipy in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from sentence-transformers>=2.2.2->learn-to-pick==0.0.3) (1.11.3)\n", - "Requirement already satisfied: nltk in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from sentence-transformers>=2.2.2->learn-to-pick==0.0.3) (3.8.1)\n", - "Requirement already satisfied: sentencepiece in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from sentence-transformers>=2.2.2->learn-to-pick==0.0.3) (0.1.99)\n", - "Requirement already satisfied: huggingface-hub>=0.4.0 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from sentence-transformers>=2.2.2->learn-to-pick==0.0.3) (0.17.3)\n", - "Requirement already satisfied: fsspec in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from huggingface-hub>=0.4.0->sentence-transformers>=2.2.2->learn-to-pick==0.0.3) (2023.10.0)\n", - "Requirement already satisfied: requests in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from huggingface-hub>=0.4.0->sentence-transformers>=2.2.2->learn-to-pick==0.0.3) (2.31.0)\n", - "Requirement already satisfied: pyyaml>=5.1 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from huggingface-hub>=0.4.0->sentence-transformers>=2.2.2->learn-to-pick==0.0.3) (6.0.1)\n", - "Requirement already satisfied: packaging>=20.9 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from huggingface-hub>=0.4.0->sentence-transformers>=2.2.2->learn-to-pick==0.0.3) (23.2)\n", - "Requirement already satisfied: six>=1.5 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from python-dateutil>=2.8.2->pandas>=2.0.3->learn-to-pick==0.0.3) (1.16.0)\n", - "Requirement already satisfied: regex!=2019.12.17 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from transformers<5.0.0,>=4.6.0->sentence-transformers>=2.2.2->learn-to-pick==0.0.3) (2023.10.3)\n", - "Requirement already satisfied: tokenizers<0.15,>=0.14 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from transformers<5.0.0,>=4.6.0->sentence-transformers>=2.2.2->learn-to-pick==0.0.3) (0.14.1)\n", - "Requirement already satisfied: safetensors>=0.3.1 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from transformers<5.0.0,>=4.6.0->sentence-transformers>=2.2.2->learn-to-pick==0.0.3) (0.4.0)\n", - "Requirement already satisfied: MarkupSafe>=2.0 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from jinja2->torch==2.0.1->learn-to-pick==0.0.3) (2.1.3)\n", - "Requirement already satisfied: click in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from nltk->sentence-transformers>=2.2.2->learn-to-pick==0.0.3) (8.1.7)\n", - "Requirement already satisfied: joblib in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from nltk->sentence-transformers>=2.2.2->learn-to-pick==0.0.3) (1.3.2)\n", - "Requirement already satisfied: threadpoolctl>=2.0.0 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from scikit-learn->sentence-transformers>=2.2.2->learn-to-pick==0.0.3) (3.2.0)\n", - "Requirement already satisfied: mpmath>=0.19 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from sympy->torch==2.0.1->learn-to-pick==0.0.3) (1.3.0)\n", - "Requirement already satisfied: pillow!=8.3.*,>=5.3.0 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from torchvision->sentence-transformers>=2.2.2->learn-to-pick==0.0.3) (10.1.0)\n", - "Requirement already satisfied: charset-normalizer<4,>=2 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from requests->huggingface-hub>=0.4.0->sentence-transformers>=2.2.2->learn-to-pick==0.0.3) (3.3.1)\n", - "Requirement already satisfied: idna<4,>=2.5 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from requests->huggingface-hub>=0.4.0->sentence-transformers>=2.2.2->learn-to-pick==0.0.3) (3.4)\n", - "Requirement already satisfied: urllib3<3,>=1.21.1 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from requests->huggingface-hub>=0.4.0->sentence-transformers>=2.2.2->learn-to-pick==0.0.3) (2.0.7)\n", - "Requirement already satisfied: certifi>=2017.4.17 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from requests->huggingface-hub>=0.4.0->sentence-transformers>=2.2.2->learn-to-pick==0.0.3) (2023.7.22)\n", - "Building wheels for collected packages: learn-to-pick\n", - " Building wheel for learn-to-pick (setup.py) ... \u001b[?25ldone\n", - "\u001b[?25h Created wheel for learn-to-pick: filename=learn_to_pick-0.0.3-py3-none-any.whl size=23183 sha256=c440095cf98c3e38f6cb6539c62fd4764ccc46f0554a5416fbcc4e07b34a949a\n", - " Stored in directory: /tmp/pip-ephem-wheel-cache-wmr6btmi/wheels/18/bf/25/d8dda8a9a6b5284eaed510a4708ef9b22b9894a5e94b329ea2\n", - "Successfully built learn-to-pick\n", - "Installing collected packages: learn-to-pick\n", - " Attempting uninstall: learn-to-pick\n", - " Found existing installation: learn-to-pick 0.0.3\n", - " Uninstalling learn-to-pick-0.0.3:\n", - " Successfully uninstalled learn-to-pick-0.0.3\n", - "Successfully installed learn-to-pick-0.0.3\n" - ] - } - ], + "outputs": [], "source": [ - "! pip install ../\n", + "# ! pip install ../\n", "# ! pip install matplotlib" ] }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 39, "metadata": {}, "outputs": [ { @@ -149,7 +62,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 40, "metadata": {}, "outputs": [], "source": [ @@ -169,7 +82,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 41, "metadata": {}, "outputs": [], "source": [ @@ -213,17 +126,17 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 42, "metadata": {}, "outputs": [], "source": [ "from learn_to_pick import PyTorchFeatureEmbedder\n", - "fe = PyTorchFeatureEmbedder(auto_embed=True)" + "fe = PyTorchFeatureEmbedder() #auto_embed=True" ] }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 43, "metadata": {}, "outputs": [ { @@ -237,50 +150,36 @@ "source": [ "from learn_to_pick import PyTorchPolicy\n", "\n", - "# picker = learn_to_pick.PickBest.create(\n", - "# metrics_step=100, metrics_window_size=100, selection_scorer=CustomSelectionScorer())\n", + "picker = learn_to_pick.PickBest.create(\n", + " metrics_step=100, metrics_window_size=100, selection_scorer=CustomSelectionScorer())\n", "pytorch_picker = learn_to_pick.PickBest.create(\n", " metrics_step=100, metrics_window_size=100, policy=PyTorchPolicy(feature_embedder=fe), selection_scorer=CustomSelectionScorer())\n", - "# random_picker = learn_to_pick.PickBest.create(\n", - "# metrics_step=100, metrics_window_size=100, policy=learn_to_pick.PickBestRandomPolicy(), selection_scorer=CustomSelectionScorer())" + "random_picker = learn_to_pick.PickBest.create(\n", + " metrics_step=100, metrics_window_size=100, policy=learn_to_pick.PickBestRandomPolicy(), selection_scorer=CustomSelectionScorer())" ] }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 44, "metadata": {}, - "outputs": [ - { - "ename": "KeyboardInterrupt", - "evalue": "", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", - "\u001b[1;32m/home/chetan/dev/learn_to_pick/notebooks/news_recommendation_byom.ipynb Cell 10\u001b[0m line \u001b[0;36m1\n\u001b[1;32m 5\u001b[0m time_of_day \u001b[39m=\u001b[39m choose_time_of_day(times_of_day)\n\u001b[1;32m 6\u001b[0m \u001b[39m# picker.run(\u001b[39;00m\n\u001b[1;32m 7\u001b[0m \u001b[39m# article = learn_to_pick.ToSelectFrom(articles),\u001b[39;00m\n\u001b[1;32m 8\u001b[0m \u001b[39m# user = learn_to_pick.BasedOn(user),\u001b[39;00m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 15\u001b[0m \u001b[39m# time_of_day = learn_to_pick.BasedOn(time_of_day),\u001b[39;00m\n\u001b[1;32m 16\u001b[0m \u001b[39m# )\u001b[39;00m\n\u001b[0;32m---> 18\u001b[0m pytorch_picker\u001b[39m.\u001b[39;49mrun(\n\u001b[1;32m 19\u001b[0m article \u001b[39m=\u001b[39;49m learn_to_pick\u001b[39m.\u001b[39;49mToSelectFrom(articles),\n\u001b[1;32m 20\u001b[0m user \u001b[39m=\u001b[39;49m learn_to_pick\u001b[39m.\u001b[39;49mBasedOn(user),\n\u001b[1;32m 21\u001b[0m time_of_day \u001b[39m=\u001b[39;49m learn_to_pick\u001b[39m.\u001b[39;49mBasedOn(time_of_day),\n\u001b[1;32m 22\u001b[0m )\n", - "File \u001b[0;32m/anaconda/envs/learn_to_pick/lib/python3.10/site-packages/learn_to_pick/base.py:452\u001b[0m, in \u001b[0;36mRLLoop.run\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 447\u001b[0m \u001b[39mraise\u001b[39;00m \u001b[39mValueError\u001b[39;00m(\n\u001b[1;32m 448\u001b[0m \u001b[39mf\u001b[39m\u001b[39m\"\u001b[39m\u001b[39mThe input key \u001b[39m\u001b[39m{\u001b[39;00m\u001b[39mself\u001b[39m\u001b[39m.\u001b[39mselected_input_key\u001b[39m}\u001b[39;00m\u001b[39m is reserved. Please use a different key.\u001b[39m\u001b[39m\"\u001b[39m\n\u001b[1;32m 449\u001b[0m )\n\u001b[1;32m 451\u001b[0m event: TEvent \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_call_before_predict(inputs\u001b[39m=\u001b[39minputs)\n\u001b[0;32m--> 452\u001b[0m prediction \u001b[39m=\u001b[39m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mpolicy\u001b[39m.\u001b[39;49mpredict(event\u001b[39m=\u001b[39;49mevent)\n\u001b[1;32m 453\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mmetrics:\n\u001b[1;32m 454\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mmetrics\u001b[39m.\u001b[39mon_decision()\n", - "File \u001b[0;32m/anaconda/envs/learn_to_pick/lib/python3.10/site-packages/learn_to_pick/byom/pytorch_policy.py:44\u001b[0m, in \u001b[0;36mPyTorchPolicy.predict\u001b[0;34m(self, event)\u001b[0m\n\u001b[1;32m 42\u001b[0m r \u001b[39m=\u001b[39m []\n\u001b[1;32m 43\u001b[0m \u001b[39mfor\u001b[39;00m index \u001b[39min\u001b[39;00m \u001b[39mrange\u001b[39m(p\u001b[39m.\u001b[39mshape[\u001b[39m1\u001b[39m]):\n\u001b[0;32m---> 44\u001b[0m \u001b[39mif\u001b[39;00m index \u001b[39m==\u001b[39m explore[\u001b[39m0\u001b[39m]:\n\u001b[1;32m 45\u001b[0m r\u001b[39m.\u001b[39mappend((index, \u001b[39m1\u001b[39m))\n\u001b[1;32m 46\u001b[0m \u001b[39melse\u001b[39;00m:\n", - "\u001b[0;31mKeyboardInterrupt\u001b[0m: " - ] - } - ], + "outputs": [], "source": [ "# randomly pick users and times of day\n", "\n", "for i in range(2500):\n", " user = choose_user(users)\n", " time_of_day = choose_time_of_day(times_of_day)\n", - " # picker.run(\n", - " # article = learn_to_pick.ToSelectFrom(articles),\n", - " # user = learn_to_pick.BasedOn(user),\n", - " # time_of_day = learn_to_pick.BasedOn(time_of_day),\n", - " # )\n", + " picker.run(\n", + " article = learn_to_pick.ToSelectFrom(articles),\n", + " user = learn_to_pick.BasedOn(user),\n", + " time_of_day = learn_to_pick.BasedOn(time_of_day),\n", + " )\n", "\n", - " # random_picker.run(\n", - " # article = learn_to_pick.ToSelectFrom(articles),\n", - " # user = learn_to_pick.BasedOn(user),\n", - " # time_of_day = learn_to_pick.BasedOn(time_of_day),\n", - " # )\n", + " random_picker.run(\n", + " article = learn_to_pick.ToSelectFrom(articles),\n", + " user = learn_to_pick.BasedOn(user),\n", + " time_of_day = learn_to_pick.BasedOn(time_of_day),\n", + " )\n", "\n", " pytorch_picker.run(\n", " article = learn_to_pick.ToSelectFrom(articles),\n", @@ -298,19 +197,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 45, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "The final average score for the default policy, calculated over a rolling window, is: 0.86\n" + "The final average score for the default policy, calculated over a rolling window, is: 0.97\n", + "The final average score for the default policy, calculated over a rolling window, is: 0.81\n", + "The final average score for the random policy, calculated over a rolling window, is: 0.55\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -321,15 +222,15 @@ ], "source": [ "from matplotlib import pyplot as plt\n", - "# picker.metrics.to_pandas()['score'].plot(label=\"vw\")\n", - "# random_picker.metrics.to_pandas()['score'].plot(label=\"random\")\n", + "picker.metrics.to_pandas()['score'].plot(label=\"vw\")\n", + "random_picker.metrics.to_pandas()['score'].plot(label=\"random\")\n", "pytorch_picker.metrics.to_pandas()['score'].plot(label=\"pytorch\")\n", "\n", "plt.legend()\n", "\n", "print(f\"The final average score for the default policy, calculated over a rolling window, is: {pytorch_picker.metrics.to_pandas()['score'].iloc[-1]}\")\n", - "# print(f\"The final average score for the default policy, calculated over a rolling window, is: {picker.metrics.to_pandas()['score'].iloc[-1]}\")\n", - "# print(f\"The final average score for the random policy, calculated over a rolling window, is: {random_picker.metrics.to_pandas()['score'].iloc[-1]}\")\n" + "print(f\"The final average score for the default policy, calculated over a rolling window, is: {picker.metrics.to_pandas()['score'].iloc[-1]}\")\n", + "print(f\"The final average score for the random policy, calculated over a rolling window, is: {random_picker.metrics.to_pandas()['score'].iloc[-1]}\")\n" ] } ], diff --git a/tests/unit_tests/test_byom.py b/tests/unit_tests/test_byom.py index 75c633d..675aa0e 100644 --- a/tests/unit_tests/test_byom.py +++ b/tests/unit_tests/test_byom.py @@ -32,7 +32,7 @@ def score_response( chosen_article = picked["article"] user = event.based_on["user"] time_of_day = event.based_on["time_of_day"] - score = self.get_score(user[0], time_of_day[0], chosen_article) + score = self.get_score(user, time_of_day, chosen_article) return score From 97d9f0c3ac321117b8224e9a3ee08940a9cc4d51 Mon Sep 17 00:00:00 2001 From: cheng Date: Mon, 20 Nov 2023 16:55:52 +0000 Subject: [PATCH 07/16] format --- .../byom/pytorch_feature_embedder.py | 20 ++++++++++++------- src/learn_to_pick/byom/pytorch_policy.py | 1 - 2 files changed, 13 insertions(+), 8 deletions(-) diff --git a/src/learn_to_pick/byom/pytorch_feature_embedder.py b/src/learn_to_pick/byom/pytorch_feature_embedder.py index 0ae9299..f4d1dd4 100644 --- a/src/learn_to_pick/byom/pytorch_feature_embedder.py +++ b/src/learn_to_pick/byom/pytorch_feature_embedder.py @@ -2,6 +2,7 @@ import torch from learn_to_pick import PickBestFeaturizer + class PyTorchFeatureEmbedder: def __init__(self, auto_embed=False, model=None, *args, **kwargs): if model is None: @@ -10,17 +11,17 @@ def __init__(self, auto_embed=False, model=None, *args, **kwargs): self.model = model self.featurizer = PickBestFeaturizer(auto_embed=auto_embed) - def encode(self, stuff): embeddings = self.model.encode(stuff, convert_to_tensor=True) normalized = torch.nn.functional.normalize(embeddings) return normalized - def convert_features_to_text(self, features): def process_feature(feature): if isinstance(feature, dict): - return " ".join([f"{k}_{process_feature(v)}" for k, v in feature.items()]) + return " ".join( + [f"{k}_{process_feature(v)}" for k, v in feature.items()] + ) elif isinstance(feature, list): return " ".join([process_feature(elem) for elem in feature]) else: @@ -28,16 +29,21 @@ def process_feature(feature): return process_feature(features) - def format(self, event): # TODO: handle dense - context_featurized, actions_featurized, selected = self.featurizer.featurize(event) + context_featurized, actions_featurized, selected = self.featurizer.featurize( + event + ) - context_sparse = self.encode([self.convert_features_to_text(context_featurized.sparse)]) + context_sparse = self.encode( + [self.convert_features_to_text(context_featurized.sparse)] + ) actions_sparse = [] for action_featurized in actions_featurized: - actions_sparse.append(self.convert_features_to_text(action_featurized.sparse)) + actions_sparse.append( + self.convert_features_to_text(action_featurized.sparse) + ) actions_sparse = self.encode(actions_sparse).unsqueeze(0) if selected.score is not None: diff --git a/src/learn_to_pick/byom/pytorch_policy.py b/src/learn_to_pick/byom/pytorch_policy.py index 93c2ba5..ddd09c3 100644 --- a/src/learn_to_pick/byom/pytorch_policy.py +++ b/src/learn_to_pick/byom/pytorch_policy.py @@ -48,7 +48,6 @@ def predict(self, event): # print(f"returning: {r}") return r - def learn(self, event): R, X, A = self.feature_embedder.format(event) # print(f"R: {R}") From 324ca819989fe8c17310625984d52258e2c332c6 Mon Sep 17 00:00:00 2001 From: cheng Date: Tue, 21 Nov 2023 16:51:09 +0000 Subject: [PATCH 08/16] separate vw and pytorch --- src/learn_to_pick/__init__.py | 17 +++--- src/learn_to_pick/base.py | 53 +--------------- src/learn_to_pick/pick_best.py | 8 +-- .../{byom => pytorch}/__init__.py | 0 src/learn_to_pick/{byom => pytorch}/igw.py | 0 .../{byom => pytorch}/logistic_regression.py | 0 .../pytorch_policy.py => pytorch/policy.py} | 4 +- .../pytorch_feature_embedder.py | 0 src/learn_to_pick/vw/__init__.py | 0 .../{vw_logger.py => vw/logger.py} | 0 .../{ => vw}/model_repository.py | 0 src/learn_to_pick/vw/policy.py | 61 +++++++++++++++++++ 12 files changed, 77 insertions(+), 66 deletions(-) rename src/learn_to_pick/{byom => pytorch}/__init__.py (100%) rename src/learn_to_pick/{byom => pytorch}/igw.py (100%) rename src/learn_to_pick/{byom => pytorch}/logistic_regression.py (100%) rename src/learn_to_pick/{byom/pytorch_policy.py => pytorch/policy.py} (95%) rename src/learn_to_pick/{byom => pytorch}/pytorch_feature_embedder.py (100%) create mode 100644 src/learn_to_pick/vw/__init__.py rename src/learn_to_pick/{vw_logger.py => vw/logger.py} (100%) rename src/learn_to_pick/{ => vw}/model_repository.py (100%) create mode 100644 src/learn_to_pick/vw/policy.py diff --git a/src/learn_to_pick/__init__.py b/src/learn_to_pick/__init__.py index c0c3f55..485cd47 100644 --- a/src/learn_to_pick/__init__.py +++ b/src/learn_to_pick/__init__.py @@ -5,12 +5,9 @@ BasedOn, Embed, Featurizer, - ModelRepository, Policy, SelectionScorer, ToSelectFrom, - VwPolicy, - VwLogger, embed, ) from learn_to_pick.pick_best import ( @@ -21,9 +18,13 @@ PickBestSelected, ) -from learn_to_pick.byom.pytorch_policy import PyTorchPolicy -from learn_to_pick.byom.pytorch_feature_embedder import PyTorchFeatureEmbedder +from learn_to_pick.vw.policy import VwPolicy +from learn_to_pick.vw.model_repository import ModelRepository +from learn_to_pick.vw.logger import VwLogger + +from learn_to_pick.pytorch.policy import PyTorchPolicy +from learn_to_pick.pytorch.pytorch_feature_embedder import PyTorchFeatureEmbedder def configure_logger() -> None: @@ -52,11 +53,11 @@ def configure_logger() -> None: "SelectionScorer", "AutoSelectionScorer", "Featurizer", - "ModelRepository", "Policy", "PyTorchPolicy", "PyTorchFeatureEmbedder", - "VwPolicy", - "VwLogger", "embed", + "ModelRepository", + "VwPolicy", + "VwLogger" ] diff --git a/src/learn_to_pick/base.py b/src/learn_to_pick/base.py index 73cd9f8..7f8115a 100644 --- a/src/learn_to_pick/base.py +++ b/src/learn_to_pick/base.py @@ -10,15 +10,12 @@ List, Optional, Tuple, - Type, TypeVar, Union, - Callable, ) from learn_to_pick.metrics import MetricsTrackerAverage, MetricsTrackerRollingWindow -from learn_to_pick.model_repository import ModelRepository -from learn_to_pick.vw_logger import VwLogger + from learn_to_pick.features import Featurized, DenseFeatures, SparseFeatures from enum import Enum @@ -89,10 +86,6 @@ def EmbedAndKeep(anything: Any) -> Any: # helper functions -def _parse_lines(parser: "vw.TextFormatParser", input_str: str) -> List["vw.Example"]: - return [parser.parse_line(line) for line in input_str.split("\n")] - - def filter_inputs(inputs: Dict[str, Any], role: Role) -> Dict[str, Any]: return { k: v.value @@ -144,50 +137,6 @@ def save(self) -> None: pass -class VwPolicy(Policy): - def __init__( - self, - model_repo: ModelRepository, - vw_cmd: List[str], - featurizer: Featurizer, - formatter: Callable, - vw_logger: VwLogger, - **kwargs: Any, - ): - super().__init__(**kwargs) - self.model_repo = model_repo - self.vw_cmd = vw_cmd - self.workspace = self.model_repo.load(vw_cmd) - self.featurizer = featurizer - self.formatter = formatter - self.vw_logger = vw_logger - - def format(self, event): - return self.formatter(*self.featurizer.featurize(event)) - - def predict(self, event: TEvent) -> Any: - import vowpal_wabbit_next as vw - - text_parser = vw.TextFormatParser(self.workspace) - return self.workspace.predict_one(_parse_lines(text_parser, self.format(event))) - - def learn(self, event: TEvent) -> None: - import vowpal_wabbit_next as vw - - vw_ex = self.format(event) - text_parser = vw.TextFormatParser(self.workspace) - multi_ex = _parse_lines(text_parser, vw_ex) - self.workspace.learn_one(multi_ex) - - def log(self, event: TEvent) -> None: - if self.vw_logger.logging_enabled(): - vw_ex = self.format(event) - self.vw_logger.log(vw_ex) - - def save(self) -> None: - self.model_repo.save(self.workspace) - - class Featurizer(Generic[TEvent], ABC): def __init__(self, *args: Any, **kwargs: Any): pass diff --git a/src/learn_to_pick/pick_best.py b/src/learn_to_pick/pick_best.py index f51aedc..9a04f1c 100644 --- a/src/learn_to_pick/pick_best.py +++ b/src/learn_to_pick/pick_best.py @@ -6,7 +6,7 @@ import os import numpy as np -from learn_to_pick import base +from learn_to_pick import base, VwPolicy, ModelRepository, VwLogger logger = logging.getLogger(__name__) @@ -333,14 +333,14 @@ def create_policy( vw_cmd = interactions + vw_cmd - return base.VwPolicy( - model_repo=base.ModelRepository( + return VwPolicy( + model_repo=ModelRepository( model_save_dir, with_history=True, reset=reset_model ), vw_cmd=vw_cmd, featurizer=featurizer, formatter=formatter, - vw_logger=base.VwLogger(rl_logs), + vw_logger=VwLogger(rl_logs), ) def _default_policy(self): diff --git a/src/learn_to_pick/byom/__init__.py b/src/learn_to_pick/pytorch/__init__.py similarity index 100% rename from src/learn_to_pick/byom/__init__.py rename to src/learn_to_pick/pytorch/__init__.py diff --git a/src/learn_to_pick/byom/igw.py b/src/learn_to_pick/pytorch/igw.py similarity index 100% rename from src/learn_to_pick/byom/igw.py rename to src/learn_to_pick/pytorch/igw.py diff --git a/src/learn_to_pick/byom/logistic_regression.py b/src/learn_to_pick/pytorch/logistic_regression.py similarity index 100% rename from src/learn_to_pick/byom/logistic_regression.py rename to src/learn_to_pick/pytorch/logistic_regression.py diff --git a/src/learn_to_pick/byom/pytorch_policy.py b/src/learn_to_pick/pytorch/policy.py similarity index 95% rename from src/learn_to_pick/byom/pytorch_policy.py rename to src/learn_to_pick/pytorch/policy.py index ddd09c3..ddfd7c1 100644 --- a/src/learn_to_pick/byom/pytorch_policy.py +++ b/src/learn_to_pick/pytorch/policy.py @@ -1,6 +1,6 @@ from learn_to_pick import base, PickBestEvent -from learn_to_pick.byom.logistic_regression import ResidualLogisticRegressor -from learn_to_pick.byom.igw import SamplingIGW +from learn_to_pick.pytorch.logistic_regression import ResidualLogisticRegressor +from learn_to_pick.pytorch.igw import SamplingIGW import torch import os diff --git a/src/learn_to_pick/byom/pytorch_feature_embedder.py b/src/learn_to_pick/pytorch/pytorch_feature_embedder.py similarity index 100% rename from src/learn_to_pick/byom/pytorch_feature_embedder.py rename to src/learn_to_pick/pytorch/pytorch_feature_embedder.py diff --git a/src/learn_to_pick/vw/__init__.py b/src/learn_to_pick/vw/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/src/learn_to_pick/vw_logger.py b/src/learn_to_pick/vw/logger.py similarity index 100% rename from src/learn_to_pick/vw_logger.py rename to src/learn_to_pick/vw/logger.py diff --git a/src/learn_to_pick/model_repository.py b/src/learn_to_pick/vw/model_repository.py similarity index 100% rename from src/learn_to_pick/model_repository.py rename to src/learn_to_pick/vw/model_repository.py diff --git a/src/learn_to_pick/vw/policy.py b/src/learn_to_pick/vw/policy.py new file mode 100644 index 0000000..e53cdde --- /dev/null +++ b/src/learn_to_pick/vw/policy.py @@ -0,0 +1,61 @@ +from learn_to_pick.base import Event, Featurizer, Policy +from learn_to_pick import ModelRepository, VwLogger +from typing import ( + Any, + List, + Callable, + TYPE_CHECKING, + TypeVar +) + +if TYPE_CHECKING: + import vowpal_wabbit_next as vw + +TEvent = TypeVar("TEvent", bound=Event) + +def _parse_lines(parser: "vw.TextFormatParser", input_str: str) -> List["vw.Example"]: + return [parser.parse_line(line) for line in input_str.split("\n")] + + +class VwPolicy(Policy): + def __init__( + self, + model_repo: ModelRepository, + vw_cmd: List[str], + featurizer: Featurizer, + formatter: Callable, + vw_logger: VwLogger, + **kwargs: Any, + ): + super().__init__(**kwargs) + self.model_repo = model_repo + self.vw_cmd = vw_cmd + self.workspace = self.model_repo.load(vw_cmd) + self.featurizer = featurizer + self.formatter = formatter + self.vw_logger = vw_logger + + def format(self, event): + return self.formatter(*self.featurizer.featurize(event)) + + def predict(self, event: TEvent) -> Any: + import vowpal_wabbit_next as vw + + text_parser = vw.TextFormatParser(self.workspace) + return self.workspace.predict_one(_parse_lines(text_parser, self.format(event))) + + def learn(self, event: TEvent) -> None: + import vowpal_wabbit_next as vw + + vw_ex = self.format(event) + text_parser = vw.TextFormatParser(self.workspace) + multi_ex = _parse_lines(text_parser, vw_ex) + self.workspace.learn_one(multi_ex) + + def log(self, event: TEvent) -> None: + if self.vw_logger.logging_enabled(): + vw_ex = self.format(event) + self.vw_logger.log(vw_ex) + + def save(self) -> None: + self.model_repo.save(self.workspace) From 1295d33700a855a0595cfbf021d0edf48b6441b7 Mon Sep 17 00:00:00 2001 From: cheng Date: Tue, 21 Nov 2023 17:03:20 +0000 Subject: [PATCH 09/16] format --- src/learn_to_pick/__init__.py | 2 +- src/learn_to_pick/vw/policy.py | 9 ++------- 2 files changed, 3 insertions(+), 8 deletions(-) diff --git a/src/learn_to_pick/__init__.py b/src/learn_to_pick/__init__.py index 485cd47..a102d0d 100644 --- a/src/learn_to_pick/__init__.py +++ b/src/learn_to_pick/__init__.py @@ -59,5 +59,5 @@ def configure_logger() -> None: "embed", "ModelRepository", "VwPolicy", - "VwLogger" + "VwLogger", ] diff --git a/src/learn_to_pick/vw/policy.py b/src/learn_to_pick/vw/policy.py index e53cdde..49cdcd3 100644 --- a/src/learn_to_pick/vw/policy.py +++ b/src/learn_to_pick/vw/policy.py @@ -1,18 +1,13 @@ from learn_to_pick.base import Event, Featurizer, Policy from learn_to_pick import ModelRepository, VwLogger -from typing import ( - Any, - List, - Callable, - TYPE_CHECKING, - TypeVar -) +from typing import Any, List, Callable, TYPE_CHECKING, TypeVar if TYPE_CHECKING: import vowpal_wabbit_next as vw TEvent = TypeVar("TEvent", bound=Event) + def _parse_lines(parser: "vw.TextFormatParser", input_str: str) -> List["vw.Example"]: return [parser.parse_line(line) for line in input_str.split("\n")] From cf4b28410d9926c7aec3dc6086249a8f2c2107eb Mon Sep 17 00:00:00 2001 From: cheng Date: Tue, 21 Nov 2023 19:06:14 +0000 Subject: [PATCH 10/16] fix tests --- src/learn_to_pick/__init__.py | 4 ++-- src/learn_to_pick/pick_best.py | 6 +++++- src/learn_to_pick/vw/policy.py | 3 ++- tests/unit_tests/{test_byom.py => test_pytorch_model.py} | 2 +- 4 files changed, 10 insertions(+), 5 deletions(-) rename tests/unit_tests/{test_byom.py => test_pytorch_model.py} (98%) diff --git a/src/learn_to_pick/__init__.py b/src/learn_to_pick/__init__.py index a102d0d..4cab81d 100644 --- a/src/learn_to_pick/__init__.py +++ b/src/learn_to_pick/__init__.py @@ -24,7 +24,7 @@ from learn_to_pick.vw.logger import VwLogger from learn_to_pick.pytorch.policy import PyTorchPolicy -from learn_to_pick.pytorch.pytorch_feature_embedder import PyTorchFeatureEmbedder +from learn_to_pick.pytorch.featurizer import PyTorchFeaturizer def configure_logger() -> None: @@ -55,7 +55,7 @@ def configure_logger() -> None: "Featurizer", "Policy", "PyTorchPolicy", - "PyTorchFeatureEmbedder", + "PyTorchFeaturizer", "embed", "ModelRepository", "VwPolicy", diff --git a/src/learn_to_pick/pick_best.py b/src/learn_to_pick/pick_best.py index 9a04f1c..e574157 100644 --- a/src/learn_to_pick/pick_best.py +++ b/src/learn_to_pick/pick_best.py @@ -6,7 +6,11 @@ import os import numpy as np -from learn_to_pick import base, VwPolicy, ModelRepository, VwLogger +from learn_to_pick import base +from learn_to_pick.vw.policy import VwPolicy +from learn_to_pick.vw.model_repository import ModelRepository +from learn_to_pick.vw.logger import VwLogger + logger = logging.getLogger(__name__) diff --git a/src/learn_to_pick/vw/policy.py b/src/learn_to_pick/vw/policy.py index 49cdcd3..5bd71c2 100644 --- a/src/learn_to_pick/vw/policy.py +++ b/src/learn_to_pick/vw/policy.py @@ -1,5 +1,6 @@ from learn_to_pick.base import Event, Featurizer, Policy -from learn_to_pick import ModelRepository, VwLogger +from learn_to_pick.vw.model_repository import ModelRepository +from learn_to_pick.vw.logger import VwLogger from typing import Any, List, Callable, TYPE_CHECKING, TypeVar if TYPE_CHECKING: diff --git a/tests/unit_tests/test_byom.py b/tests/unit_tests/test_pytorch_model.py similarity index 98% rename from tests/unit_tests/test_byom.py rename to tests/unit_tests/test_pytorch_model.py index 675aa0e..9ef8ba7 100644 --- a/tests/unit_tests/test_byom.py +++ b/tests/unit_tests/test_pytorch_model.py @@ -102,7 +102,7 @@ def test_save_load(remove_checkpoint): sim1 = Simulator() sim2 = Simulator() - fe = learn_to_pick.PyTorchFeatureEmbedder(auto_embed=True) + fe = learn_to_pick.PyTorchFeaturizer(auto_embed=True) first_model_path = f"{CHECKPOINT_DIR}/first.checkpoint" torch.manual_seed(0) From d6e9c870422998235bb45ea1ee6b74f8846d17e6 Mon Sep 17 00:00:00 2001 From: cheng Date: Tue, 28 Nov 2023 15:07:12 +0000 Subject: [PATCH 11/16] update feature embedder --- src/learn_to_pick/__init__.py | 4 ++-- ...eature_embedder.py => feature_embedder.py} | 22 +++++++------------ tests/unit_tests/test_pytorch_model.py | 2 +- 3 files changed, 11 insertions(+), 17 deletions(-) rename src/learn_to_pick/pytorch/{pytorch_feature_embedder.py => feature_embedder.py} (67%) diff --git a/src/learn_to_pick/__init__.py b/src/learn_to_pick/__init__.py index 4cab81d..f15e95b 100644 --- a/src/learn_to_pick/__init__.py +++ b/src/learn_to_pick/__init__.py @@ -24,7 +24,7 @@ from learn_to_pick.vw.logger import VwLogger from learn_to_pick.pytorch.policy import PyTorchPolicy -from learn_to_pick.pytorch.featurizer import PyTorchFeaturizer +from learn_to_pick.pytorch.feature_embedder import PyTorchFeatureEmbedder def configure_logger() -> None: @@ -55,7 +55,7 @@ def configure_logger() -> None: "Featurizer", "Policy", "PyTorchPolicy", - "PyTorchFeaturizer", + "PyTorchFeatureEmbedder", "embed", "ModelRepository", "VwPolicy", diff --git a/src/learn_to_pick/pytorch/pytorch_feature_embedder.py b/src/learn_to_pick/pytorch/feature_embedder.py similarity index 67% rename from src/learn_to_pick/pytorch/pytorch_feature_embedder.py rename to src/learn_to_pick/pytorch/feature_embedder.py index f4d1dd4..c43de3e 100644 --- a/src/learn_to_pick/pytorch/pytorch_feature_embedder.py +++ b/src/learn_to_pick/pytorch/feature_embedder.py @@ -4,30 +4,24 @@ class PyTorchFeatureEmbedder: - def __init__(self, auto_embed=False, model=None, *args, **kwargs): + def __init__(self, model=None, *args, **kwargs): if model is None: model = SentenceTransformer("all-MiniLM-L6-v2") self.model = model - self.featurizer = PickBestFeaturizer(auto_embed=auto_embed) + self.featurizer = PickBestFeaturizer(auto_embed=False) def encode(self, stuff): embeddings = self.model.encode(stuff, convert_to_tensor=True) normalized = torch.nn.functional.normalize(embeddings) return normalized - def convert_features_to_text(self, features): - def process_feature(feature): - if isinstance(feature, dict): - return " ".join( - [f"{k}_{process_feature(v)}" for k, v in feature.items()] - ) - elif isinstance(feature, list): - return " ".join([process_feature(elem) for elem in feature]) - else: - return str(feature) - - return process_feature(features) + def convert_features_to_text(self, sparse_features): + results = [] + for ns, obj in sparse_features.items(): + value = obj.get("default_ft", "") + results.append(f"{ns}={value}") + return " ".join(results) def format(self, event): # TODO: handle dense diff --git a/tests/unit_tests/test_pytorch_model.py b/tests/unit_tests/test_pytorch_model.py index 9ef8ba7..0ebfa17 100644 --- a/tests/unit_tests/test_pytorch_model.py +++ b/tests/unit_tests/test_pytorch_model.py @@ -102,7 +102,7 @@ def test_save_load(remove_checkpoint): sim1 = Simulator() sim2 = Simulator() - fe = learn_to_pick.PyTorchFeaturizer(auto_embed=True) + fe = learn_to_pick.PyTorchFeatureEmbedder() first_model_path = f"{CHECKPOINT_DIR}/first.checkpoint" torch.manual_seed(0) From 20f8a21b25e57dab2085f794f9301167cb72be0c Mon Sep 17 00:00:00 2001 From: cheng Date: Tue, 28 Nov 2023 21:25:26 +0000 Subject: [PATCH 12/16] add type hint to pytorch --- src/learn_to_pick/pytorch/feature_embedder.py | 31 +++++++++++++++---- src/learn_to_pick/pytorch/igw.py | 6 ++-- .../pytorch/logistic_regression.py | 23 +++++++------- src/learn_to_pick/pytorch/policy.py | 24 +++++++------- 4 files changed, 52 insertions(+), 32 deletions(-) diff --git a/src/learn_to_pick/pytorch/feature_embedder.py b/src/learn_to_pick/pytorch/feature_embedder.py index c43de3e..ed39fcd 100644 --- a/src/learn_to_pick/pytorch/feature_embedder.py +++ b/src/learn_to_pick/pytorch/feature_embedder.py @@ -1,34 +1,53 @@ from sentence_transformers import SentenceTransformer import torch +from torch import Tensor + from learn_to_pick import PickBestFeaturizer +from learn_to_pick.base import Event +from learn_to_pick.features import SparseFeatures +from typing import Any, Tuple, TypeVar, Union + +TEvent = TypeVar("TEvent", bound=Event) class PyTorchFeatureEmbedder: - def __init__(self, model=None, *args, **kwargs): + def __init__(self, model: Any = None): if model is None: model = SentenceTransformer("all-MiniLM-L6-v2") self.model = model self.featurizer = PickBestFeaturizer(auto_embed=False) - def encode(self, stuff): - embeddings = self.model.encode(stuff, convert_to_tensor=True) + def encode(self, to_encode: str) -> Tensor: + embeddings = self.model.encode(to_encode, convert_to_tensor=True) normalized = torch.nn.functional.normalize(embeddings) return normalized - def convert_features_to_text(self, sparse_features): + def convert_features_to_text(self, sparse_features: SparseFeatures) -> str: results = [] for ns, obj in sparse_features.items(): value = obj.get("default_ft", "") results.append(f"{ns}={value}") return " ".join(results) - def format(self, event): - # TODO: handle dense + def format( + self, event: TEvent + ) -> Union[Tuple[Tensor, Tensor, Tensor], Tuple[Tensor, Tensor]]: context_featurized, actions_featurized, selected = self.featurizer.featurize( event ) + if len(context_featurized.dense) > 0: + raise NotImplementedError( + "pytorch policy doesn't support context with dense feature" + ) + + for action_featurized in actions_featurized: + if len(action_featurized.dense) > 0: + raise NotImplementedError( + "pytorch policy doesn't support action with dense feature" + ) + context_sparse = self.encode( [self.convert_features_to_text(context_featurized.sparse)] ) diff --git a/src/learn_to_pick/pytorch/igw.py b/src/learn_to_pick/pytorch/igw.py index e7d4011..f3d895c 100644 --- a/src/learn_to_pick/pytorch/igw.py +++ b/src/learn_to_pick/pytorch/igw.py @@ -1,7 +1,9 @@ import torch +from torch import Tensor +from typing import Tuple -def IGW(fhat, gamma): +def IGW(fhat: torch.Tensor, gamma: float) -> Tuple[Tensor, Tensor]: from math import sqrt fhatahat, ahat = fhat.max(dim=1) @@ -13,7 +15,7 @@ def IGW(fhat, gamma): return torch.multinomial(p, num_samples=1).squeeze(1), ahat -def SamplingIGW(A, P, gamma): +def SamplingIGW(A: Tensor, P: Tensor, gamma: float) -> list: exploreind, _ = IGW(P, gamma) explore = [ind for _, ind in zip(A, exploreind)] return explore diff --git a/src/learn_to_pick/pytorch/logistic_regression.py b/src/learn_to_pick/pytorch/logistic_regression.py index d345567..9e1e1f2 100644 --- a/src/learn_to_pick/pytorch/logistic_regression.py +++ b/src/learn_to_pick/pytorch/logistic_regression.py @@ -1,11 +1,12 @@ import parameterfree import torch +from torch import Tensor import torch.nn.functional as F class MLP(torch.nn.Module): @staticmethod - def new_gelu(x): + def new_gelu(x: Tensor) -> Tensor: import math return ( @@ -19,13 +20,13 @@ def new_gelu(x): ) ) - def __init__(self, dim): + def __init__(self, dim: int): super().__init__() self.c_fc = torch.nn.Linear(dim, 4 * dim) self.c_proj = torch.nn.Linear(4 * dim, dim) self.dropout = torch.nn.Dropout(0.5) - def forward(self, x): + def forward(self, x: Tensor) -> Tensor: x = self.c_fc(x) x = self.new_gelu(x) x = self.c_proj(x) @@ -34,16 +35,16 @@ def forward(self, x): class Block(torch.nn.Module): - def __init__(self, dim): + def __init__(self, dim: int): super().__init__() self.layer = MLP(dim) - def forward(self, x): + def forward(self, x: Tensor): return x + self.layer(x) class ResidualLogisticRegressor(torch.nn.Module): - def __init__(self, in_features, depth, device): + def __init__(self, in_features: int, depth: int, device: str): super().__init__() self._in_features = in_features self._depth = depth @@ -52,17 +53,17 @@ def __init__(self, in_features, depth, device): self.optim = parameterfree.COCOB(self.parameters()) self._device = device - def clone(self): + def clone(self) -> "ResidualLogisticRegressor": other = ResidualLogisticRegressor(self._in_features, self._depth, self._device) other.load_state_dict(self.state_dict()) other.optim = parameterfree.COCOB(other.parameters()) other.optim.load_state_dict(self.optim.state_dict()) return other - def forward(self, X, A): + def forward(self, X: Tensor, A: Tensor) -> Tensor: return self.logits(X, A) - def logits(self, X, A): + def logits(self, X: Tensor, A: Tensor) -> Tensor: # X = batch x features # A = batch x actionbatch x actionfeatures @@ -76,11 +77,11 @@ def logits(self, X, A): ) # batch x actionbatch x (features + actionfeatures) return self.linear(self.blocks(XA)).squeeze(2) # batch x actionbatch - def predict(self, X, A): + def predict(self, X: Tensor, A: Tensor) -> Tensor: self.eval() return torch.special.expit(self.logits(X, A)) - def bandit_learn(self, X, A, R): + def bandit_learn(self, X: Tensor, A: Tensor, R: Tensor) -> float: self.train() self.optim.zero_grad() output = self(X, A) diff --git a/src/learn_to_pick/pytorch/policy.py b/src/learn_to_pick/pytorch/policy.py index ddfd7c1..606df93 100644 --- a/src/learn_to_pick/pytorch/policy.py +++ b/src/learn_to_pick/pytorch/policy.py @@ -1,18 +1,22 @@ from learn_to_pick import base, PickBestEvent from learn_to_pick.pytorch.logistic_regression import ResidualLogisticRegressor from learn_to_pick.pytorch.igw import SamplingIGW +from learn_to_pick.pytorch.feature_embedder import PyTorchFeatureEmbedder import torch import os +from typing import Any, Optional, PathLike, TypeVar, Union + +TEvent = TypeVar("TEvent", bound=base.Event) class PyTorchPolicy(base.Policy[PickBestEvent]): def __init__( self, - feature_embedder, + feature_embedder=PyTorchFeatureEmbedder(), depth: int = 2, device: str = "cuda" if torch.cuda.is_available() else "cpu", - *args, - **kwargs, + *args: Any, + **kwargs: Any, ): print(f"Device: {device}") super().__init__(*args, **kwargs) @@ -24,40 +28,34 @@ def __init__( self.index = 0 self.loss = None - def predict(self, event): + def predict(self, event: TEvent) -> list: X, A = self.feature_embedder.format(event) - # print(f"X shape: {X.shape}") - # print(f"A shape: {A.shape}") # TODO IGW sampling then create the distro so that the one # that was sampled here is the one that will def be sampled by # the base sampler, and in the future replace the sampler so that it # is something that can be plugged in p = self.workspace.predict(X, A) - # print(f"p: {p}") import math explore = SamplingIGW(A, p, math.sqrt(self.index)) self.index += 1 - # print(f"explore: {explore}") r = [] for index in range(p.shape[1]): if index == explore[0]: r.append((index, 1)) else: r.append((index, 0)) - # print(f"returning: {r}") return r - def learn(self, event): + def learn(self, event: TEvent) -> None: R, X, A = self.feature_embedder.format(event) - # print(f"R: {R}") R, X, A = R.to(self.device), X.to(self.device), A.to(self.device) self.loss = self.workspace.bandit_learn(X, A, R) def log(self, event): pass - def save(self, path) -> None: + def save(self, path: Optional[Union[str, PathLike]]) -> None: state = { "workspace_state_dict": self.workspace.state_dict(), "optimizer_state_dict": self.workspace.optim.state_dict(), @@ -71,7 +69,7 @@ def save(self, path) -> None: os.makedirs(dir, exist_ok=True) torch.save(state, path) - def load(self, path) -> None: + def load(self, path: Optional[Union[str, PathLike]]) -> None: import parameterfree if os.path.exists(path): From af207ffca7ec04d215bbb5f86a0fc413fde10290 Mon Sep 17 00:00:00 2001 From: cheng Date: Tue, 28 Nov 2023 21:39:30 +0000 Subject: [PATCH 13/16] update notebook --- notebooks/news_recommendation_byom.ipynb | 135 +++++++++++++----- src/learn_to_pick/pytorch/feature_embedder.py | 4 +- src/learn_to_pick/pytorch/policy.py | 6 +- 3 files changed, 106 insertions(+), 39 deletions(-) diff --git a/notebooks/news_recommendation_byom.ipynb b/notebooks/news_recommendation_byom.ipynb index b74f4ca..6f8c45e 100644 --- a/notebooks/news_recommendation_byom.ipynb +++ b/notebooks/news_recommendation_byom.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 37, + "execution_count": 10, "metadata": {}, "outputs": [ { @@ -21,17 +21,104 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 11, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "huggingface/tokenizers: The current process just got forked, after parallelism has already been used. Disabling parallelism to avoid deadlocks...\n", + "To disable this warning, you can either:\n", + "\t- Avoid using `tokenizers` before the fork if possible\n", + "\t- Explicitly set the environment variable TOKENIZERS_PARALLELISM=(true | false)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing /home/chetan/dev/learn_to_pick\n", + " Preparing metadata (setup.py) ... \u001b[?25ldone\n", + "\u001b[?25hRequirement already satisfied: numpy>=1.24.4 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from learn-to-pick==0.0.3) (1.26.1)\n", + "Requirement already satisfied: pandas>=2.0.3 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from learn-to-pick==0.0.3) (2.1.1)\n", + "Requirement already satisfied: vowpal-wabbit-next==0.7.0 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from learn-to-pick==0.0.3) (0.7.0)\n", + "Requirement already satisfied: sentence-transformers>=2.2.2 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from learn-to-pick==0.0.3) (2.2.2)\n", + "Requirement already satisfied: torch in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from learn-to-pick==0.0.3) (2.0.1)\n", + "Requirement already satisfied: pyskiplist in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from learn-to-pick==0.0.3) (1.0.0)\n", + "Requirement already satisfied: parameterfree in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from learn-to-pick==0.0.3) (0.0.1)\n", + "Requirement already satisfied: python-dateutil>=2.8.2 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from pandas>=2.0.3->learn-to-pick==0.0.3) (2.8.2)\n", + "Requirement already satisfied: pytz>=2020.1 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from pandas>=2.0.3->learn-to-pick==0.0.3) (2023.3.post1)\n", + "Requirement already satisfied: tzdata>=2022.1 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from pandas>=2.0.3->learn-to-pick==0.0.3) (2023.3)\n", + "Requirement already satisfied: transformers<5.0.0,>=4.6.0 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from sentence-transformers>=2.2.2->learn-to-pick==0.0.3) (4.34.1)\n", + "Requirement already satisfied: tqdm in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from sentence-transformers>=2.2.2->learn-to-pick==0.0.3) (4.66.1)\n", + "Requirement already satisfied: torchvision in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from sentence-transformers>=2.2.2->learn-to-pick==0.0.3) (0.15.2)\n", + "Requirement already satisfied: scikit-learn in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from sentence-transformers>=2.2.2->learn-to-pick==0.0.3) (1.3.2)\n", + "Requirement already satisfied: scipy in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from sentence-transformers>=2.2.2->learn-to-pick==0.0.3) (1.11.3)\n", + "Requirement already satisfied: nltk in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from sentence-transformers>=2.2.2->learn-to-pick==0.0.3) (3.8.1)\n", + "Requirement already satisfied: sentencepiece in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from sentence-transformers>=2.2.2->learn-to-pick==0.0.3) (0.1.99)\n", + "Requirement already satisfied: huggingface-hub>=0.4.0 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from sentence-transformers>=2.2.2->learn-to-pick==0.0.3) (0.17.3)\n", + "Requirement already satisfied: filelock in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from torch->learn-to-pick==0.0.3) (3.12.4)\n", + "Requirement already satisfied: typing-extensions in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from torch->learn-to-pick==0.0.3) (4.8.0)\n", + "Requirement already satisfied: sympy in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from torch->learn-to-pick==0.0.3) (1.12)\n", + "Requirement already satisfied: networkx in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from torch->learn-to-pick==0.0.3) (3.2)\n", + "Requirement already satisfied: jinja2 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from torch->learn-to-pick==0.0.3) (3.1.2)\n", + "Requirement already satisfied: nvidia-cuda-nvrtc-cu11==11.7.99 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from torch->learn-to-pick==0.0.3) (11.7.99)\n", + "Requirement already satisfied: nvidia-cuda-runtime-cu11==11.7.99 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from torch->learn-to-pick==0.0.3) (11.7.99)\n", + "Requirement already satisfied: nvidia-cuda-cupti-cu11==11.7.101 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from torch->learn-to-pick==0.0.3) (11.7.101)\n", + "Requirement already satisfied: nvidia-cudnn-cu11==8.5.0.96 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from torch->learn-to-pick==0.0.3) (8.5.0.96)\n", + "Requirement already satisfied: nvidia-cublas-cu11==11.10.3.66 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from torch->learn-to-pick==0.0.3) (11.10.3.66)\n", + "Requirement already satisfied: nvidia-cufft-cu11==10.9.0.58 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from torch->learn-to-pick==0.0.3) (10.9.0.58)\n", + "Requirement already satisfied: nvidia-curand-cu11==10.2.10.91 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from torch->learn-to-pick==0.0.3) (10.2.10.91)\n", + "Requirement already satisfied: nvidia-cusolver-cu11==11.4.0.1 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from torch->learn-to-pick==0.0.3) (11.4.0.1)\n", + "Requirement already satisfied: nvidia-cusparse-cu11==11.7.4.91 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from torch->learn-to-pick==0.0.3) (11.7.4.91)\n", + "Requirement already satisfied: nvidia-nccl-cu11==2.14.3 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from torch->learn-to-pick==0.0.3) (2.14.3)\n", + "Requirement already satisfied: nvidia-nvtx-cu11==11.7.91 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from torch->learn-to-pick==0.0.3) (11.7.91)\n", + "Requirement already satisfied: triton==2.0.0 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from torch->learn-to-pick==0.0.3) (2.0.0)\n", + "Requirement already satisfied: setuptools in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from nvidia-cublas-cu11==11.10.3.66->torch->learn-to-pick==0.0.3) (68.0.0)\n", + "Requirement already satisfied: wheel in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from nvidia-cublas-cu11==11.10.3.66->torch->learn-to-pick==0.0.3) (0.41.2)\n", + "Requirement already satisfied: cmake in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from triton==2.0.0->torch->learn-to-pick==0.0.3) (3.27.7)\n", + "Requirement already satisfied: lit in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from triton==2.0.0->torch->learn-to-pick==0.0.3) (17.0.4)\n", + "Requirement already satisfied: fsspec in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from huggingface-hub>=0.4.0->sentence-transformers>=2.2.2->learn-to-pick==0.0.3) (2023.10.0)\n", + "Requirement already satisfied: requests in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from huggingface-hub>=0.4.0->sentence-transformers>=2.2.2->learn-to-pick==0.0.3) (2.31.0)\n", + "Requirement already satisfied: pyyaml>=5.1 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from huggingface-hub>=0.4.0->sentence-transformers>=2.2.2->learn-to-pick==0.0.3) (6.0.1)\n", + "Requirement already satisfied: packaging>=20.9 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from huggingface-hub>=0.4.0->sentence-transformers>=2.2.2->learn-to-pick==0.0.3) (23.2)\n", + "Requirement already satisfied: six>=1.5 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from python-dateutil>=2.8.2->pandas>=2.0.3->learn-to-pick==0.0.3) (1.16.0)\n", + "Requirement already satisfied: regex!=2019.12.17 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from transformers<5.0.0,>=4.6.0->sentence-transformers>=2.2.2->learn-to-pick==0.0.3) (2023.10.3)\n", + "Requirement already satisfied: tokenizers<0.15,>=0.14 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from transformers<5.0.0,>=4.6.0->sentence-transformers>=2.2.2->learn-to-pick==0.0.3) (0.14.1)\n", + "Requirement already satisfied: safetensors>=0.3.1 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from transformers<5.0.0,>=4.6.0->sentence-transformers>=2.2.2->learn-to-pick==0.0.3) (0.4.0)\n", + "Requirement already satisfied: MarkupSafe>=2.0 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from jinja2->torch->learn-to-pick==0.0.3) (2.1.3)\n", + "Requirement already satisfied: click in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from nltk->sentence-transformers>=2.2.2->learn-to-pick==0.0.3) (8.1.7)\n", + "Requirement already satisfied: joblib in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from nltk->sentence-transformers>=2.2.2->learn-to-pick==0.0.3) (1.3.2)\n", + "Requirement already satisfied: threadpoolctl>=2.0.0 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from scikit-learn->sentence-transformers>=2.2.2->learn-to-pick==0.0.3) (3.2.0)\n", + "Requirement already satisfied: mpmath>=0.19 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from sympy->torch->learn-to-pick==0.0.3) (1.3.0)\n", + "Requirement already satisfied: pillow!=8.3.*,>=5.3.0 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from torchvision->sentence-transformers>=2.2.2->learn-to-pick==0.0.3) (10.1.0)\n", + "Requirement already satisfied: charset-normalizer<4,>=2 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from requests->huggingface-hub>=0.4.0->sentence-transformers>=2.2.2->learn-to-pick==0.0.3) (3.3.1)\n", + "Requirement already satisfied: idna<4,>=2.5 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from requests->huggingface-hub>=0.4.0->sentence-transformers>=2.2.2->learn-to-pick==0.0.3) (3.4)\n", + "Requirement already satisfied: urllib3<3,>=1.21.1 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from requests->huggingface-hub>=0.4.0->sentence-transformers>=2.2.2->learn-to-pick==0.0.3) (2.0.7)\n", + "Requirement already satisfied: certifi>=2017.4.17 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from requests->huggingface-hub>=0.4.0->sentence-transformers>=2.2.2->learn-to-pick==0.0.3) (2023.7.22)\n", + "Building wheels for collected packages: learn-to-pick\n", + " Building wheel for learn-to-pick (setup.py) ... \u001b[?25ldone\n", + "\u001b[?25h Created wheel for learn-to-pick: filename=learn_to_pick-0.0.3-py3-none-any.whl size=31195 sha256=bee6266df7b0bde64de2e58bff8c435340c315aa8fa9cfa3c84751c22a26fab1\n", + " Stored in directory: /tmp/pip-ephem-wheel-cache-zigo2ps9/wheels/18/bf/25/d8dda8a9a6b5284eaed510a4708ef9b22b9894a5e94b329ea2\n", + "Successfully built learn-to-pick\n", + "Installing collected packages: learn-to-pick\n", + " Attempting uninstall: learn-to-pick\n", + " Found existing installation: learn-to-pick 0.0.3\n", + " Uninstalling learn-to-pick-0.0.3:\n", + " Successfully uninstalled learn-to-pick-0.0.3\n", + "Successfully installed learn-to-pick-0.0.3\n" + ] + } + ], "source": [ - "# ! pip install ../\n", + "! pip install ../\n", "# ! pip install matplotlib" ] }, { "cell_type": "code", - "execution_count": 39, + "execution_count": 12, "metadata": {}, "outputs": [ { @@ -62,7 +149,7 @@ }, { "cell_type": "code", - "execution_count": 40, + "execution_count": 13, "metadata": {}, "outputs": [], "source": [ @@ -82,7 +169,7 @@ }, { "cell_type": "code", - "execution_count": 41, + "execution_count": 14, "metadata": {}, "outputs": [], "source": [ @@ -126,17 +213,7 @@ }, { "cell_type": "code", - "execution_count": 42, - "metadata": {}, - "outputs": [], - "source": [ - "from learn_to_pick import PyTorchFeatureEmbedder\n", - "fe = PyTorchFeatureEmbedder() #auto_embed=True" - ] - }, - { - "cell_type": "code", - "execution_count": 43, + "execution_count": 15, "metadata": {}, "outputs": [ { @@ -150,17 +227,15 @@ "source": [ "from learn_to_pick import PyTorchPolicy\n", "\n", - "picker = learn_to_pick.PickBest.create(\n", - " metrics_step=100, metrics_window_size=100, selection_scorer=CustomSelectionScorer())\n", "pytorch_picker = learn_to_pick.PickBest.create(\n", - " metrics_step=100, metrics_window_size=100, policy=PyTorchPolicy(feature_embedder=fe), selection_scorer=CustomSelectionScorer())\n", + " metrics_step=100, metrics_window_size=100, policy=PyTorchPolicy(), selection_scorer=CustomSelectionScorer())\n", "random_picker = learn_to_pick.PickBest.create(\n", " metrics_step=100, metrics_window_size=100, policy=learn_to_pick.PickBestRandomPolicy(), selection_scorer=CustomSelectionScorer())" ] }, { "cell_type": "code", - "execution_count": 44, + "execution_count": 16, "metadata": {}, "outputs": [], "source": [ @@ -169,11 +244,6 @@ "for i in range(2500):\n", " user = choose_user(users)\n", " time_of_day = choose_time_of_day(times_of_day)\n", - " picker.run(\n", - " article = learn_to_pick.ToSelectFrom(articles),\n", - " user = learn_to_pick.BasedOn(user),\n", - " time_of_day = learn_to_pick.BasedOn(time_of_day),\n", - " )\n", "\n", " random_picker.run(\n", " article = learn_to_pick.ToSelectFrom(articles),\n", @@ -197,21 +267,20 @@ }, { "cell_type": "code", - "execution_count": 45, + "execution_count": 17, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "The final average score for the default policy, calculated over a rolling window, is: 0.97\n", - "The final average score for the default policy, calculated over a rolling window, is: 0.81\n", - "The final average score for the random policy, calculated over a rolling window, is: 0.55\n" + "The final average score for the default policy, calculated over a rolling window, is: 0.93\n", + "The final average score for the random policy, calculated over a rolling window, is: 0.53\n" ] }, { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiMAAAGdCAYAAADAAnMpAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAABwzUlEQVR4nO3dd3xT5ffA8U/S3dJBKV1QKHvvUYYsqYIDRUUQFRARBcGFEweoPxW3fBUVRRkOFEHBgYKIDIHK3puW3U2heyb398dt0hZL27RJblLO+/Xqq2l6c+9pKM3J85znPDpFURSEEEIIITSi1zoAIYQQQlzdJBkRQgghhKYkGRFCCCGEpiQZEUIIIYSmJBkRQgghhKYkGRFCCCGEpiQZEUIIIYSmJBkRQgghhKZctQ6gKoxGI/Hx8fj6+qLT6bQORwghhBBVoCgKmZmZhIeHo9dfefzDKZKR+Ph4IiIitA5DCCGEENVw9uxZGjZseMXvO0Uy4uvrC6g/jJ+fn8bRCCGEEKIqMjIyiIiIML+OX4lTJCOmqRk/Pz9JRoQQQggnU1mJhRSwCiGEEEJTkowIIYQQQlOSjAghhBBCU05RM1IVBoOBwsJCrcMQpbi4uODq6irLsYUQQlSoViQjWVlZnDt3DkVRtA5FXMbb25uwsDDc3d21DkUIIYSDcvpkxGAwcO7cOby9valfv768C3cQiqJQUFBASkoKJ0+epEWLFhU2vBFCCHH1cvpkpLCwEEVRqF+/Pl5eXlqHI0rx8vLCzc2N06dPU1BQgKenp9YhCSGEcEC15q2qjIg4JhkNEUIIURl5pRBCCCGEpixORjZu3MiwYcMIDw9Hp9OxYsWKSh+zfv16unbtioeHB82bN2fhwoXVCFUIIYQQtZHFyUh2djadOnXi448/rtLxJ0+e5KabbmLQoEHs2bOHxx9/nAceeIDVq1dbHKyonvvuu4/hw4drHYYQQghRLosLWG+44QZuuOGGKh8/d+5cmjRpwnvvvQdAmzZt2LRpEx988AFDhgyx9PJCCCGEqGVsXjMSExNDdHR0mfuGDBlCTEzMFR+Tn59PRkZGmY/arqCgQOsQhBDO6OIp2PwhxP6tdSRCVJvNk5HExERCQkLK3BcSEkJGRga5ubnlPmbWrFn4+/ubPyIiIqp8PUVRyCko0uTDkqZrAwcOZOrUqTz++OMEBQUxZMgQ3n//fTp06ICPjw8RERE8/PDDZGVlmR+zcOFCAgICWL16NW3atKFOnToMHTqUhIQE8zEGg4Fp06YREBBAvXr1eOaZZ/4TV35+Po8++ijBwcF4enpyzTXXsH37dvP3169fj06nY/Xq1XTp0gUvLy+uvfZakpOT+eOPP2jTpg1+fn7cfffd5OTkVPlnFkJYSX4m7P4GFtwE/+sEa16CxXfBpbNaRyZEtThkn5Hp06czbdo089cZGRlVTkhyCw20naFNPcqhV4fg7V71p3TRokVMnjyZzZs3A/DHH3/w4Ycf0qRJE+Li4nj44Yd55pln+OSTT8yPycnJ4d133+Xrr79Gr9dz77338tRTT/Htt98C8N5777Fw4ULmz59PmzZteO+991i+fDnXXnut+RzPPPMMP/74I4sWLaJx48a8/fbbDBkyhBMnThAYGGg+7uWXX2bOnDl4e3szcuRIRo4ciYeHB4sXLyYrK4vbbruNjz76iGeffbamT50QojJGI5z6B/YshsO/QKHpjYAOvAIg9yKsfxOGV62eTwhHYvNkJDQ0lKSkpDL3JSUl4efnd8UmZR4eHnh4eNg6NM21aNGCt99+2/x1q1atzLcjIyN57bXXmDRpUplkpLCwkLlz59KsWTMApk6dyquvvmr+/uzZs5k+fTq33347oNbslC4Wzs7O5tNPP2XhwoXm2p958+axZs0avvzyS55++mnzsa+99hp9+/YFYMKECUyfPp3Y2FiaNm0KwIgRI1i3bp0kI0LY0oVYNQHZtwTSS4181GsOnUZDp7sgMxG+GAx7F0OfqRDcRrt4hagGmycjvXv35vfffy9z35o1a+jdu7dNrufl5sKhV7UpjPVyc7Ho+G7dupX5+q+//mLWrFkcOXKEjIwMioqKyMvLIycnB29vb0Dd68WUiACEhYWRnJwMQHp6OgkJCURFRZm/7+rqSvfu3c1TNbGxsRQWFpqTDAA3Nzd69uzJ4cOHy8TTsWNH8+2QkBC8vb3NiYjpvm3btln0MwshqiAvHQ4uV5OQs1tL7vfwh/a3Q+d7oGF3MDV79G8IbYbB4V9h7asw+jtt4haimixORrKysjhx4oT565MnT7Jnzx4CAwNp1KgR06dP5/z583z11VcATJo0iTlz5vDMM89w//338/fff/PDDz+wcuVK6/0Upeh0OoumSrTk4+Njvn3q1CluvvlmJk+ezOuvv05gYCCbNm1iwoQJFBQUmJMRNze3MufQ6XQ22yCw9LV0Ol251zYajTa5thBXHaMB4tapCciRlVCUp96v00OzwdB5NLS6CdyusK3CtTPUxx39Hc78C4162S92IWrI4gLWHTt20KVLF7p06QLAtGnT6NKlCzNmzAAgISGBM2fOmI9v0qQJK1euZM2aNXTq1In33nuPL774Qpb1Xmbnzp0YjUbee+89evXqRcuWLYmPj7foHP7+/oSFhbF1a8k7qaKiInbu3Gn+ulmzZri7u5vrVECd+tm+fTtt27at+Q8ihLBMylFYMxM+aAff3AEHflQTkfqt4bpX4YlDcO8yaH/HlRMRgPotocsY9faamSC7mAsnYvEQwsCBAyt8J15ed9WBAweye/duSy91VWnevDmFhYV89NFHDBs2jM2bNzN37lyLz/PYY4/x5ptv0qJFC1q3bs3777/PpUuXzN/38fFh8uTJPP300+bRrLfffpucnBwmTJhgxZ9ICFGh/ExYci/ErS+5z6sudLhTrQUJ71IyDVNVA59Ta0vO/gvHVkGrqveEEkJLzjGfcRXo1KkT77//Pm+99RbTp0+nf//+zJo1i7Fjx1p0nieffJKEhATGjRuHXq/n/vvv57bbbiM9Pd18zJtvvonRaGTMmDFkZmbSvXt3Vq9eTd26da39YwkhrmT9m2oionOBFtdD57uh5RBwrUHxvl849JoMmz6Av15Rz6u3rJZNCC3oFFsVHFhRRkYG/v7+pKen4+fnV+Z7eXl5nDx5kiZNmsgW9Q5I/n2EKEfyEZjbF4xFcPdSaHm99c6de0ntPZJ3CW79BLrcY71zC2Ghil6/S5Nde4UQwp4UBX5/Sk1EWt1k3UQE1J4j/Yr7NK17AwrzrHt+IWxAkhEhhLCng8vV5mWunjD0Ddtco+eD4NcAMs7B9nm2uYYQViTJiBBC2Et+Fqx+Qb19zRNQN9I213HzgoHT1dv/vKdO3QjhwKSAVQhx9SjMBRcP0Gv0PmzjO5AZDwGNoe9jtr1Wp9EQMwdSjsDm/0H0TNtezxYK8yArqfLjqsI3tGbFwcKmJBkRQlwd0uLg077QqDfc/QO42PnPX+pxiCneN+aGt9TRC1tycYXBM+D7u+HfT4unbsJse01rKcqHbfNg49tqN1pr8K4Hwz9VVywJhyPTNEKIq8PB5ermcrFr4e//s++1FQX+eAaMhepy25ZD7XPdVjdCRBQU5cKGt+xzzZpQFDi4Aj7uCX++oCYiLu7g6lWzDxd3yLkAi0fCny+CoVDrn1RcRkZGhBBXh+N/ldzePFt9kW59o32uffhXiP1bfVEc+qblzcyqS6eD6JdhwQ2w6yvoPQWCWtjn2pY6t0Otpzn7r/p1nRC49kV1H56a9kopyoc1M2DrXNjykdouf8R8CGhU87iFVUgyIoSo/fLSSzacazscDq2A5ZPgoQ0Q2MS21y7IgdXPq7f7Pgb1mlV8vLU17qOOxBxbpY4IjfzKvtevzKUzaoO2A8vUr129oO+j0OdR8KhjnWu4eqhTY5HXwM9T4Nx2mHuNOm3T+ibrXKOqslPVouLzu6xzvjr11a0CWt5Q8XYBDk6SEVGpl19+mRUrVrBnzx6tQxGieuI2gGKAes3hji8gM0FNTn4YCxPW2PaP+Kb3If0s+EfANdNsd52KDJ4Jx1bDoZ/h3E5o2K3yx9haXjr8875az2LIB3RqF9prX1Q7ydpCm2EQ2hGWjYfzO9V6mqjJ6h5Aru62uaZJYR5s/VT9mfMzrHvuw7+CZ4CalHS+Bxp0td/om5VIMuKk7rvvPi5dusSKFSu0DkUIx3dijfq5+XXg4gYjFsBn/SBxn1rLccuHtrnuhVh1JQvAkDfA3ds216lMSFt1dc3exfDXTBj3q3YvVoYi2LkA1s9S6zgAmvSH61+DsE62v37dxjB+Fax9RV1ttPVTdWpoxALbjJIpirr54V+vQHrxJrJhnaDXFCsUMSsQv0fdjyjjPOz4Uv0Iaqkmdh1H2S6xszJJRq5yBQUFuLvb+B2BEFpSFDixVr3dPFr97N9AHSH5+nbYtQga9VL/eFvbqulgKIBm16rvyrU0aLo6FXLqH7WI1/Rc2IuiqKMza16C1GPqffVawPX/p04j2TM5cnWHIa+r0zYrJkP8bvisP9zyEbQbbr3rnPlXnaI7X7xzum+4usKp4yjrLS9ve6s6mnRyA+z5Th0lST0Gf70Ma1+FpgPV0ZLWN9l+BVcNyGoajQwcOJCpU6cydepU/P39CQoK4qWXXkJRFF599VXat2//n8d07tyZl156iZdffplFixbx888/o9Pp0Ol0rF+/HoD9+/dz7bXX4uXlRb169XjwwQfJysoyn+O+++5j+PDhvP7664SHh9OqVSsAzp07x+jRowkMDMTHx4fu3buzdevWMtf/+uuviYyMxN/fn7vuuovMzEzbPUFCWEvKEfVdo6snRPYtub/ZtTCouJbjt2mQdNC61z36BxxfDXo3uOFt7YfNAxqpy3sB1rwMRqP9rp2wD766Bb4bpb5QeteDG9+Fh2PUnYW1em5a3QCTNkFEL3XqZOk4WPlkzVvop8WpU4Dzh6iJiJsPDHoRHtkJnUdbv8+N3kX9fb5jHjx1TE2qGvUBxagWTv84Ad5tCb88qiZIDrglXe0bGVEUdfmeFty8LfpPtWjRIiZMmMC2bdvYsWMHDz74II0aNeL+++/nlVdeYfv27fTo0QOA3bt3s2/fPn766SeCg4M5fPgwGRkZLFiwAIDAwECys7MZMmQIvXv3Zvv27SQnJ/PAAw8wdepUFi5caL7u2rVr8fPzY80adeg6KyuLAQMG0KBBA3755RdCQ0PZtWsXxlJ/rGJjY1mxYgW//fYbFy9eZOTIkbz55pu8/vrrVnjihLCh48VTNJHX/PedYb+n1D/OsWthyRh4cD14XnkzryorzIU/nlVvO9IKln5PqqtqkvarUwcd77Tt9TLi4e/XYM9iQFEbzvWarO6d4+lv22tXlX9DuO83WPe6utvx9i/g7Da4c6Hlxca5F2Hju7D1M3UZt04PXcbAoBfAN8Qm4f+Hpx90Hat+pMXB3u9h73dqofCuRepHYFPodDd0GuUwK4pqXzJSmANvaDRH9nw8uPtU+fCIiAg++OADdDodrVq1Yv/+/XzwwQdMnDiRIUOGsGDBAnMysmDBAgYMGEDTpk0B8PLyIj8/n9DQUPP5Fi1aRF5eHl999RU+Pmocc+bMYdiwYbz11luEhKj/GXx8fPjiiy/M0zOff/45KSkpbN++ncDAQACaN29eJlaj0cjChQvx9fUFYMyYMaxdu1aSEeH4ThQv6S1vWkKvh9vnqUP0abHwy1S4c1HN36lv/hAunVb3h+n/dM3OZU3egeqKnr//T/1oe6ttCjcLstXnYMuHJW8O29+hFtLWbWz969WUi5u6BLrxNbD8QbWW6LP+MOx/0GFE5Y8vKlBrNTa8pSYkAM0Gq3UwIW1tGnqFApuqo38DnoPTm9Wk5OAKNUlZ95r60aS/mpi0vcWi1y9rk2kaDfXq1QtdqT96vXv35vjx4xgMBiZOnMh3331HXl4eBQUFLF68mPvvv7/C8x0+fJhOnTqZExGAvn37YjQaOXr0qPm+Dh06lKkT2bNnD126dDEnIuWJjIw0JyIAYWFhJCcnW/TzCmF3+VlwJka9faUaCZ96MHKROp1y6Ge1F0VNXDylrqAB9cXIWstTraXXZLWHx6XTaiGpNRkNsOtr+LArbHhTTUQiouCBtWpfD0dMREprEa1O2zTuCwVZ6vTGr4+pI13lURS1RuOTKFj1nJqIBLeFe3+EMT9pm4iUptdDk34w/BN1Gmf4XDUJATi5EVZMgndawNFVmoVY+0ZG3LzVEQqtrm0lw4YNw8PDg+XLl+Pu7k5hYSEjRlQhQ6+C0skKqKMslXFzcyvztU6nKzONI4RDOvWPWkAa0Fhd1nslDburq13+eFrt0BneFRpFVe+aq56Hojz1j32726p3Dlty94EBz8LKabDhbbVw18O38sdVJnad+twlHVC/rhsJ0a+ooy9a18tYwi8cxv6ijnJsfAd2LoSz29Vpm/otS447v0v9eU9vVr/2CYZrX4DO99p/qwFLeNRR61Y6j1anbvYuUVdZpZ2E0A6aheXAz1g16XSaDjVZ4vIC0X///ZcWLVrg4qJ2Gxw3bhwLFizA3d2du+66q0zS4O7ujsFgKPP4Nm3asHDhQrKzs80Jx+bNm9Hr9eZC1fJ07NiRL774grS0tApHR4RwOqWnaCp7Qew5UV3ieeBHWHofTPoHfIIsu97xNXB0Jehd4YZ3HPdFuOtYdZ+ctFjYMkddaVNdyUfUFTLH/1S/9vSH/s+oz6ezbkzn4qomFo37wE8PQvJB+Hwg3Py+Omqy9lXY/4N6rKsX9JmqTn9ZI6mzp4BGMOBp6P8UJB9WV5lpRKZpNHTmzBmmTZvG0aNH+e677/joo4947LGSnTwfeOAB/v77b1atWvWfKZrIyEj27dvH0aNHSU1NpbCwkHvuuQdPT0/GjRvHgQMHWLduHY888ghjxowx14uUZ/To0YSGhjJ8+HA2b95MXFwcP/74IzExMTb72YWwOUUpKV6tyjJWnU6tEQhqqe6s++MEddqhqory1Z4lAFGTILi15THbi4sbDH5JvR0zB7KqMeWalQK/PQGf9lETEb2r2kDs0T3qi7OzJiKlNRukTts0GQCF2bD8Ifiwc0ki0mm0ukLm2hedLxEpTafTfEpJkhENjR07ltzcXHr27MmUKVN47LHHePDBB83fb9GiBX369KF169ZERZUdMp44cSKtWrWie/fu1K9fn82bN+Pt7c3q1atJS0ujR48ejBgxgsGDBzNnzpwK43B3d+fPP/8kODiYG2+8kQ4dOvDmm2+aR2iEcEppcWpdhN6tZH68Mh6+art0N2+IW2/Z5nIxc9Rr1glRp0EcXdvh6nRUQZY6HVFVhblqO/MPu8CO+Wpn29Y3w5RtcMObapFsbeIbAmOWqytidHowFkFkP3hwA9w2V9PRhNpEpygOuOD4MhkZGfj7+5Oeno6fX9lld3l5eZw8eZImTZrg6ek8ffkHDhxI586dmT179hWPURSFFi1a8PDDDzNtmkZtpGvIWf99RC3w71xY9ayaiIz71bLH7vsBfpoI6OCeZWphY0UunVV3mi3MUVfndBxZ7bDtKm6D2v9D7wZTt6mrL67EaFSbpq19VW1vDxDWWa21Kd2/pTZL2Ku2sY/s57hTcA6motfv0mRkxEGlpKQwZ84cEhMTGT9+vNbhCOF8KlrSW5mOI6H7BECBnx5Qk42K/PmCmog06gMdbNy7w5qaDlCXoBoL4e8Klumf3gJfDFYTtPSz4NcQbvscJq67ehIRUNu4N+kviYgN1L4C1loiODiYoKAgPv/8c+rWrat1OEI4l8JcOLVJvd38uuqdY+gsiN+ltgpfOk7dz6S8nhyx69QlwToXuNGBi1avJHqm2vTtwDJ1t9zS+8NciIU1M+DIb+rX7nXgmifURm4O3FpcOB9JRjRiat9+JU4weyaE4zq9GYpy1b1AgttU7xyuHmoDtM/6qy29/3wRbny77DFFBSVFqz0nQuh/t3FweGGdoP0INRn56xW1P0ZOmlpHsm1eSSfRruPUBlp1grWOWNRCMk0jhKh9zBvjDa7ZSEXdxnD75+rtbZ/B/mVlv7/1U3WvFZ/6MLAGy2O1du2Lat1I7FpY+ZRanPrvJ2oi0vw6mLwFhs2WRETYjCQjQojax1Qv0qKaUzSltRyi7ukC6kZjKcXdjDPi1aZhoDb38gqo+bW0EtgEuhfXpm2fB3mXILiduork3mXVH10SoopqTTIi0xqOSf5dhN1dPK2OVuhc1P4Q1jDweXUFRWG2uhtrQTb8+ZK6LLZhT7XfhLPr/4y6l06dEHXX10n/qDvBCmEHTl8zYuqFUVBQUKW25sK+cnLUTbIubycvhM2YRkUielpvtMLFVd1bZW4/SDkCX98GZ7cCOrjpXetvCa+FOvXh0d3qdE1t+HmEU3H6ZMTV1RVvb29SUlJwc3NDL/+JHIKiKOTk5JCcnExAQIA0UBP2Y64XqcaS3orUCYY7F8DCm4sTEaD7/WVXnzi72tA1VTglp09GdDodYWFhnDx5ktOnT2sdjrhMQEAAoaGhWochrhZFBXByg3rb2skIqHuVRL+s7sXiFagWfgohaszpkxFQ25m3aNGCgoICrUMRpbi5ucmIiLCvs/+qdRw+9SG0o22u0ecRtQV4UKva1/pcCI3UimQEQK/XS7txIa52pbuu2mrKVqeD9nfY5txCXKWkwEIIUXscr0ELeCGEZiQZEULUDhnxkHwQ0EHTQVpHI4SwgCQjQojawbSKpkE38KmnbSxCCItIMiKEqB1OrFE/yxSNEE5HkhEhhPMzFEHsevW2JCNCOB1JRoQQzu/8DshPB6+60KCr1tEIISwkyYgQwvmZlvQ2uxb00ttGCGcjyYgQwvkdl3oRIZyZJCNCCOeWlQIJe9TbzQZrGooQonokGRFCOLfYv9XPoR3BN0TbWIQQ1SLJiBDCucmSXiGcniQjQgjnZTSUNDtrcZ22sQghqk2SESGE80rYA7lp4OEHDXtoHY0QopokGRFCOC/TxnhNB4CLm7axCCGqTZIRIYTzMvUXaS5TNEI4M0lGhBDOKSdN7bwK0FyW9ArhzCQZEUI4p7h1oBihfhvwb6h1NEKIGpBkRAjhnMyraGRJrxDOTpIRIYTzUZRS9SKSjAjh7CQZEULYTlGBbc6buB+yksDNBxr1ts01hBB2I8mIEMI2EvbBmxHw3d1QkGPdc5tGRZr0B1cP655bCGF3kowIIWxj+xdQlAdHV8I3d0BeuvXObaoXkVU0QtQKkowIIayvKB8OrVBvu7jDmS2w8GZ1h92aysuAs/+qt6VeRIhaQZIRIYT1Hf9THQnxDYcJa8CnPiTugwVD4dLZmp375AYwFkG95hDYxDrxCiE0Va1k5OOPPyYyMhJPT0+ioqLYtm1bhcfPnj2bVq1a4eXlRUREBE888QR5eXnVClgI4QT2/aB+7nAHhHeG8avAPwIunID5QyH1ePXPLatohKh1LE5GlixZwrRp05g5cya7du2iU6dODBkyhOTk5HKPX7x4Mc899xwzZ87k8OHDfPnllyxZsoTnn3++xsELIRxQ7iU4tkq93XGU+jmoOdy/GoJaQsY5mD8E4vdYfm5FKVUvIsmIELWFxcnI+++/z8SJExk/fjxt27Zl7ty5eHt7M3/+/HKP37JlC3379uXuu+8mMjKS66+/ntGjR1c6miKEcFKHfgZDAQS3hZD2Jff7N1BHSMI6Q84FtYbk1GbLzp1yFNLPgqsnRF5j1bCFENqxKBkpKChg586dREeXvCPR6/VER0cTExNT7mP69OnDzp07zclHXFwcv//+OzfeeOMVr5Ofn09GRkaZDyGEk9i/VP3c4U7Q6cp+z6cejPsVGl8DBZnwze1wbHXVz22aomncF9y8rBOvEEJzFiUjqampGAwGQkJCytwfEhJCYmJiuY+5++67efXVV7nmmmtwc3OjWbNmDBw4sMJpmlmzZuHv72/+iIiIsCRMIYRW0s/BqX/U2x3uLP8YTz+4dxm0vEFd+vv93bBvadXOL/UiQtRKNl9Ns379et544w0++eQTdu3axU8//cTKlSv5v//7vys+Zvr06aSnp5s/zp6tYfW9EMI+9i9TPzfuCwEVvIlw84JRX6s1JcYi+GkibJtX8bkLsuF08bROi+usE68QwiG4WnJwUFAQLi4uJCUllbk/KSmJ0NDQch/z0ksvMWbMGB544AEAOnToQHZ2Ng8++CAvvPACev1/8yEPDw88PKSrohBOx7SKpuPIyo91cYPhc8HTH7Z9Dr8/BXmXoN9T/53eATi1Sa1FCWikLusVQtQaFo2MuLu7061bN9auXWu+z2g0snbtWnr3Ln9/iJycnP8kHC4uLgAoimJpvEIIR5V4AJIPqk3O2t5atcfo9XDD2zDgWfXrv1+DP19UV81crvQUTXnJihDCaVk0MgIwbdo0xo0bR/fu3enZsyezZ88mOzub8ePHAzB27FgaNGjArFmzABg2bBjvv/8+Xbp0ISoqihMnTvDSSy8xbNgwc1IihKgF9hePirS4HrzqVv1xOh0Meh48A2D1dIiZo46Q3Pw/cCn1J+r4GvVzc5miEaK2sTgZGTVqFCkpKcyYMYPExEQ6d+7MqlWrzEWtZ86cKTMS8uKLL6LT6XjxxRc5f/489evXZ9iwYbz++uvW+ymEENoyGkuKUE29RSzV+2F1yuaXqbD7G7WD6x1fqhvhXYiFiydB7wZN+lkvbiGEQ9ApTjBXkpGRgb+/P+np6fj5+WkdjhDicic3wqJhajLx5DFw86z+uQ7/CsvuV+tDmg6EUd/CnsXwx9MQ2Q/u+81qYQshbKuqr9+yN40QouZMhattb61ZIgLQZhjcsxTcfCBuPXx1a8mme7KKRohaSZIRIbSmKGrxp6FI60iqpzBP7boK1Z+iuVzTgTDuF7WO5PyOkiW90l9EiFpJkhEhtHZwOcztq64icUbHV0N+Bvg1hEZ9rHfeht1h/B9Qp7htgG+42mJeCFHrSDIihNbi1qmfd38N+VnaxlId5h16R6hLda0ppC1MWA2tboLrXpElvULUUpKMCKG1xAPq54KskukOZ5GTVrK3jLWmaC5XNxJGL65aIzUhhFOSZEQILRmKIPlQyde7v9Euluo49DMYC9XdeUNkCkUIUT2SjAihpbRYdbM4V0/Q6eHMFkg9oXVUVWdJ+3chhLgCSUaE0FLifvVzaMeSzqJ7nGR05NIZNXlCB+1HaB2NEMKJSTIihJbMyUh76HKvenvPd86xzHd/ccfVyGvAv4G2sQghnJokI0JoKam4eDWkPbQcCt71ICsRYtdW/DitKUqpKRobFa4KIa4akowIoaXS0zSu7tDxLvXr3V9rF1NVJO6HlCPg4gFtb9E6GiGEk5NkRAitZCVDVhKgK1mJYpqqOfoHZKdqFlql9i1RP7caqu5HI4QQNSDJiBBaMY2K1GsG7j7q7ZC2EN4VjEUlL/iOxmiAAz+qt2WKRghhBZKMCKGV0vUipXUdo37e9bVam+FoTv0DmQnqvjHNZeM6IUTNSTIihFZMnVdDL0tG2t+h9h1JOQznd9k/rsqYClfb3abWuQghRA1JMiKEVkoXr5bm6Q9tb1VvO1oha2EuHPpFvS2NzoQQViLJiBBaKMyD1GPq7cunaaCkkPXAj1CQY7+4KnP0DyjIBP9GENFL62iEELWEJCNCaCHlMCgG8AoEv/D/fr/xNRDQGPIz4PCv9o/vSkyNzjreaf0deoUQVy35ayKEFkrXi+h0//2+Xl8yOuIoUzXZF+D4n+rtDjJFI4SwHklGhNCCeSVNhysf0/luQKeuXkmLs0tYFTq0XF1yHNoRgltrHY0QohaRZEQILZiLVytIRvwbQrNr1dt7Fts+psrsM03RyKiIEMK6JBkRwt4U5crLei9n3jxvsdpsTCsXT8HZf5EdeoUQtiDJiBD2ln4W8tNB7wZBrSo+tvVN4FUXMs5D3Dr7xFceU+Fq0wHgF6ZdHEKIWkmSESHszTRFU7915U3DXD1KikV3f2PbuK6k9A69UrgqhLABSUaEsLeqTtGYmKZqjqyEnDTbxFSRhD1qTxRXT2gzzP7XF0LUepKMCGFvifvUzxUVr5YW1hHCOoGhoGSEwp5MhautbgRPP/tfXwhR60kyIoS9XWmDvIp0Kd48b7edN88zFMGBZeptWUUjhLARSUaEsKe8DHVlClR9ZATUzfNcPNREJmGvTUIr18kNkJWkdoptNth+1xVCXFUkGRHCnpIOqp/9GoB3YNUf5x0IbW5Wb9uzkNW0ikZ26BVC2JAkI0LYU3WmaExMhaz7f1B3z7W1gpySfXE6jrL99YQQVy1JRoSwJ0uLV0trMgD8IyAvXV1ZY2tHf4eCLHXDvoietr+eEOKqJcmIEPZk6bLe0vQuxfvVYJ/N80wrdzqOLH8zPyGEsBJJRoSwF0MRJB9Sb1e0QV5FOt+jfo7bABdPWyeu8mSnwom/1NvS6EwIYWOSjAhhL2mxUJQHbj4Q2KR656jbWJ2uQYG931k1vDIOLgfFAGGdoX5L211HCCGQZEQI+zG1gQ9pq065VJe558i3YDTWPK7y7FuifpbCVSGEHUgyIoS9mJORatSLlNbmZvDwh/Qzah8Qa0s8AOe2g06v9jcRQggbk2RECHsxLeutzkqa0ty8oMMI9ba1e44cXA4LblBvN48G3xDrnl8IIcohyYgQ9pJopWQESnqOHP4Vci/W/HyFefDbNFh6H+RnQEQvGPZhzc8rhBBVIMmIEPaQlQJZiYAOgtvW/HzhXdTpHkM+7F9Ws3NdiIUvo2HHl+rX10yD+1aCX1jN4xRCiCqQZEQIe0gqrhcJbAoedWp+Pp2uZHSkJlM1+5fBZ/3VehbvILj3R4ieCS6uNY9RCCGqSJIRIeyhJs3OrqTDSNC7QcKekuLYqirMhV8egR8nqF1WI/vBpE1qnYgQQtiZJCNC2IMpWbBGvYiJTz1ofaN625LRkZSjMO9a2PUVoIMBz8LYn2VaRgihGUlGhLAH8wZ5VkxGoKTnyL4lUJRf+fF7FsPnA9VOsD7BMHYFDHq+Zn1PhBCihiQZEcLWCvPU0Qiw7sgIQLNrwTdcXVFz9PcrH1eQDcsnw4rJUJijdnGdtAmaDrRuPEIIUQ2SjAhhaylH1NbqXnXBL9y65y6zed4VpmqSDsHng2DvYrWR2aAXYcxy6SEihHAYkowIYWvmKZr2ttn91pSMnFgL6edK7lcUtS5k3iBIPQq+YTDuVxjwtEzLCCEciiQjQtiauXi1o23OX68ZNL4GUGBP8eZ5+Znw04PqipmiPHWVzKRNEHmNbWIQQogakGRECFuzxbLey5l6juz5BhL2qkWq+38AnQtEvwx3LwWfINtdXwghakCSESFsSVFss6z3cm1vAXdfuHhKrQ+5cAL8GsD43+GaJ0Av/9WFEI5L/kIJYUvpZyE/XW1OFtTKdtdx94H2t6u3FQO0HKpOyzTqZbtrCiGElUjPZyFsyTRFU78VuLrb9lr9n4LMBHW5b9Qk2xTLCiGEDUgyIoQt2WOKxiSgEdyz1PbXEUIIK5NpGiFsybRBXogNi1eFEMLJSTIihC2ZR0YkGRFCiCuRZEQIW8nLUFe3gPX3pBFCiFpEkhEhbCX5kPrZN1zdYVcIIUS5qpWMfPzxx0RGRuLp6UlUVBTbtm2r8PhLly4xZcoUwsLC8PDwoGXLlvz+ewWbeglRG9izeFUIIZyYxatplixZwrRp05g7dy5RUVHMnj2bIUOGcPToUYKDg/9zfEFBAddddx3BwcEsW7aMBg0acPr0aQICAqwRvxCOS+pFhBCiSixORt5//30mTpzI+PHjAZg7dy4rV65k/vz5PPfcc/85fv78+aSlpbFlyxbc3NwAiIyMrFnUQjiDRFlJI4QQVWHRNE1BQQE7d+4kOjq65AR6PdHR0cTExJT7mF9++YXevXszZcoUQkJCaN++PW+88QYGg+GK18nPzycjI6PMhxBOxWiA5MPqbVttkCeEELWERclIamoqBoOBkJCQMveHhISQmJhY7mPi4uJYtmwZBoOB33//nZdeeon33nuP11577YrXmTVrFv7+/uaPiIgIS8IUQnsXYqEoF9y8IbCJ1tEIIYRDs/lqGqPRSHBwMJ9//jndunVj1KhRvPDCC8ydO/eKj5k+fTrp6enmj7Nnz9o6TCGsK3Gf+jmkHehdtI1FCCEcnEU1I0FBQbi4uJCUlFTm/qSkJEJDQ8t9TFhYGG5ubri4lPxBbtOmDYmJiRQUFODu/t/9Ojw8PPDw8LAkNCEcS1LxnjRSLyKEEJWyaGTE3d2dbt26sXbtWvN9RqORtWvX0rt373If07dvX06cOIHRaDTfd+zYMcLCwspNRISoFUwb5MlKGiGEqJTF0zTTpk1j3rx5LFq0iMOHDzN58mSys7PNq2vGjh3L9OnTzcdPnjyZtLQ0HnvsMY4dO8bKlSt54403mDJlivV+CiEcjXlZrxSvCiFEZSxe2jtq1ChSUlKYMWMGiYmJdO7cmVWrVpmLWs+cOYNeX5LjREREsHr1ap544gk6duxIgwYNeOyxx3j22Wet91MI4UiyUiArEdBBcFutoxFCCIenUxRF0TqIymRkZODv7096ejp+fn5ahyNExWL/hq9vg8Cm8OhuraMRQgjNVPX1W/amEcLazPUi0gZeCCGqQpIRIazNvJJGkhEhhKgKSUaEsDbZIE8IISwiyYgQ1lSYB6nH1NuyrFcIIapEkhEhrCnlCBiLwDMA/BpoHY0QQjgFSUaEsKakUsWrOp22sQghhJOQZEQIa5KVNEIIYTFJRoSwJileFUIIi0kyIoS1KAokFScjskEeRqPC5hOppGUXaB2K2Y5TaaRk5msdRq13NDGTo4mZWochnIjF7eCFEFeQfhby0kHvCvVbaR2NpooMRp79cT8/7jpH/5b1+er+nlqHxLaTaYz8LIZGgd788Vg/fDzkz58tHE3M5OaP/qHQoHBzxzCeHdqaiEBvrcMSDk5GRoSwFlO9SP3W4OqhbSwayis0MPnbXfy46xwAm46nOMRoxPLdajxn0nJ4848jGkdTOymKwoyfD1BoUHcZ+W1fAoPf28Cs3w+TnluocXTCkUkyIoS1mDuvXr1TNFn5RYxfsJ01h5Jwd9UT5u+JUYFVBxM1javIYGTVgZIYvv73NFtOpGoYUe30674Etp5Mw8NVzxdju9O3eT0KDEY+2xjHwHfWsWjLKQoNRq3DFA5IkhEhrCVxn/r5Km12djG7gHvm/UtM3AV83F1YOL4H9/dtAsDKffGaxhYTd4GLOYXU83FndM8IAJ5eto+s/CJN46pNsvKLeH3lIQCmDGpOdNsQvpkQxfz7utM8uA4XcwqZ+ctBhszeyJpDSTjBHq3CjiQZEcJaruJlvYnpeYz8LIa959Kp6+3G4om96NMsiBs6hAKw9WQayZl5msW3cl8CAEPbh/LiTW1pWNeL85dyeeP3w5rFVNt8tPY4SRn5NAr05sH+TQHQ6XRc2zqEVY/14/+Gt6eejztxKdlM/GoHd8/byoHz6RpHLRyFJCNCWEN+Jlw8qd6+yjbIO5WazYi5WzienEWonyc/PNSbThEBADSs603niAAUhTLTJPZUaDCap4lu6hiGj4crb4/oCMDirWf453iKJnHVJieSM/lyk/r7P3NYWzzdXMp839VFz5hejVn39EAmD2yGu6uemLgLDJuziSd/2EtCeq4WYYtSjEZtR6okGRE2dyQxg+k/7eeT9SdYfzRZ03fINpN0UP3sGw4+9ar8sIIiI38eTGTmzweccink4YQMRsyN4dzFXBrX82bppN60CPEtc8zNHcMAtZhRC1tiL3App5CgOu5ENVH/bfo0C2Jc78YAPLtsH5l5UlxZXYqi8PIvhygyKgxuHczgNiFXPNbP041nh7bm7ycHcGvncBQFftx1jkHvrue9P4+SbcVps/wiAwfOp/PDjrO8+ushPl53ggz5dy7Xt1tPM27BNvIKDZrFIGvbhE2dvpDNvV9sJTWrbK+JoDoetAnzpW24H23D1I8mQT64ujhpfmxudlZ5vYiiKByMz2DZznP8sjfe3IfjnxOprHqsP+6uzvEc7DydxvgF28nIK6J1qC9fTehJsK/nf467oUMYr608zPZTaSRl5BHi999jbMlUr3JD+zBc9CUt+p+9oTXrjqZwJi2H11ce5s07Oto1rtrijwOJbDqRirurnhnD2lbpMQ3revO/u7owvm8TXvvtEDtOX+Sjv0/w3bazPHV9S+7sHlHm36oyadkFHE7I4FB8hvo5IYMTyVkUXfZu/8tNJ3k8ugWjezbCzVn/1ljZJ+tP8PaqowCs2H2eu3o20iQOSUaEzaRm5TN2/jZSswpoFeJLq1BfDiVkEJeSRWpWPv8cz+ef4yUrGjxc9bQO9aVNmJ85SWkd5kcdZ+gHkVh5s7OUzHx+3nOeZTvPcaTUKEh9Xw8KDUbiUrL5ctNJJg9sZutoa2zjsRQe+nonuYUGujWuy/xxPfD3div32AYBXnRtFMCuM5f4Y38C9xUXtdpDQZGR1QeTALixQ1iZ73m7u/LunZ0Y9XkM328/y9D2oQxsFWy32GqDnIIiXvtNLVqd1L8pjev5WPT4zhEBLJ3Um1UHEnlz1RFOX8jhuZ/2s3DLKZ6/sQ39W9Yvc7zRqHA6LadM0nEoPoPEjPJHW/293Ggb5kerUF/+OZ5CbEo2M34+qJ7/hjYMbhOM7irdQ0pRFN5cdYTPNsQBMHVQc0b1iNAsHif4Ky+cUXZ+Efcv3M7pCzk0rOvF1w+UvGvOLTBwNCnT/E7mUIL6hyWnwMDec+nsPVe2qK1xPW/ahvnRJsyPDg386dciyPFGUJLKL17NLzKw9nAyy3aeY8OxFAzF79TcXfVc1zaEEV0b0q9FED/viefJpXv56O/jDO8STpi/l71/gir7fX8Cj32/m0KDQv+W9Zl7b1e83Sv+U3JTx3B2nbnESjsnI5tjU0nPLSSojgc9mwT+5/s9mwRyX59IFmw+xXM/7mf1E/3x9yo/qRL/9fG6E8Sn59EgwIvJA5tX6xw6nY4bOoQxuE0IX8Wc4qO/T3AkMZOx87cxoGV9otuGcDRR/VtxJDGTnILypxJK/51oW/yGJszf05xsFBqMfL/tDB/8dZy4lGwe+GoHvZvW44Wb2tC+gX+1nwNnZDAqvLhiP99tOwvACze2YWJx0bFWdIoTrK/KyMjA39+f9PR0/Pz8tA5HVKLQYOSBRTvYcCyFut5u/Di5D03r16nwMUajwpm0HPM7HVOCkpD+33c8j0e34PHolrYK33JGA7zRAIpyYeoOlHrN2XsunWU7z/Lr3oQyzZ66NArgjq4NGdYxvMxIgqIo3Dk3hh2nL3JzxzDm3N1Vi5+kUku2n2H6T/sxKnBThzA+GNW5StNKCem59J71NwD/Th9MqL99pmqeXrqXpTvPMbZ3Y169tfxRq9wCAzf8byOnLuQwoltD3r2zk11ic3YnU7MZ8sFGtY/ImG4MaRdqlfNeyingw7Un+PrfU+bmaaWVN4LaKtQXX8+qJZEZeYV8si6W+ZtPUlBkRKeD27s05Okhrez2e6mlgiIjTyzZw8r9Ceh1MOv2DozqYbupmaq+fksyIqxKURSeWrqPH3edw9NNz3cTe9GlUd1qn6/0XPD2U2n8eSiJut5ubHluMF7uLpWfwB5SjsHHPTC6evFZ3w0s25VAbEq2+dth/p7c1qUBd3RrSLMKkrKD8ekM+2gTRgUWT4yiT7Mge0RfZZ9vjOWN39XOpaN7RvDa8A4WzeuP+HQLO05fZMbNbbn/GtuPjhQUGen+2hoy8opY8mAvoppeubB4x6k07vwsBkWB+fd159rWVy7CFOr/8/sWbGfDsRT6t6zPovE9rD7dcSo1m4/+PkFKVr5aX2bl2rKzaTm8s/oov+xVa4o83fQ82K8pDw1oVmu3CsgpKGLSN7vYeCwFNxcd/7ury3+mL61NkhGhiXdWH+HjdbG46HV8PqZbhZX1ljIYFQa+u46zabm8Nrw99/ZqbLVzV1deoYH9qxfQY8eT7DY257aCVwH1D9vQdqHc0a0hfZoFVflFe8bPB/gq5jQtguvw+2P9HKLITlEU3ll9lE/WxwLw0ICmPDe0tcUvPgs2n+SVXw/RvXFdlk3uY4tQy1h3JJnxC7cT7OtBzPTBlf4bvL7yEPP+OUmwrwdrnhhwxRoYAX8eTOTBr3fi5qJj9eP9Kx35dGS7z1zk9ZWH2XH6IqDWcD11fUtGdLOsiNbRpecUcv+i7ew8fREvNxc+H9uNfi3qV/7AGqrq67f2f+lErfF1zCk+Xqe+YL0+vL1VExEAF72O8X3Ud9TzN52s/rr4U5vgo26wZoa6sV017Tx9kag31rL93w0AHDY2omdkIG/d0YHtL0Qz+64u9GtR36I/aE9e14pAH3eOJ2exaMupasdmLUajwosrDpgTkWeGtmL6DW2q9S74hvZh6HSw4/RFu/SVMC0lvrFDWJX+DZ68vhVN6/uQnJnPK78etHV4VpOWXcDoz/9l2pI95F6hnsKa8goNvFpctDqxX1OnTkQAujSqy9JJvfn0nq40rudNSmY+z/64n5s+/KfW9KBJzsxj1Ocx7Dx9ET9PV755IMouiYglJBkRVrHqQAIzflH/gD8R3dJmy8NG9ojA19OVuNRs/j6SXL2T7P4GLpyAzf+DD7vAtnlgsKz/gKIovPLrQdJzC+nirm7ANiT6On6Y1JtRPRpVef76cv7ebjw7VN3xd/Zfx0m+wioBeyg0GHl8yR6+3XoGnQ5ev609D1ezSBEg1N+T7o3VKbvf99u2AVp+kYE/D5U0OqsKTzcX3r2zE3od/LT7PH9qvJ9OVRiNCo8v2UNM3AV+2n2eMV9utfmGdJ+sj+XcxVzC/D2Zem31fx8ciamI9s8n+vPiTW3w83TlSGImY77cxn0LtnEsyfl6AJmcTcth5NwYjiRmUt/Xgx8m9aZb4+pPnduKJCOixradTOPR7/egKDC6ZyMeHWy7P1B1PFy5uzjRmfdPXPVOcm6H+tkrEHIuwO9Pwad94OgqqOKs5YZjKew7l46nm56e3uqcc72m3aoXz2Xu7BZB54gAsvKLNGtXnltg4MGvdvDL3nhc9To+vKsL90TVfFrspuL5aVvvVbPpeCqZeUWE+HnQzYKapa6N6ppXFTy//AAXswsqeYS25qw7wcZjKXi66fHzdGXH6Yvc9fm/Ntsl+cyFHOZuUEfJXrypbaWrqJyNh6sLD/RryoanBzG+bySueh3rj6YwdPZGnl++3yF2n7bE8aRMRszdwqniVY1LH+pN61DHLHWQZMSBbI27wOcbY8kpcJ7Nu44lZfLAou0UFBmJbhPC/93azubr9u8r/iOx9WQa+89ZOM2SexEuHFdvPxwDN74L3vUg9Rh8Nwq+ugUS9lV4CkVR+OjvEwBM7OqHS1bxO+iQqjV8qoxer+PVW9uh08GKPfFsjbtglfNWVVZ+EePmb2PdUfVFbt647gzrFG6Vc9/QQZ2q2XXmEucv2W6qZmWpKRq9hfP+T0S3pHlwHVKz8nnZgadr/jmewgd/HQPgteEdWPJQb4LqeHA4IYM7527h3MUcq1/z1d8OUlBkpG/zetzYwTqrZxxRXR93Zg5rx5ppAxjSLkQtKt96hkHvrueDNceIt+HvrrXsPXuJkZ/FkJSRT4vgOiyb1IfIIMv6wNiTJCMOIC4li4lf7WDU5//yxu9HeOWXQ1qHVCUJ6bmMm7+NjLwiujYK4KPRXezS/yPM38s89P7FJgtHR87vUj/XjQTfUOg5ER7dDX0fAxd3OLkRPusPKx6GjPLfvcfEXmDn6Yu4u+q5v3mWemdgU/DwLff46ujYMIDRxSNAM385SJGdtl0vKDLy0Nc72HYqDV9PV76eEMUgKzYCC/HzpEek2u/jj/22aQ+fX2RgzSG10dlN1Vgp4Onmwnt3dsJFr+PnPfGsOqBNG/uKJKTn8ph5NDKCEd0a0ibMj2WTetMgwEtdpvxpDCeSrTe98PeRJP46nIyrXscrt9j+TYcjaBLkw2djurPkwV50bOhPVn4R/1t7nL5v/c29X2xlxe7zdqnTsdSW2FTunvcvF3MK6RQRwA8P9Xb4ZcuSjGgoLbuAl385yPUfqFtqu+h16HSwZMdZ1h2tZj2EnaTnFnLf/O0kpOfRrL4PX47rYdeltg9cow6lr9yXYNm7lPM71c8Nupfc5+kP170KU3dA+zsABfZ8qxa5rnsD8rPKnOLDv9WRlbt6RFA3Q22jXFHn1ep6+vpWBHi7cSQxk6//PW3181/OaFR4etleNp+4gLe7C99MiDInDtZk671q/jmWSmZ+EaF+nnSt5rLyThEBTBqg/o69sPwAF7IcZ3i+0GBkyre7SMsuoF24HzOHtTN/LzLIhx8n96F5cB0SM/K4c24M+85dqvE18woNvPKr+ibp/mua0DzYeom3M4hqWo8VD/flw9FdiGoSiKLAphOpPL5kDz1e/4tnlu1l28k0HGFx6p8HE7lvwXayCwz0aVaPbx+Ioq6Pu9ZhVUqSEQ3kFxn4bEMsA95Zx8Itp8wbTK1+vJ95tchzP+6zeSFadeUVGpj41Q6OJmUS7OvBovt72v2XvUNDf6KaBFJkVCxbdWKqF2nY/b/fq9sYRsyHB9ZCRBQU5sCGt9SkZNdXYDSw/VQa/8al4eaiY9KAZqU6r1p/X5O6Pu48PUQtZn3/z2M2n69+c9URft6j1oh8em8388671ja0fSg6Hew5e4mzadafSli5v/pTNKU9OrgFrUJ8uZBdYC7OdgSzfj/CrjOX8PV05ZN7uv5nh9xQ/+Kdkxv6czGnkLvnbSUmtmZTffM2xnH6Qg4hfh48OrhFjc7lrPR6Hbd0CmfJQ73555lBPB7dgohAL7Lyi/hhxzlGfhbDgHfW87+/jtvk97oqftx5jsnf7qKgyMj1bUOYf18P59hOA0lG7EpRFH7bF8/g9zYw648jZOYV0TbMj8UPRPHlfT1oHuzL00Na0STIh6SMfP7vN8ebrjEYFab9sIdtJ9Oo4+HKwvE9aVjXW5NYJvZT37ku3naGrKrs9qkocL44GWlQTjJi0rA73L8a7lykTudkJcIvj8Bn/fl75RIARnRrSHiAFySakhHrj4wA3NWjER0a+JOZX8Rbq47Y5BqgbiD2+UZ1yuutOzoyoKXtlv0F+3oSVdya/Q8rT4HkFZaaoqniKpor8XBVV9e46HWs3JdgrkPR0u/7E5i/+SQA793Z6Yp7wQT6uPPtxF70blpPrQFasI2/ip8XS527mMPH69UaqedvbOM0L262FBHozePRLdnw1CCWPNiLkd0b4uPuwpm0HD746xj93l7HqM9iWLrjbNX+NlnBgs0neXLpXgxGhTu6Niw3UXVkkozYyc7TF7nj0y1MXbybcxdzCfHz4J0RHfn1kWvo07yk06aXuwvv3tkRnQ6W7TzH2sPV+wNiC4qi8H+/HeL3/Ym4uahNzdqGa1eZfW3rYJoG+ZCZV8QP289W/oCLp9TVM3q3/+wh8x86HbQbDlO2wfWvq1M5SQd4NuU5Fri/zSMdDFCUD6m2m6YBtbfKK7eqw/DLdp5jZ3FjJmv6dW+8OfF9Zmgr7ujW0OrXuNxNHdWC2JVWXuK78VgKWflFhPt70sUKIzsdGvozpXjjwpd+PkCqhtM1cSlZPLNMLa5+aEBTrq+k/XodD1cWjO/BdW1D1Fqgb3ayfPc5i6/72m+HySs0EtUkkFusVMhcW+j1OqKa1uPtEZ3Y/mI0H4zqxDXNg9DpYOvJNJ5eto8er/3FtCV72HIitfq9kSqgKAqz/zpmnkYb3zeSd0Z0dLz9uyrhXNE6obNpOUxZvIs7Pt3CrjOX8HJz4Ynolqx7auAVt8nu1jiQB4rbZU//aT+XchxjeeHcDXEsLJ4SeW9k5zJJlBb0ep25rfj8zSfNm9BdkaleJLQDuFWxmMvVA/pMhUf3sMbvdgoVFwbp9xC+eDAsHQ/GIvAMAH/bvYB3bVSXkd3V88/4+UDlP6cFtsSm8uQPewEY17sxkwfYZ8fgoe1C0evUin9rDmlba4qmtKnXtqB1qC9p2QW8tOKAJnUBuQUGHv52F1n5RfRsEsjT17eq0uM83Vz49J6u3N61AQajwhNL9lo0rbnxWAqrDibiotfx6q3tr4qi1erydnflti4N+eaBKDY/ey1PD2lF0yAfcgsN/LT7PHd/sZV+b6/j3dVHOZmaXfkJq8BoVHjl10PM/kutY5t2XUtm3NzWar/79iTjbTaSnlvIx+tOsHDzKQoM6mZMI7tF8OT1LQn2q/yF8MnrW7H2SDJxKdm88ushPhjV2fZBV+CnXefM0wQv3tTGYd4h3dG1Ie/9eZRzF3NZfTCx4n0WKqoXqcTBSy5MTB5BE31ffm39F3Xi/oCjK9VvhnZQR1Js6NmhrVl1IJGD8Rks3naGMVZohX8oPoOHvtpJgcHIjR1CmTHMfisk6vt60KtpPbbEXuD3/Qk8ZIUkKK/QYJ6KqOkUTWnurnreG9mJW+ds5o8Dify6L8Guv/+KovDCiv0cScwkqI4HcyxctebqoufdEZ3w83Rj4ZZTzPxFbdb3yLXNK/z3zi8y8HJxrcy43pG0Cr26ilZrIjzAiymDmvPwwGbsOnOJH3ed49e98Zy/lMucdSeYs+4EjQK9cXWp2f+3/EKjeYn8y8Pa2nVHbGuTkRErKzQYWbj5JAPfWcfnG+MoMBi5pnkQKx/px1sjOlYpEYGy3SCXa9wNcsOxFPPw8APXNOGBftpuNV2al7uLeY+aLyprglaVepErmFPcV6R9h27UGfs93Pc7hHVWvxl5jcXns1S9Oh48Wfxu+N3VR0mrYTOucxdzuG/BNjKL32m/P7Kz3ffhMCWOK620xHf90RSyCww0CPCis5WLb9uF+/PItWrh5oyfD5Ccab/OuEu2n+WnXefR6+Cj0V2q/DekNL1ex8xhbXk8Wv0Z3l9zjNdWHq5w2mD+plPEpWYTVMeDx6+7OotWa0qn09GtcV3euE3dIuKj0V0Y2Ko+eh2cScshLiW7Rh/nL+Xiotfx/shOTp2IgIyMWI2iKKw5lMSbfxwhrngIrnlwHV64sQ0DW9Wv1jvOro3q8mD/ZszdEMvzyw/QIzLQ7qtW9p9LZ/I3OykyKtzSKZznb2xj1+tXxZjejflsQxy7zlxi5+mL5bc6LiooaWZm4cjIsaRM/jigJoNTBxV3l43sCxPXqc3SglrWJPwquyeqEd9vP8vhhAzeXnWEN++o3gqei9kFjJu/jeTMfFqF+DJvbHdNCt2Gtg9lxs8H2HcunTMXcmhUr2aF0Kak5qaOYTYZ4Xl4UDP+PKSOTr2w/ACfj+lm85GkA+fTzSt5nhrSit7NrrzzcGV0Oh2PR7fEz9ONV387xJebTpKeW8ibt3f4z0hLQnouHxUvYZ9+Q2v8qrm9gSjh6ebCsE7hDOsUTnJmHqdSrTM9GRHoRZi/l1XOpSVJRqwgNiWLF5bv59+4NADq+bjzxHUtuatHRI2LiB6PbsHaw0kcT85i5i8H+XB0F2uEXCWnL2QzfuE2corXq79zZ0eHnIsM9vXk1s7hLN15ji83xdGtcTlt2ZP2gyEfvOqqDcosYBoVGdoutOxQtV4Pwa1rErpFXF30/N+t7RgxN4YlO85yV89GFo8A5BUaeOCrHcSmZBPm78nC+3vg76XNC01QHQ96N6vH5hMXWLk/gckDqz9Vk1doMBd722pLdDcXPe/e2Ylb5mxizaEkfthxllE9bLMHE6i7rE7+dicFRUYGtw5mUn/r1PPcf00T/L3ceObHfSzbeY7MvEL+d1eXMgnpaysPk1NgoHvjutzetYFVritKBPt6Euzr2E3I7E2maazg1V8P8W9cGh6ueh4e2Iz1Tw/k3l6NrVLNbJqucdHr+GVvvM26Vl7uWFImIz+LITWrgDZhfnw2phsero67TGxCP3WIctWBxPILIs+Zmp11s6i+Iy4li9+K91FxhE3BukcGcnvXBigKzPz5gEXV+UUGI498t9u8c+ei+3tq/o7qpg6mVTU126tm/dFkcoqnaDo19LdGaOVqE+bHY8V9Np79cT8PLNrOieSsSh5lOUVReHLpXs6m5dKwrhfvj+xs1TcCd3RryKf3dMXdRc/qg0lMWLTdvAR1y4lUVu5LQK+DV+ywvYMQIMmIVZy+oE7LfDamG88MbV3tHVuvpHQ3yBdX2L4b5OV7Giwa38PqP5O1tQ71o1+LIIwK5j4MZVSzXuTjdbEYFRjcOpj2DWz3ImeJ525oja+HK3vPpbNkRxWWNKO+uM345SBrDiXh7qrny/t60DJE+4LEIe1CcNHrOHA+g1M1WGFg6uZ6s42maEqbNKAZ4/tG4qLX8dfhZIbM3siMn637//KzjXH8dTgJdxc9n97TDX9v6///u75dKAvH98DH3YXNJy5wzxdbScnMZ2bxtNC9vRrTLtwxfudF7SfJSA0pikJCulrM1qx+HZtdx17dIE17GlwqtadBdQrmtGAqrP1h+9n/dq+txkqaMxdyWLHnPACPOFDXyWBfTx6/Tq1TeXvVkSot/f7o7xMs3noGnQ4+vKuzTdq8V0e9Oh70Ka6DqG4ha26BgbWH1e0TrLmK5kpcXfTMHNaO1Y/3J7pNMAajwlcxpxn4znrmboglr7Bme5X8G3eBd1ar/Wtm3tKWDjYc6enTPIhvJ/YiwNuNvWcvce176zmenEU9H3eevK5qy4eFsAZJRmooLbuA/CJ16W6IDV+0PVxdeG9kSTfI32ywBbuz7mlg0r9FEK1CfMkuMPD9tjMl38hJgzR123MalFNPcgWfbjiBwajQr0WQ1Vdn1NS43o1pFeLLxZxC3v3zaIXHLtl+hvfXqLu7vnpLO4a2t/0LtiVMm9lVt8PpuqPJ5BYaiAj0ooMdR6+aB9fhi3E9WPxAFG3D/MjML+LNP44Q/f4GftkbX61+JMmZeTzy3W4MRoXbujTg7p62q0kx6RwRwNKHehPi50FmnjpV8+zQ1jYZjRHiSiQZqaH4S+qoSFAdD9xdbft0tm9QqhvkigNW3avEmfc0MNHpdObakYVbTlFo2unWtFNvYFPwrtqIwPlLuSzbqXardMS9OFxd9ObOrN9uPcOB8+nlHvf3kSSeX662rJ8yqBljekfaK8QqG9IuFBe9jkMJGdVqBmVKYm7qEK5JfUOf5kH8+sg1vDOiIyF+Hpy7mMuj3+3m9k+3sPN0WpXPU2Qw8uh3u0nJzKdlSB1ev81+TcZahPiybFIfekYGcmvncEbYoQuvEKVJMlJD8elqw5nwAPsUApq6QV7MKeTFFfut0g1y/qaSPQ1GdHO+PQ1Ku7VzOEF1PEhIz+N307B/NepFPtsQS6FBoVfTQIeZ0rhcr6b1uKVTOIqitiq/vJh195mLPPztLvO/61NV7Nppb3V93Olb3M33dwunanIKilh7RF1Fc7MdpmiuxEWv487uEax7aiBPRLfE292F3WcuccenMUz5dhdnLlS+jPO9Ncf4Ny4NH3cXPr23G97u9n0zEBHozQ+TevO/u7o45Ko5UbtJMlJDCcXd78L97VNXYeoG6arXsfpgEr/srf50jaIofLDmGK8W70tyf98mvH2H8+1pUJqHqwvjeqtN0Ob9E6cmaxbWiyRn5PF98V43j17reKMipb1wUxt8il/4ftxVsu9IXEoW9y/cTl6hkYGt6jPr9g4OvSri5uKpmt8snKr5+0gyeYVGGtfzpp2G+ySZeLu78lh0C9Y/NZBR3SPQ6dRamOj3N/D6ykOk55S/E/dfh5L4dL06lfjWiI42rT8TwhE576uOgzAVr9pziWTpbpAzfzlYrW6Qpj0N/rdWbWz05HUteenmNrXiHdE9vRrj6abnwPkMtsZdKNmTpoojI59vjKOgyEi3xnVr1GTKHkL8PM3TSG/+cYT03EKSM/MYO38bF3MK6djQn4/v7oqbgyeY17cLwVWv43BCBrEpVV8qaxpJuamD7VfRWCLYz5O3RnTk90f70a9FEAUGI/P+OcmAd9exYPPJkilE1P2rpv2wB4D7+kRyc0fH2GpBCHty7L9QTsC0L0B4gH1XnDw8qBntwv24lFPIC8st27yryGDkqWV7zZvevXJLOx4Z3MKh/pjXRKCPO3d0Vee8f1m3CXLTwMUdQivfWfdCVj7fblWLXyvbu8NRjO/bhGb1fbiQXcDrKw8xfsF2zl3MJbKeN/Pv64GPE9T+BHiXmqqp4uhIdn4Rfx9RV9HYqtFZTbUJ8+Or+3uyYHwPWgTX4VJOIa/8eojrP9jI6oOJ5BUamPztTjLyiugcEeCQHY6FsAdJRmrINDJir5oRE1M3SDcXHWsOJZmXoFYmr9DApG928dOu87jodXwwqhPj+kTaNlgNmHbzzYrbpt4R2lHdgbcSX2w6SW6hgY4N/RnQsr4tQ7Qad1c9r96qJlo/7DjHwfgMguq4s+j+ngTVqfxndhSmZblVXeJrmqKJdJApmivR6XQMahXMH4/14/Xb2hNUx52Tqdk89PVOBryzjgPnM6jr7cbH93S1eRG8EI5KfvNryFQzEmanmpHSSneDnPnzQZIyKp6uycovYvyC7WozJVc9n93bjdu61M6q+Wb16xDdJpguerWVe1XqRS7lFPBV8WjR1EHOMSpi0rd5kHmJrLe7C/Pv60Hjej4aR2WZIW1DcXPRcSQxkxPJmZUeb15FY4dGZ9bg6qLnnqjGrHtqIFMGNcPDVU9SRj46Hcy+qwsN7PyGRghHIslIDRiMCknFy2vtPTJiMmlAMzo08Ccjr4jnf7ry6pq07ALunvcvMXEXqOPhyqLxPYluG2LnaO1rwjVN6axXiwKzgjpXevz8zafILjDQOtSX65zwuXnl1naM7tmIRff3pGPDAK3DsZi/txvXFE/VrNxX8S7VWflFrDta3Oisg3PVWPh6uvH0kNb8/dRAJvZrwgcjOzvNKJwQtiLJSA0kZ+ZhMCq46nWaDYe7uqira9xd9Kw9ksyPu/47XZOQnsvIz2LYdy6dut5uLJ4Y5fCFmdbQq5EP7fWnAPgxKbTCYzPyCllQ3Eb+kWuds34mqI4Hs27v4LBLkavipo5V26tm7eEk8ouMNA3yoU2Y9m3tq6NBgBcv3NSW4V1kIzohJBmpgfjiKZpQf09cNFyF0jLEl8evU6drXvn1IAnFvU8ATqVmM+LTGE4kZxHm78nSSb2d8l1zdeiSDuJGERcUXz7aXUR+0ZXbdH+15RSZeUU0D67DDe0rTlyE7VzXNgQ3Fx3HkrI4nnTlqRpnm6IRQlRMkpEaMHVfDdd451OAB/s1pVNEAJl5RTz3ozpdcyg+gxFzYzh/KZcmQT4sndSb5sHO+S6yWoqbnR3RtyA1u4Cf95T/bjs7v4gvN6mjIlMHNa8Vy5udlb+XG/1bqFMWVypkzcwrZP2xFMA+e9EIIWxPkpEaMI1AhNl5WW95XF30vHdnR9xd9Ww4lsKrvx3irs9jSM3Kp02YHz881JuGdb21DtO+ipuduTfuAcCX/5wst6bmm39PczGnkMh63pp28RQq86qaKyzxXXs4mYIiI83q+9DKAXYeFkLUnCQjNWAaGbFnw7OKNA/25cni3VwXbD5FRl4R3RvX5fsHe1Hf13mWeFpN8chI2x7X4u3uwtGkTP45nlrmkNwCA/P+iQPg4UHNnbr7bG0R3TYEdxc9x5OzOFbOVI1pxOSmjtrsRSOEsD75y1sD8Ro1PKvIA/2a0rVRAAADWtbn6wlR+Htdhbtv5qRBmppk+DTpycjuEYDaR6S077adITWrgIZ1vbhNCgkdgp+nG/1bqqtqLm8Pn5lXyIajxVM0DtroTAhhOUlGasDc8MxBRkZA3bDr6wlRLBzfgy/GdcfL3Tk3vKsxUwv4wGbgHcj9fZug18HGYykcTVTfbecVGvhso7r0d/LAZg7fMv1qUjJVE19mau2vw0kUGIw0D65DyxDZv0WI2kL++taAI9WMlObj4crAVsFX94vrZZvjNarnzZB26iqZLzepIybLdp4jKSOfMH9P2TLdwUS3CcHdVU9sSjZHS03VmFfRONheNEKImqnWq9XHH39MZGQknp6eREVFsW3btio97vvvv0en0zF8+PDqXNah5BUaSM0qABxrZEQUK64XKb053gP9mgKwYnc88ZdyzbukPtS/KR6uV+kIkoPy9XQzNwIzJSDpuYVsPKbW/MgqGiFqF4uTkSVLljBt2jRmzpzJrl276NSpE0OGDCE5ObnCx506dYqnnnqKfv36VTtYR5JYPEXj6aYnwPsqrMlwZIpSMk3TsJv57m6N69KlUQAFBiPjF2zn/KVcgup4cFfPRhoFKipyc6lVNYqi8NchdYqmZUgdWsoqGiFqFYuTkffff5+JEycyfvx42rZty9y5c/H29mb+/PlXfIzBYOCee+7hlVdeoWnTpjUK2FHEp5uKV71kuNjRpMVB7kVw8YCQDmW+NbF4dMQ09P9Q/6Z4usmoiCMaXDxVE5eazeGEzJJVNE7W/l0IUTmLkpGCggJ27txJdHR0yQn0eqKjo4mJibni41599VWCg4OZMGFCla6Tn59PRkZGmQ9Hk+BADc/EZUz1ImEdwdW9zLeubxtCw7rqv1mgjzv39JJREUdVx8OVQa3UqZrvtp3hn+OmRmfSIVeI2saiZCQ1NRWDwUBISNlNxEJCQkhMLH9jq02bNvHll18yb968Kl9n1qxZ+Pv7mz8iIiIsCdMuzMWrGuzWKypRTr2IiauLniei1V4sT1zXEm93V3tGJixk2qvmm62nKTQotA71vbq6CAtxlbDpcovMzEzGjBnDvHnzCAoKqvLjpk+fTnp6uvnj7NmzNoyyes6bGp7Jtt+O57KVNJe7o1tDDr86lDG9GtsxKFEdg1sH4+Gqx7S6V3qLCFE7WfS2MCgoCBcXF5KSksrcn5SURGjof4dOY2NjOXXqFMOGDTPfZzQa1Qu7unL06FGaNWv2n8d5eHjg4eHYHUNNIyMNHGxZ71WvMA8S96u3G3S74mFXbf8VJ+Pj4cqgVsGsOqiOvN4oq2iEqJUsGhlxd3enW7durF271nyf0Whk7dq19O7d+z/Ht27dmv3797Nnzx7zxy233MKgQYPYs2ePQ06/VFWCg7WCF8US94OxELzrQd1IraMRVnBrZ3Wqpl24H83qS6MzIWojiyfMp02bxrhx4+jevTs9e/Zk9uzZZGdnM378eADGjh1LgwYNmDVrFp6enrRv377M4wMCAgD+c7+zKVlNIyMjDqV0vYiscqoVhrYPZc7dXejYIEDrUIQQNmJxMjJq1ChSUlKYMWMGiYmJdO7cmVWrVpmLWs+cOYNeX7s7f2bmFZKZVwTIyIjDqaReRDgfnU7HzR1lOa8QtVm1lhJMnTqVqVOnlvu99evXV/jYhQsXVueSDsW0J42/lxs+HrIaw6GYR0auXC8ihBDCsdTuIQwbMe3WK8t6HUx2Klw8pd6WZEQIIZyGJCPVYN6tV5b1OhZTC/h6LcArQNNQhBBCVJ0kI9UgIyMOSupFhBDCKUkyUg3xl2RkxCFJvYgQQjglSUaqIUGW9Toeo7HUTr0yMiKEEM5EkpFqMNWMyLJeB5IWC3np4OoJIc7dw0YIIa42koxYSFEUc82I7NjrQMw79XYCFzdtYxFCCGERSUYslJZdQH6Rur9OiL9j759zValgp14hhBCOTZIRC5mmaOr7euDhKputOQzzShopXhVCCGcjyYiFSqZopHjVYRTmQtIB9baMjAghhNORZMRCUrzqgBL2gbEIfOpDQCOtoxFCCGEhSUYsZG54Jst6HYfs1CuEEE5NkhELxRePjDSQhmeOQ+pFhBDCqUkyYqEEcyt4SUYchqykEUIIpybJiIXMNSMyTeMYslLg0hlABw26ah2NEEKIapBkxAIGo0JiRvG+NDIy4hhMoyJBLcHTX9tYhBBCVIskIxZIzszDYFRw1euo7ysNzxyC7EcjhBBOT5IRC5h26w3x88RFL6s2HMI52alXCCGcnSQjFpDdeh2M0Qjnd6m3ZWRECCGcliQjFoiXlTSO5cIJyE8HVy8Ibqd1NEIIIapJkhELmKZpwqXHiGMwFa+GdwYXV01DEUIIUX2SjFhApmkcjNSLCCFErSDJiAVkXxoHYxoZkXoRIYRwapKMWKCkZkRGRjRXmAtJB9XbMjIihBBOTZKRKsovMpCaVQDIvjQOIWFv8U69weAfoXU0QgghakCSkSpKLJ6i8XTTE+DtpnE0omRzPNmpVwghnJ0kI1VkXknj74VOXvy0d16KV4UQoraQZKSKzPUispLGMZyTNvBCCFFbSDJSRaZlvbKSxgFkJUN68U694bJTrxBCODvpFFVF8enS8KxKFAUyEyHpACTug8T96kd2CnS8CwY8Cz71anYNU71I/Vbg6VfzmIUQQmhKkpEqSiiepgmXZb0lDEVw4XhxwrEPEg+ot3NSyz9+22ew93vo/xREPQSu1dz52FwvIlM0QghRG0gyUkWmAtawq3VkJC9d7ethGulI3A/Jh8GQ/99jdS4Q1BJC20NoB/XDaIC1r6iPW/MSbP8Col+GdrdZvhrGvJJGileFEKI2kGSkiuLTr7KREUWBE3/BrkWQsA8unS7/OHffkqQjpPhzcBtwKydpa3Yt7P0O1v6fer5l4+HfT2HI6xDRs2pxGY0Qv1u9LSMjQghRK0gyUgVZ+UVk5hUBV8nISOJ++PNFiFtf9n7/iJKEI7SDmoQERIK+inXQehfocq86GrLlI9j8Pzi3Db68Tr0v+mWoG1nxOVKPQX4GuHlDcFvLfzYhhBAOR5KRKjDVi/h5ulLHoxY/ZRkJsO412P0toICLO/SYCK2GqkmId6B1ruPuAwOfg67jSq53cDkcWQlRk6Dfk+AVUP5jTfUiYZ1lp14hhKgl5K95FZw3Fa/W1lGRguySkYrCHPW+qo5U1IRfGNz6sZqAmEZitnwIu7+BgdOh+3hwuazbrdSLCCFErSN9RqqgZLfeWlYvYjSoL/wfdYP1s9REpGEPmLAG7lxo20SktNAOMGYF3L0UglpBbhr88TR80huO/K7Wr5jIShohhKh1ZGSkChJq48hI3Ab48wW1PgQgoHH1V7dYg04HLa9Xi1x3LYJ1b6jLhr8fDZH94PrX1BU6SYfU46XzqhBC1BqSjFRBrWp4lnJMXVp7bJX6tYd/zft+WJOLK/SYAB3uhE3vQ8wncOof+HwgNOkHigHqhIJfA60jFUIIYSWSjFRBSSt4J56myU5Vp2J2LFBf0PWu0H2CdTqi2oKnnzpS0/1+WPsq7F8KJzeq35OdeoUQolaRZKQKzA3PnHFfmsI82Pop/PO+uiQWoNVNcN2rENRc29iqIqAR3PEFRE1Wp5XOxEDLoVpHJYQQwookGamEoijmHXsbONM0jaLAgR/hr1eKN5UDwjrB9a+r0x3OpmE3GP8H5FwAnyCtoxFCCGFFkoxU4mJOIflFRgBC/B2gpqIqkg7BL1Ph/E71a78GMHgGdBhZ9QZljkink0RECCFqIUlGKmEaFQmq44GHq4vG0VRBWhx8dYu6S657Hbjmceg1Bdy9tY5MCCGEKJckI5WINy/rdYLi1awU+OYONREJ7Qj3LAPfEK2jEkIIISrkxGP29mFqeBbu6MWr+VmweKQ6MhLQWBIRIYQQTkOSkUqYdusNc+SREUMhLL0P4neBdz249ydJRIQQQjgNSUYqkXDJwUdGFAV+fQxOrFF3sr37B+dYsiuEEEIUk2SkEqaaEYcdGfn7NdjzLehc1P1kpE26EEIIJyPJSCVKNslzwJGR7V/AP++qt4f9D1oO0TYeIYQQohokGamAwaiQmKEmIw7X8Ozwr7DyKfX2oBeg6xht4xFCCCGqSZKRCqRk5mMwKrjqddT3daCGZ6djYNkEQIFu46H/01pHJIQQQlSbJCMVOF9cLxLi54mL3kE2Zks+At+NAkO+usfMTe/JpnFCCCGcmiQjFXC43XrTz6tNzfLSISIKRnwJeifoCiuEEEJUQJKRCpiX9TpCvUjuJfh2BGScg6CWMPp7cHOAuIQQQogakmSkAg7T8KwwD76/B5IPgW8Y3PsjeAdqG5MQQghhJdVKRj7++GMiIyPx9PQkKiqKbdu2XfHYefPm0a9fP+rWrUvdunWJjo6u8HhHYt6XRstlvUYjLH8ITm8CDz+1zXtAI+3iEUIIIazM4mRkyZIlTJs2jZkzZ7Jr1y46derEkCFDSE5OLvf49evXM3r0aNatW0dMTAwRERFcf/31nD9/vsbB21pJjxGNRkYUBVZPh0MrwMUd7voWQttrE4sQQghhIzpFURRLHhAVFUWPHj2YM2cOAEajkYiICB555BGee+65Sh9vMBioW7cuc+bMYezYsVW6ZkZGBv7+/qSnp+Pn52dJuDXS/bW/SM3K57dHrqF9A3+7Xdds02z4a6Z6e8R8aH+H/WMQQgghqqmqr98WjYwUFBSwc+dOoqOjS06g1xMdHU1MTEyVzpGTk0NhYSGBgVeuecjPzycjI6PMh73lFxlIzcoHNCpg3ft9SSIyZJYkIkIIIWoti5KR1NRUDAYDISFld4QNCQkhMTGxSud49tlnCQ8PL5PQXG7WrFn4+/ubPyIiIiwJ0yoSi6doPFz11PV2s+/FT/wFP09Rb/eeCr0ftu/1hRBCCDuy62qaN998k++//57ly5fj6XnlOozp06eTnp5u/jh79qwdo1TFl1rWq7NnU7H43bBkLBiLoMOdcN3/2e/aQgghhAZcLTk4KCgIFxcXkpKSytyflJREaGhohY999913efPNN/nrr7/o2LFjhcd6eHjg4aFt+3VTw7PwqizrzUyCY6tAMdTsokYDbHgLCrOhyQC49RPQy+prIYQQtZtFyYi7uzvdunVj7dq1DB8+HFALWNeuXcvUqVOv+Li3336b119/ndWrV9O9u3NscW/Rbr0rJkPsWutdPLQDjPoGXN2td04hhBDCQVmUjABMmzaNcePG0b17d3r27Mns2bPJzs5m/PjxAIwdO5YGDRowa9YsAN566y1mzJjB4sWLiYyMNNeW1KlThzp16ljxR7Gu8+YeI5WMjORnwsmN6u2WN9S8PbtvKPR/Bjztt2pICCGE0JLFycioUaNISUlhxowZJCYm0rlzZ1atWmUuaj1z5gz6UlMLn376KQUFBYwYMaLMeWbOnMnLL79cs+htKOGSqftqJSMjJzeCsRDqNoG7v7dDZEIIIUTtYnEyAjB16tQrTsusX7++zNenTp2qziU0Z5qmqXRZ74m/1M/Nr7w6SAghhBBXJtWRVxBflWkaRZFkRAghhKghSUbKkZVfREZeEVDJNE3qcbh0Rm3V3qSfnaITQgghahdJRsphqhfx9XSljkcFM1mmUZHGfcDdxw6RCSGEELWPJCPliDfVi1S2rFemaIQQQogak2SkHKaRkQobnhXkwKlN6u3m19khKiGEEKJ2kmSkHKaRkQrrRU5vBkM++DWE+q3sFJkQQghR+0gyUo4qraQxT9EMBnvuXSOEEELUMpKMlMO0L02FreCPr1E/t5ApGiGEEKImJBkpR8KlShqepcVBWizoXaFJfztGJoQQQtQ+koxcRlEU4ivbsfdE8aZ4EVHg6W+nyIQQQojaSZKRy1zMKSSv0AhA6JVqRmRJrxBCCGE1koxcxlS8GlTHHQ/XcnbgLcov2aVXkhEhhBCixiQZuUylG+SdiYHCHKgTAqEd7BiZEEIIUTtJMnKZkpU0V5iiMa2iaR4tS3qFEEIIK5Bk5DLnL1WyrNdUvNp8sJ0iEkIIIWo3SUYuU7Kst5yRkfRzkHIYdHpoOsjOkQkhhBC1kyQjl0kwL+stZ2TEtIqmQXfwDrRjVEIIIUTtJcnIZeKLR0bKnaaRJb1CCCGE1UkyUorBqJCYcYVpGkMhxG1Qb0syIoQQQliNJCOlpGTmYzAquOh1BPteloyc3Qb5GeBdD8K7aBOgEEIIUQtJMlKKqQ18iK8HLvrLlu2apmiaXQt6edqEEEIIa5FX1VIq3CBP6kWEEEIIm5BkpBRTK/iwy5ORzCRI3Kfebib9RYQQQghrkmSkFPNuvZd3X40tbnQW1hnq1LdvUEIIIUQtJ8lIKQnmZb2XJSMyRSOEEELYjCQjpZTb8MxogNi/1dstrtMgKiGEEKJ2k2SklPPlFbCe3wW5F8HDX+28KoQQQgirkmSkWH6RgdSsfOCyaRrzkt6B4OJq/8CEEEKIWk6SkWJJ6Woi4uGqJ9DHveQbJ9aon5vLFI0QQghhC5KMFIsvVS+i0xU3PMu+oE7TADSXJb1CCCGELUgyUsxUvFpmiiZuHaBAcDvwC9cmMCGEEKKWk2SkWLm79R4vnqJpIUt6hRBCCFuRZKSYqfuqebdeo7Gk2Zn0FxFCCCFsRpKRYgnply3rTdwH2SngXgciemkYmRBCCFG7STJSzLwvjalmxLSKpskAcHW/wqOEEEIIUVOSjBQrmaYpHhk5YZqikVU0QgghhC1JMgJk5xeRkVcEFI+M5F6Cs9vUb0q9iBBCCGFTkoxQsqzX19MVX083iFsPigGCWkLdxtoGJ4QQQtRykoxQsqw33LSsV3bpFUIIIexGkhFKFa8GeIKiSL2IEEIIYUeSjADx6aUaniUfgsx4cPWExn01jkwIIYSo/SQZARJMK2n8PUumaCL7gZtXBY8SQgghhDVIMsJlDc+kXkQIIYSwK0lGKKkZaeBTBKdj1DslGRFCCCHs4qpPRhRFIb54aW+TzF1gLIS6kVCvmbaBCSGEEFeJqz4ZuZRTSF6hEYB6Cf+odzaPBp1Ow6iEEEKIq8dVn4yYRkWCfNxwjZN6ESGEEMLeJBkpbnjW3TcNLp0BF3d1JY0QQggh7OKqT0ZMreAHuuxV72jUGzzqaBiREEIIcXW56pMR88hI4U71DpmiEUIIIezqqk9GEtJz8aCAyKw96h0trtM0HiGEEOJqc9UnI/GXcumlP4yrMR/8GkD91lqHJIQQQlxVJBm5lMdA/R71i+aDZUmvEEIIYWdXdTJiMCokZeTRX79PvaO5TNEIIYQQ9nZVJyOpWfmEKYk00yeg6Fyg6QCtQxJCCCGuOld1MnL+Ui4DikdFdBFR4OmvcURCCCHE1adaycjHH39MZGQknp6eREVFsW3btgqPX7p0Ka1bt8bT05MOHTrw+++/VytYa0u4lMcAfXF/kRaypFcIIYTQgsXJyJIlS5g2bRozZ85k165ddOrUiSFDhpCcnFzu8Vu2bGH06NFMmDCB3bt3M3z4cIYPH86BAwdqHHxNJV1Mp4/+oPqF9BcRQgghNKFTFEWx5AFRUVH06NGDOXPmAGA0GomIiOCRRx7hueee+8/xo0aNIjs7m99++818X69evejcuTNz586t0jUzMjLw9/cnPT0dPz8/S8Kt0NffLmLM8UfJcgukzvRY0F/Vs1ZCCCGEVVX19duiV9+CggJ27txJdHTJKIJeryc6OpqYmJhyHxMTE1PmeIAhQ4Zc8XiA/Px8MjIyynzYQmjKJgASg/pKIiKEEEJoxKJX4NTUVAwGAyEhIWXuDwkJITExsdzHJCYmWnQ8wKxZs/D39zd/REREWBJmlbXI3ApAdqNBNjm/EEIIISrnkMMB06dPJz093fxx9uxZ619EUYjvOJW99W4ksMP11j+/EEIIIarE1ZKDg4KCcHFxISkpqcz9SUlJhIaGlvuY0NBQi44H8PDwwMPDw5LQLKfT0efWB4EHbXsdIYQQQlTIopERd3d3unXrxtq1a833GY1G1q5dS+/evct9TO/evcscD7BmzZorHi+EEEKIq4tFIyMA06ZNY9y4cXTv3p2ePXsye/ZssrOzGT9+PABjx46lQYMGzJo1C4DHHnuMAQMG8N5773HTTTfx/fffs2PHDj7//HPr/iRCCCGEcEoWJyOjRo0iJSWFGTNmkJiYSOfOnVm1apW5SPXMmTPoS61M6dOnD4sXL+bFF1/k+eefp0WLFqxYsYL27dtb76cQQgghhNOyuM+IFmzVZ0QIIYQQtmOTPiNCCCGEENYmyYgQQgghNCXJiBBCCCE0JcmIEEIIITQlyYgQQgghNCXJiBBCCCE0JcmIEEIIITQlyYgQQgghNCXJiBBCCCE0ZXE7eC2YmsRmZGRoHIkQQgghqsr0ul1Zs3enSEYyMzMBiIiI0DgSIYQQQlgqMzMTf3//K37fKfamMRqNxMfH4+vri06ns9p5MzIyiIiI4OzZs7LnjQ3J82w/8lzbhzzP9iHPs33Y8nlWFIXMzEzCw8PLbKJ7OacYGdHr9TRs2NBm5/fz85NfdDuQ59l+5Lm2D3me7UOeZ/uw1fNc0YiIiRSwCiGEEEJTkowIIYQQQlNXdTLi4eHBzJkz8fDw0DqUWk2eZ/uR59o+5Hm2D3me7cMRnmenKGAVQgghRO11VY+MCCGEEEJ7kowIIYQQQlOSjAghhBBCU5KMCCGEEEJTV3Uy8vHHHxMZGYmnpydRUVFs27ZN65BqlZdffhmdTlfmo3Xr1lqH5fQ2btzIsGHDCA8PR6fTsWLFijLfVxSFGTNmEBYWhpeXF9HR0Rw/flybYJ1cZc/1fffd95/f8aFDh2oTrJOaNWsWPXr0wNfXl+DgYIYPH87Ro0fLHJOXl8eUKVOoV68ederU4Y477iApKUmjiJ1TVZ7ngQMH/uf3edKkSXaJ76pNRpYsWcK0adOYOXMmu3btolOnTgwZMoTk5GStQ6tV2rVrR0JCgvlj06ZNWofk9LKzs+nUqRMff/xxud9/++23+fDDD5k7dy5bt27Fx8eHIUOGkJeXZ+dInV9lzzXA0KFDy/yOf/fdd3aM0Plt2LCBKVOm8O+//7JmzRoKCwu5/vrryc7ONh/zxBNP8Ouvv7J06VI2bNhAfHw8t99+u4ZRO5+qPM8AEydOLPP7/Pbbb9snQOUq1bNnT2XKlCnmrw0GgxIeHq7MmjVLw6hql5kzZyqdOnXSOoxaDVCWL19u/tpoNCqhoaHKO++8Y77v0qVLioeHh/Ldd99pEGHtcflzrSiKMm7cOOXWW2/VJJ7aKjk5WQGUDRs2KIqi/v66ubkpS5cuNR9z+PBhBVBiYmK0CtPpXf48K4qiDBgwQHnsscc0ieeqHBkpKChg586dREdHm+/T6/VER0cTExOjYWS1z/HjxwkPD6dp06bcc889nDlzRuuQarWTJ0+SmJhY5nfb39+fqKgo+d22kfXr1xMcHEyrVq2YPHkyFy5c0Dokp5aeng5AYGAgADt37qSwsLDM73Tr1q1p1KiR/E7XwOXPs8m3335LUFAQ7du3Z/r06eTk5NglHqfYKM/aUlNTMRgMhISElLk/JCSEI0eOaBRV7RMVFcXChQtp1aoVCQkJvPLKK/Tr148DBw7g6+urdXi1UmJiIkC5v9um7wnrGTp0KLfffjtNmjQhNjaW559/nhtuuIGYmBhcXFy0Ds/pGI1GHn/8cfr27Uv79u0B9Xfa3d2dgICAMsfK73T1lfc8A9x99900btyY8PBw9u3bx7PPPsvRo0f56aefbB7TVZmMCPu44YYbzLc7duxIVFQUjRs35ocffmDChAkaRiaEddx1113m2x06dKBjx440a9aM9evXM3jwYA0jc05TpkzhwIEDUltmY1d6nh988EHz7Q4dOhAWFsbgwYOJjY2lWbNmNo3pqpymCQoKwsXF5T/V2ElJSYSGhmoUVe0XEBBAy5YtOXHihNah1Fqm31/53dZG06ZNCQoKkt/xapg6dSq//fYb69ato2HDhub7Q0NDKSgo4NKlS2WOl9/p6rnS81yeqKgoALv8Pl+VyYi7uzvdunVj7dq15vuMRiNr166ld+/eGkZWu2VlZREbG0tYWJjWodRaTZo0ITQ0tMzvdkZGBlu3bpXfbTs4d+4cFy5ckN9xCyiKwtSpU1m+fDl///03TZo0KfP9bt264ebmVuZ3+ujRo5w5c0Z+py1Q2fNcnj179gDY5ff5qp2mmTZtGuPGjaN79+707NmT2bNnk52dzfjx47UOrdZ46qmnGDZsGI0bNyY+Pp6ZM2fi4uLC6NGjtQ7NqWVlZZV5p3Ly5En27NlDYGAgjRo14vHHH+e1116jRYsWNGnShJdeeonw8HCGDx+uXdBOqqLnOjAwkFdeeYU77riD0NBQYmNjeeaZZ2jevDlDhgzRMGrnMmXKFBYvXszPP/+Mr6+vuQ7E398fLy8v/P39mTBhAtOmTSMwMBA/Pz8eeeQRevfuTa9evTSO3nlU9jzHxsayePFibrzxRurVq8e+fft44okn6N+/Px07drR9gJqs4XEQH330kdKoUSPF3d1d6dmzp/Lvv/9qHVKtMmrUKCUsLExxd3dXGjRooIwaNUo5ceKE1mE5vXXr1inAfz7GjRunKIq6vPell15SQkJCFA8PD2Xw4MHK0aNHtQ3aSVX0XOfk5CjXX3+9Ur9+fcXNzU1p3LixMnHiRCUxMVHrsJ1Kec8voCxYsMB8TG5urvLwww8rdevWVby9vZXbbrtNSUhI0C5oJ1TZ83zmzBmlf//+SmBgoOLh4aE0b95cefrpp5X09HS7xKcrDlIIIYQQQhNXZc2IEEIIIRyHJCNCCCGE0JQkI0IIIYTQlCQjQgghhNCUJCNCCCGE0JQkI0IIIYTQlCQjQgghhNCUJCNCCCGE0JQkI0IIIYTQlCQjQgghhNCUJCNCCCGE0JQkI0IIIYTQ1P8DDRkN2WT01rEAAAAASUVORK5CYII=", "text/plain": [ "
" ] @@ -222,14 +291,12 @@ ], "source": [ "from matplotlib import pyplot as plt\n", - "picker.metrics.to_pandas()['score'].plot(label=\"vw\")\n", "random_picker.metrics.to_pandas()['score'].plot(label=\"random\")\n", "pytorch_picker.metrics.to_pandas()['score'].plot(label=\"pytorch\")\n", "\n", "plt.legend()\n", "\n", "print(f\"The final average score for the default policy, calculated over a rolling window, is: {pytorch_picker.metrics.to_pandas()['score'].iloc[-1]}\")\n", - "print(f\"The final average score for the default policy, calculated over a rolling window, is: {picker.metrics.to_pandas()['score'].iloc[-1]}\")\n", "print(f\"The final average score for the random policy, calculated over a rolling window, is: {random_picker.metrics.to_pandas()['score'].iloc[-1]}\")\n" ] } diff --git a/src/learn_to_pick/pytorch/feature_embedder.py b/src/learn_to_pick/pytorch/feature_embedder.py index ed39fcd..7014c92 100644 --- a/src/learn_to_pick/pytorch/feature_embedder.py +++ b/src/learn_to_pick/pytorch/feature_embedder.py @@ -39,13 +39,13 @@ def format( if len(context_featurized.dense) > 0: raise NotImplementedError( - "pytorch policy doesn't support context with dense feature" + "pytorch policy doesn't support context with dense features" ) for action_featurized in actions_featurized: if len(action_featurized.dense) > 0: raise NotImplementedError( - "pytorch policy doesn't support action with dense feature" + "pytorch policy doesn't support action with dense features" ) context_sparse = self.encode( diff --git a/src/learn_to_pick/pytorch/policy.py b/src/learn_to_pick/pytorch/policy.py index 606df93..6848e47 100644 --- a/src/learn_to_pick/pytorch/policy.py +++ b/src/learn_to_pick/pytorch/policy.py @@ -4,7 +4,7 @@ from learn_to_pick.pytorch.feature_embedder import PyTorchFeatureEmbedder import torch import os -from typing import Any, Optional, PathLike, TypeVar, Union +from typing import Any, Optional, TypeVar, Union TEvent = TypeVar("TEvent", bound=base.Event) @@ -55,7 +55,7 @@ def learn(self, event: TEvent) -> None: def log(self, event): pass - def save(self, path: Optional[Union[str, PathLike]]) -> None: + def save(self, path: Optional[Union[str, os.PathLike]]) -> None: state = { "workspace_state_dict": self.workspace.state_dict(), "optimizer_state_dict": self.workspace.optim.state_dict(), @@ -69,7 +69,7 @@ def save(self, path: Optional[Union[str, PathLike]]) -> None: os.makedirs(dir, exist_ok=True) torch.save(state, path) - def load(self, path: Optional[Union[str, PathLike]]) -> None: + def load(self, path: Optional[Union[str, os.PathLike]]) -> None: import parameterfree if os.path.exists(path): From d75f88aa0c4e859bd32b1864a76d84595897c95b Mon Sep 17 00:00:00 2001 From: cheng Date: Tue, 28 Nov 2023 21:40:36 +0000 Subject: [PATCH 14/16] rename notebook --- ...pynb => news_recommendation_pytorch.ipynb} | 91 +------------------ 1 file changed, 2 insertions(+), 89 deletions(-) rename notebooks/{news_recommendation_byom.ipynb => news_recommendation_pytorch.ipynb} (79%) diff --git a/notebooks/news_recommendation_byom.ipynb b/notebooks/news_recommendation_pytorch.ipynb similarity index 79% rename from notebooks/news_recommendation_byom.ipynb rename to notebooks/news_recommendation_pytorch.ipynb index 6f8c45e..28b943b 100644 --- a/notebooks/news_recommendation_byom.ipynb +++ b/notebooks/news_recommendation_pytorch.ipynb @@ -21,96 +21,9 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "huggingface/tokenizers: The current process just got forked, after parallelism has already been used. Disabling parallelism to avoid deadlocks...\n", - "To disable this warning, you can either:\n", - "\t- Avoid using `tokenizers` before the fork if possible\n", - "\t- Explicitly set the environment variable TOKENIZERS_PARALLELISM=(true | false)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Processing /home/chetan/dev/learn_to_pick\n", - " Preparing metadata (setup.py) ... \u001b[?25ldone\n", - "\u001b[?25hRequirement already satisfied: numpy>=1.24.4 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from learn-to-pick==0.0.3) (1.26.1)\n", - "Requirement already satisfied: pandas>=2.0.3 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from learn-to-pick==0.0.3) (2.1.1)\n", - "Requirement already satisfied: vowpal-wabbit-next==0.7.0 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from learn-to-pick==0.0.3) (0.7.0)\n", - "Requirement already satisfied: sentence-transformers>=2.2.2 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from learn-to-pick==0.0.3) (2.2.2)\n", - "Requirement already satisfied: torch in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from learn-to-pick==0.0.3) (2.0.1)\n", - "Requirement already satisfied: pyskiplist in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from learn-to-pick==0.0.3) (1.0.0)\n", - "Requirement already satisfied: parameterfree in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from learn-to-pick==0.0.3) (0.0.1)\n", - "Requirement already satisfied: python-dateutil>=2.8.2 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from pandas>=2.0.3->learn-to-pick==0.0.3) (2.8.2)\n", - "Requirement already satisfied: pytz>=2020.1 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from pandas>=2.0.3->learn-to-pick==0.0.3) (2023.3.post1)\n", - "Requirement already satisfied: tzdata>=2022.1 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from pandas>=2.0.3->learn-to-pick==0.0.3) (2023.3)\n", - "Requirement already satisfied: transformers<5.0.0,>=4.6.0 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from sentence-transformers>=2.2.2->learn-to-pick==0.0.3) (4.34.1)\n", - "Requirement already satisfied: tqdm in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from sentence-transformers>=2.2.2->learn-to-pick==0.0.3) (4.66.1)\n", - "Requirement already satisfied: torchvision in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from sentence-transformers>=2.2.2->learn-to-pick==0.0.3) (0.15.2)\n", - "Requirement already satisfied: scikit-learn in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from sentence-transformers>=2.2.2->learn-to-pick==0.0.3) (1.3.2)\n", - "Requirement already satisfied: scipy in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from sentence-transformers>=2.2.2->learn-to-pick==0.0.3) (1.11.3)\n", - "Requirement already satisfied: nltk in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from sentence-transformers>=2.2.2->learn-to-pick==0.0.3) (3.8.1)\n", - "Requirement already satisfied: sentencepiece in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from sentence-transformers>=2.2.2->learn-to-pick==0.0.3) (0.1.99)\n", - "Requirement already satisfied: huggingface-hub>=0.4.0 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from sentence-transformers>=2.2.2->learn-to-pick==0.0.3) (0.17.3)\n", - "Requirement already satisfied: filelock in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from torch->learn-to-pick==0.0.3) (3.12.4)\n", - "Requirement already satisfied: typing-extensions in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from torch->learn-to-pick==0.0.3) (4.8.0)\n", - "Requirement already satisfied: sympy in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from torch->learn-to-pick==0.0.3) (1.12)\n", - "Requirement already satisfied: networkx in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from torch->learn-to-pick==0.0.3) (3.2)\n", - "Requirement already satisfied: jinja2 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from torch->learn-to-pick==0.0.3) (3.1.2)\n", - "Requirement already satisfied: nvidia-cuda-nvrtc-cu11==11.7.99 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from torch->learn-to-pick==0.0.3) (11.7.99)\n", - "Requirement already satisfied: nvidia-cuda-runtime-cu11==11.7.99 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from torch->learn-to-pick==0.0.3) (11.7.99)\n", - "Requirement already satisfied: nvidia-cuda-cupti-cu11==11.7.101 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from torch->learn-to-pick==0.0.3) (11.7.101)\n", - "Requirement already satisfied: nvidia-cudnn-cu11==8.5.0.96 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from torch->learn-to-pick==0.0.3) (8.5.0.96)\n", - "Requirement already satisfied: nvidia-cublas-cu11==11.10.3.66 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from torch->learn-to-pick==0.0.3) (11.10.3.66)\n", - "Requirement already satisfied: nvidia-cufft-cu11==10.9.0.58 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from torch->learn-to-pick==0.0.3) (10.9.0.58)\n", - "Requirement already satisfied: nvidia-curand-cu11==10.2.10.91 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from torch->learn-to-pick==0.0.3) (10.2.10.91)\n", - "Requirement already satisfied: nvidia-cusolver-cu11==11.4.0.1 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from torch->learn-to-pick==0.0.3) (11.4.0.1)\n", - "Requirement already satisfied: nvidia-cusparse-cu11==11.7.4.91 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from torch->learn-to-pick==0.0.3) (11.7.4.91)\n", - "Requirement already satisfied: nvidia-nccl-cu11==2.14.3 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from torch->learn-to-pick==0.0.3) (2.14.3)\n", - "Requirement already satisfied: nvidia-nvtx-cu11==11.7.91 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from torch->learn-to-pick==0.0.3) (11.7.91)\n", - "Requirement already satisfied: triton==2.0.0 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from torch->learn-to-pick==0.0.3) (2.0.0)\n", - "Requirement already satisfied: setuptools in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from nvidia-cublas-cu11==11.10.3.66->torch->learn-to-pick==0.0.3) (68.0.0)\n", - "Requirement already satisfied: wheel in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from nvidia-cublas-cu11==11.10.3.66->torch->learn-to-pick==0.0.3) (0.41.2)\n", - "Requirement already satisfied: cmake in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from triton==2.0.0->torch->learn-to-pick==0.0.3) (3.27.7)\n", - "Requirement already satisfied: lit in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from triton==2.0.0->torch->learn-to-pick==0.0.3) (17.0.4)\n", - "Requirement already satisfied: fsspec in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from huggingface-hub>=0.4.0->sentence-transformers>=2.2.2->learn-to-pick==0.0.3) (2023.10.0)\n", - "Requirement already satisfied: requests in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from huggingface-hub>=0.4.0->sentence-transformers>=2.2.2->learn-to-pick==0.0.3) (2.31.0)\n", - "Requirement already satisfied: pyyaml>=5.1 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from huggingface-hub>=0.4.0->sentence-transformers>=2.2.2->learn-to-pick==0.0.3) (6.0.1)\n", - "Requirement already satisfied: packaging>=20.9 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from huggingface-hub>=0.4.0->sentence-transformers>=2.2.2->learn-to-pick==0.0.3) (23.2)\n", - "Requirement already satisfied: six>=1.5 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from python-dateutil>=2.8.2->pandas>=2.0.3->learn-to-pick==0.0.3) (1.16.0)\n", - "Requirement already satisfied: regex!=2019.12.17 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from transformers<5.0.0,>=4.6.0->sentence-transformers>=2.2.2->learn-to-pick==0.0.3) (2023.10.3)\n", - "Requirement already satisfied: tokenizers<0.15,>=0.14 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from transformers<5.0.0,>=4.6.0->sentence-transformers>=2.2.2->learn-to-pick==0.0.3) (0.14.1)\n", - "Requirement already satisfied: safetensors>=0.3.1 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from transformers<5.0.0,>=4.6.0->sentence-transformers>=2.2.2->learn-to-pick==0.0.3) (0.4.0)\n", - "Requirement already satisfied: MarkupSafe>=2.0 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from jinja2->torch->learn-to-pick==0.0.3) (2.1.3)\n", - "Requirement already satisfied: click in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from nltk->sentence-transformers>=2.2.2->learn-to-pick==0.0.3) (8.1.7)\n", - "Requirement already satisfied: joblib in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from nltk->sentence-transformers>=2.2.2->learn-to-pick==0.0.3) (1.3.2)\n", - "Requirement already satisfied: threadpoolctl>=2.0.0 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from scikit-learn->sentence-transformers>=2.2.2->learn-to-pick==0.0.3) (3.2.0)\n", - "Requirement already satisfied: mpmath>=0.19 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from sympy->torch->learn-to-pick==0.0.3) (1.3.0)\n", - "Requirement already satisfied: pillow!=8.3.*,>=5.3.0 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from torchvision->sentence-transformers>=2.2.2->learn-to-pick==0.0.3) (10.1.0)\n", - "Requirement already satisfied: charset-normalizer<4,>=2 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from requests->huggingface-hub>=0.4.0->sentence-transformers>=2.2.2->learn-to-pick==0.0.3) (3.3.1)\n", - "Requirement already satisfied: idna<4,>=2.5 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from requests->huggingface-hub>=0.4.0->sentence-transformers>=2.2.2->learn-to-pick==0.0.3) (3.4)\n", - "Requirement already satisfied: urllib3<3,>=1.21.1 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from requests->huggingface-hub>=0.4.0->sentence-transformers>=2.2.2->learn-to-pick==0.0.3) (2.0.7)\n", - "Requirement already satisfied: certifi>=2017.4.17 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from requests->huggingface-hub>=0.4.0->sentence-transformers>=2.2.2->learn-to-pick==0.0.3) (2023.7.22)\n", - "Building wheels for collected packages: learn-to-pick\n", - " Building wheel for learn-to-pick (setup.py) ... \u001b[?25ldone\n", - "\u001b[?25h Created wheel for learn-to-pick: filename=learn_to_pick-0.0.3-py3-none-any.whl size=31195 sha256=bee6266df7b0bde64de2e58bff8c435340c315aa8fa9cfa3c84751c22a26fab1\n", - " Stored in directory: /tmp/pip-ephem-wheel-cache-zigo2ps9/wheels/18/bf/25/d8dda8a9a6b5284eaed510a4708ef9b22b9894a5e94b329ea2\n", - "Successfully built learn-to-pick\n", - "Installing collected packages: learn-to-pick\n", - " Attempting uninstall: learn-to-pick\n", - " Found existing installation: learn-to-pick 0.0.3\n", - " Uninstalling learn-to-pick-0.0.3:\n", - " Successfully uninstalled learn-to-pick-0.0.3\n", - "Successfully installed learn-to-pick-0.0.3\n" - ] - } - ], + "outputs": [], "source": [ "! pip install ../\n", "# ! pip install matplotlib" From 7f30c8506136d60ece5127f0ecfd09ae9258684e Mon Sep 17 00:00:00 2001 From: cheng Date: Tue, 28 Nov 2023 21:51:53 +0000 Subject: [PATCH 15/16] rename variables --- tests/unit_tests/test_pytorch_model.py | 25 ++++++++++++------------- 1 file changed, 12 insertions(+), 13 deletions(-) diff --git a/tests/unit_tests/test_pytorch_model.py b/tests/unit_tests/test_pytorch_model.py index 0ebfa17..147ec00 100644 --- a/tests/unit_tests/test_pytorch_model.py +++ b/tests/unit_tests/test_pytorch_model.py @@ -102,34 +102,33 @@ def test_save_load(remove_checkpoint): sim1 = Simulator() sim2 = Simulator() - fe = learn_to_pick.PyTorchFeatureEmbedder() first_model_path = f"{CHECKPOINT_DIR}/first.checkpoint" torch.manual_seed(0) - first_byom = learn_to_pick.PyTorchPolicy(feature_embedder=fe) - second_byom = learn_to_pick.PyTorchPolicy(feature_embedder=fe) + first_policy = learn_to_pick.PyTorchPolicy() + other_policy = learn_to_pick.PyTorchPolicy() torch.manual_seed(0) first_picker = learn_to_pick.PickBest.create( - policy=first_byom, selection_scorer=CustomSelectionScorer() + policy=first_policy, selection_scorer=CustomSelectionScorer() ) sim1.run(first_picker, 5) - first_byom.save(first_model_path) + first_policy.save(first_model_path) - second_byom.load(first_model_path) - second_picker = learn_to_pick.PickBest.create( - policy=second_byom, selection_scorer=CustomSelectionScorer() + other_policy.load(first_model_path) + other_picker = learn_to_pick.PickBest.create( + policy=other_policy, selection_scorer=CustomSelectionScorer() ) - sim1.run(second_picker, 5) + sim1.run(other_picker, 5) torch.manual_seed(0) - all_byom = learn_to_pick.PyTorchPolicy(feature_embedder=fe) + all_policy = learn_to_pick.PyTorchPolicy() torch.manual_seed(0) all_picker = learn_to_pick.PickBest.create( - policy=all_byom, selection_scorer=CustomSelectionScorer() + policy=all_policy, selection_scorer=CustomSelectionScorer() ) sim2.run(all_picker, 10) - verify_same_models(second_byom.workspace, all_byom.workspace) - verify_same_optimizers(second_byom.workspace.optim, all_byom.workspace.optim) + verify_same_models(other_policy.workspace, all_policy.workspace) + verify_same_optimizers(other_policy.workspace.optim, all_policy.workspace.optim) From d88ea8eb35bdfc25de1061b7dee103d51cb36487 Mon Sep 17 00:00:00 2001 From: cheng Date: Tue, 28 Nov 2023 22:19:43 +0000 Subject: [PATCH 16/16] update readme --- README.md | 50 ++++++++++++++++++++++++++++++++++++++++++++++---- 1 file changed, 46 insertions(+), 4 deletions(-) diff --git a/README.md b/README.md index 8408944..d141ee9 100644 --- a/README.md +++ b/README.md @@ -29,7 +29,7 @@ Note: all code examples presented here can be found in `notebooks/readme.ipynb` - Use a custom score function to grade the decision. - Directly specify the score manually and asynchronously. -The beauty of `learn_to_pick` is its flexibility. Whether you're a fan of VowpalWabbit or prefer PyTorch (coming soon), the library can seamlessly integrate with both, allowing them to be the brain behind your decisions. +The beauty of `learn_to_pick` is its flexibility. Whether you're a fan of VowpalWabbit or prefer PyTorch, the library can seamlessly integrate with both, allowing them to be the brain behind your decisions. ## Installation @@ -43,6 +43,8 @@ The `PickBest` scenario should be used when: - Only one option is optimal for a specific criteria or context - There exists a mechanism to provide feedback on the suitability of the chosen option for the specific criteria +### Scorer + Example usage with llm default scorer: ```python @@ -113,7 +115,46 @@ dummy_score = 1 picker.update_with_delayed_score(dummy_score, result) ``` -`PickBest` is highly configurable to work with a VowpalWabbit decision making policy, a PyTorch decision making policy (coming soon), or with a custom user defined decision making policy +### Using Pytorch policy + +Example usage with a Pytorch policy: +```python +from learn_to_pick import PyTorchPolicy + +pytorch_picker = learn_to_pick.PickBest.create( + policy=PyTorchPolicy(), selection_scorer=CustomSelectionScorer()) + +pytorch_picker.run( + pick = learn_to_pick.ToSelectFrom(["option1", "option2"]), + criteria = learn_to_pick.BasedOn("some criteria") +) +``` + +Example usage with a custom Pytorch policy: +You can alway create a custom Pytorch policy by implementing the Policy interface + +```python +class CustomPytorchPolicy(Policy): + def __init__(self, **kwargs: Any): + ... + + def predict(self, event: TEvent) -> Any: + ... + + def learn(self, event: TEvent) -> None: + ... + + def log(self, event: TEvent) -> None: + ... + + def save(self) -> None: + ... + +pytorch_picker = learn_to_pick.PickBest.create( + policy=CustomPytorchPolicy(), selection_scorer=CustomSelectionScorer()) +``` + +`PickBest` is highly configurable to work with a VowpalWabbit decision making policy, a PyTorch decision making policy, or with a custom user defined decision making policy The main thing that needs to be decided from the get-go is: @@ -134,7 +175,8 @@ In all three cases, when a score is calculated or provided, the decision making ## Example Notebooks - `readme.ipynb` showcases all examples shown in this README -- `news_recommendation.ipynb` showcases a personalization scenario where we have to pick articles for specific users +- `news_recommendation.ipynb` showcases a personalization scenario where we have to pick articles for specific users with VowpalWabbit policy +- `news_recommendation_pytorch.ipynb` showcases the same personalization scenario where we have to pick articles for specific users with Pytorch policy - `prompt_variable_injection.ipynb` showcases learned prompt variable injection and registering callback functionality ### Advanced Usage @@ -183,7 +225,7 @@ class CustomSelectionScorer(learn_to_pick.SelectionScorer): # inputs: the inputs to the picker in Dict[str, Any] format # picked: the selection that was made by the policy # event: metadata that can be used to determine the score if needed - + # scoring logic goes here dummy_score = 1.0