eval.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "29e8ea56-c3e6-49cf-8e19-276c02e3237d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<torch._C.Generator at 0x7fb92d41d4f0>"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import torch\n",
    "import pickle\n",
    "import os\n",
    "\n",
    "from tqdm.notebook import tqdm\n",
    "\n",
    "ADAPTERS = [{\n",
    "        \"dir\" : \"./open_llama_3b_v2_sft/\",\n",
    "        \"moniker\" : \"pre\"\n",
    "    }, {\n",
    "        \"dir\" : \"./open_llama_3b_v2_sft_full/\",\n",
    "        \"moniker\" : \"sft\"\n",
    "    }, {\n",
    "        \"dir\" : \"./open_llama_3b_v2_sft_plus_dpo/\",\n",
    "        \"moniker\" : \"dpo\",\n",
    "    }, {\n",
    "        \"dir\" : \"./open_llama_3b_v2_sft_plus_dpo_r4\",\n",
    "        \"moniker\" : \"dpo_r4\"\n",
    "}]\n",
    "\n",
    "torch.manual_seed(42)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "530344de",
   "metadata": {},
   "source": [
    "## Generate Evaluation metrics\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "da5c8741",
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import Tuple\n",
    "from peft import AutoPeftModelForCausalLM\n",
    "from transformers import (\n",
    "    BitsAndBytesConfig,\n",
    "    pipeline,\n",
    "    AutoTokenizer\n",
    ")\n",
    "from datasets import load_dataset\n",
    "\n",
    "from reward import get_reward"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "fd6250d4-2855-49d3-ba8e-cdbd4a8c8696",
   "metadata": {},
   "outputs": [],
   "source": [
    "dataset_name = \"samlhuillier/sql-create-context-spider-intersect\"\n",
    "response_template = \"\\n-- Answer:\\n\"\n",
    "def format_prompt(example) -> Tuple[str, str]:\n",
    "    return f\"{example['context']} \\n-- Question: {example['question']}{response_template}\", example['answer']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "5899661b-12d6-478f-b448-14ee27cfbe29",
   "metadata": {},
   "outputs": [],
   "source": [
    "dataset = load_dataset(dataset_name, split=\"validation\").map(lambda example: {\"query\" : format_prompt(example)[0]})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "9955a4f2-a504-43fd-895d-6cb946fb0be9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'answer': 'SELECT count(*) FROM singer',\n",
       " 'db_id': 'concert_singer',\n",
       " 'context': 'CREATE TABLE singer (Id VARCHAR)',\n",
       " 'question': 'How many singers do we have?',\n",
       " 'query': 'CREATE TABLE singer (Id VARCHAR) \\n-- Question: How many singers do we have?\\n-- Answer:\\n'}"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dataset[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "49ce118e-4f2c-46a8-97af-7b29bcec810f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Model from Hugging Face hub\n",
    "base_model = \"openlm-research/open_llama_3b_v2\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "ed209c56-1e8a-4480-af93-bcf68c5d02c5",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "You are using the default legacy behaviour of the <class 'transformers.models.llama.tokenization_llama.LlamaTokenizer'>. This is expected, and simply means that the `legacy` (previous) behavior will be used so nothing changes for you. If you want to use the new behaviour, set `legacy=False`. This should only be set if you understand what it means, and thoroughly read the reason why this was added as explained in https://github.com/huggingface/transformers/pull/24565\n"
     ]
    }
   ],
   "source": [
    "# Load LLaMA tokenizer\n",
    "tokenizer = AutoTokenizer.from_pretrained(base_model, trust_remote_code=True)\n",
    "tokenizer.pad_token = tokenizer.eos_token\n",
    "tokenizer.padding_side = \"left\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "7d864a23-22a4-4a82-85bf-70095c0a9624",
   "metadata": {},
   "outputs": [],
   "source": [
    "def load_model(adapter_dir):\n",
    "    # Load model\n",
    "    quant_config = BitsAndBytesConfig(\n",
    "        load_in_4bit=True,\n",
    "        bnb_4bit_quant_type=\"nf4\",\n",
    "        bnb_4bit_compute_dtype=torch.float16,\n",
    "        bnb_4bit_use_double_quant=False,\n",
    "    )\n",
    "    \n",
    "    dpo_model = AutoPeftModelForCausalLM.from_pretrained(\n",
    "        adapter_dir,\n",
    "        quantization_config=quant_config,\n",
    "        trust_remote_code=True,\n",
    "        is_trainable=True,\n",
    "    )\n",
    "    \n",
    "    dpo_model.config.use_cache = False\n",
    "    dpo_model.config.pretraining_tp = 1\n",
    "    \n",
    "    return dpo_model.merge_and_unload().eval()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "0f009867-be67-4fe4-a44a-196f0adc7fc0",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_logger(quiet=True, outfile=\"eval_out.txt\"):\n",
    "    def log(txt):\n",
    "        with open(outfile, \"a\", encoding=\"utf-8\") as f:\n",
    "            f.write(f\"{txt}\\n\")\n",
    "        if not quiet:\n",
    "            print(txt)\n",
    "    return log"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "6528c076-4997-4067-b4a3-b46004f7dfd4",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_eval_rewards(model, quiet=True, sample_size=-1, logfile=\"eval_out.txt\"):\n",
    "    p = pipeline(task=\"text-generation\", model=model, tokenizer=tokenizer, max_new_tokens=120)\n",
    "    \n",
    "    rewards = []\n",
    "    if sample_size >= 0:\n",
    "        inds = torch.randperm(len(dataset))[:sample_size]\n",
    "        ds = dataset.select(inds)\n",
    "    else:\n",
    "        ds = dataset\n",
    "\n",
    "    log = get_logger(quiet, logfile)\n",
    "    for row in tqdm(ds):\n",
    "        out = p(row[\"query\"])\n",
    "        response = out[0][\"generated_text\"]\n",
    "        \n",
    "        # remove our query, split by newlines\n",
    "        response_lines = response.replace(row[\"query\"], \"\").split(\"\\n\")\n",
    "        model_submission = response_lines[0]\n",
    "        rew = get_reward(row[\"db_id\"], model_submission, row[\"answer\"])\n",
    "        rewards.append(rew)\n",
    "        \n",
    "        log(row[\"query\"])\n",
    "        log(model_submission)\n",
    "        log(\"-------------------------------------------------\")\n",
    "        log(f\"-- Got reward of {rew} against solution:\")\n",
    "        log(row['answer'])\n",
    "        log(\"-------------------------------------------------\")\n",
    "    \n",
    "    return rewards"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "a9c88f11-bd71-4758-966f-21ac2441b768",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Evaluating pre ...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ubuntu/.local/lib/python3.10/site-packages/peft/tuners/lora/bnb.py:229: UserWarning: Merge lora module to 4-bit linear may get different generations due to rounding errors.\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "69a1004efd444a8a97b79ed85e24391a",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/50 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ubuntu/.local/lib/python3.10/site-packages/transformers/generation/utils.py:1518: UserWarning: You have modified the pretrained model configuration to control generation. This is a deprecated strategy to control generation and will be removed soon, in a future version. Please use and modify the model generation configuration (see https://huggingface.co/docs/transformers/generation_strategies#default-text-generation-configuration )\n",
      "  warnings.warn(\n",
      "/home/ubuntu/.local/lib/python3.10/site-packages/transformers/pipelines/base.py:1101: UserWarning: You seem to be using the pipelines sequentially on GPU. In order to maximize efficiency please use a dataset\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Evaluating sft ...\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "b546861f44da49c89c9bd63d9a7f9f87",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/50 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Evaluating dpo ...\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "78d59e9d91b1461a97b61d7d7dbb172f",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/50 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Evaluating dpo_r4 ...\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "4a5b15aee39442deb3475b072a4596a3",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/50 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "\n",
    "if not os.path.isdir(\"eval_results/\"):\n",
    "    os.mkdir(\"eval_results/\")\n",
    "\n",
    "for adapter in ADAPTERS:\n",
    "    moniker = adapter['moniker']\n",
    "    print(\"Evaluating\", moniker, \"...\")\n",
    "    rewards = get_eval_rewards(load_model(adapter[\"dir\"]), \n",
    "                                quiet=True, sample_size=50, \n",
    "                                logfile=f\"eval_results/{moniker}_eval_out.txt\")\n",
    "\n",
    "    with open(f\"eval_results/{adapter['moniker']}_eval_returns.pkl\", \"wb\") as f:\n",
    "        pickle.dump(rewards, f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "dae75730-deab-4a99-80b0-5cbe1e254509",
   "metadata": {},
   "outputs": [],
   "source": [
    "def load_reward(adapter) -> list:\n",
    "    with open(f\"eval_results/{adapter['moniker']}_eval_returns.pkl\", \"rb\") as f:\n",
    "        return pickle.load(f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "ecbf742f-9143-4765-8fdd-e7d806d8183c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Adapter pre got reward tensor(0.5752, dtype=torch.float64) +- tensor(0.2469, dtype=torch.float64)\n",
      "Adapter sft got reward tensor(1.3521, dtype=torch.float64) +- tensor(0.4724, dtype=torch.float64)\n",
      "Adapter dpo got reward tensor(1.4493, dtype=torch.float64) +- tensor(0.4367, dtype=torch.float64)\n",
      "Adapter dpo_r4 got reward tensor(1.4397, dtype=torch.float64) +- tensor(0.4094, dtype=torch.float64)\n"
     ]
    }
   ],
   "source": [
    "for adapter in ADAPTERS:\n",
    "    rews = torch.tensor(load_reward(adapter))\n",
    "    print(f\"Adapter {adapter['moniker']} got reward\", rews.mean(), \"+-\", rews.std())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f96f3d1a-c3f3-4319-bbd3-5829c0d8ee26",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "68363e51",
   "metadata": {},
   "source": [
    "## Post-generation\n",
    "---\n",
    "Run from here if you have the eval metrics pregenerated and available at `eval_results/`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "5026d9d4",
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import pandas as pd\n",
    "\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "id": "9384f1c7",
   "metadata": {},
   "outputs": [],
   "source": [
    "def load_eval_outs(moniker: str, delim = \"---\") -> pd.DataFrame:\n",
    "    with open(f\"eval_results/{moniker}_eval_out.txt\", \"r\") as f:\n",
    "        lines = f.readlines()\n",
    "\n",
    "    in_solution = False\n",
    "    out_entries = [ ]\n",
    "    resp = \"\"\n",
    "    sol = \"\"\n",
    "    for line in lines:\n",
    "        is_delim = delim in line\n",
    "\n",
    "        if is_delim:\n",
    "            in_solution = not in_solution\n",
    "            if sol != \"\":\n",
    "                sol_query = sol.split(\"\\n\")[1]\n",
    "                rew = float(sol.split(\"\\n\")[0]\n",
    "                               .replace(\"-- Got reward of\" , \"\")\n",
    "                               .replace(\"against solution:\", \"\")\n",
    "                               .strip() )\n",
    "                prompt = \"\\n\".join(resp.strip().split(\"\\n\")[:-1]).strip()\n",
    "                response = resp.strip().split(\"\\n\")[-1].strip()\n",
    "                out_entries.append({\n",
    "                    \"prompt\" : prompt,\n",
    "                    \"response\" : response,\n",
    "                    \"solution\" : sol_query,\n",
    "                    \"reward\" : rew\n",
    "                })\n",
    "                resp = \"\"\n",
    "                sol = \"\"\n",
    "        else:\n",
    "            if in_solution:\n",
    "                sol += line\n",
    "            else:\n",
    "                resp += line\n",
    "    \n",
    "    return pd.DataFrame(out_entries)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "id": "0336d25b",
   "metadata": {},
   "outputs": [],
   "source": [
    "returns = {\n",
    "    adapter['moniker'] : load_eval_outs(adapter['moniker'])\n",
    "    for adapter in ADAPTERS\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "id": "5fd0c418",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkAAAAGzCAYAAADHdKgcAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAAA700lEQVR4nO3de1gWdf7/8dcNyg2hoMY5UUjNI2rpSmSmJol8XZXdMnUtldTcktKlrNhSs/wudlCxskhL0dbysJrtVqJGoZmn9UBHKzVMU0AyBSEDhfn94c/5dgd4IOAG5vm4rrnW+cx75n4Ps9y8msN92wzDMAQAAGAhLs5uAAAAoKYRgAAAgOUQgAAAgOUQgAAAgOUQgAAAgOUQgAAAgOUQgAAAgOUQgAAAgOUQgAAAgOUQgAAAgOUQgACLefnll2Wz2RQeHu7sVmqdkJAQ2Ww2c/L09FSPHj20dOnSSm/z5ZdfVkpKStU1CaBK2PguMMBaevbsqWPHjunQoUPav3+/Wrdu7eyWao2QkBA1bdpUDz30kCQpKytLr732mr799lstWLBA48ePv+JtdurUST4+PkpPT6/ibgH8HpwBAiwkMzNTW7du1Zw5c+Tr66tly5bVeA+lpaX65Zdfavx1L9c111yju+66S3fddZemTJmiLVu2qFGjRpo7d66zWzMZhqEzZ844uw2gTiMAARaybNkyNW3aVAMHDtQdd9zhEIDOnj2rZs2aKTY2tsx6+fn5cnd318MPP2yOFRUVafr06WrdurXsdruCg4P1yCOPqKioyGFdm82muLg4LVu2TB07dpTdbldqaqok6fnnn9dNN92kq6++Wh4eHurWrZv+9a9/lXn9M2fO6MEHH5SPj48aN26swYMH6+jRo7LZbHryyScdao8ePap77rlH/v7+stvt6tixoxYtWlTpn5mvr6/atWungwcPOoyXlpYqKSlJHTt2lLu7u/z9/TVhwgSdPHnSrAkJCdGXX36pTZs2mZfV+vTpI0l68sknZbPZyrxeSkqKbDabDh065LCdP/7xj1q/fr26d+8uDw8Pvfrqq0pPT5fNZtPKlSv1v//7v2revLnc3d3Vr18/HThwwGG7+/fv1+23366AgAC5u7urefPmGj58uPLy8ir9swHqsgbObgBAzVm2bJn+/Oc/y83NTSNGjNArr7yi//73v/rDH/6ghg0b6k9/+pPWrFmjV199VW5ubuZ6a9euVVFRkYYPHy7p/B//wYMHa8uWLbr33nvVvn17ff7555o7d66+/fZbrV271uF1P/zwQ61cuVJxcXHy8fFRSEiIJGnevHkaPHiwRo4cqeLiYi1fvlxDhw7Vu+++q4EDB5rrjxkzRitXrtTdd9+tG2+8UZs2bXJYfkFOTo5uvPFGM3T5+vpq3bp1Gjt2rPLz8zV58uQr/pmdO3dOP/zwg5o2beowPmHCBKWkpCg2NlYPPvigMjMz9dJLL2nv3r365JNP1LBhQyUlJemBBx5Qo0aN9Pjjj0uS/P39r7gHSfrmm280YsQITZgwQePHj1fbtm3NZbNmzZKLi4sefvhh5eXl6dlnn9XIkSO1Y8cOSVJxcbGioqJUVFSkBx54QAEBATp69KjeffddnTp1St7e3pXqCajTDACWsGvXLkOSsXHjRsMwDKO0tNRo3ry5MWnSJLNm/fr1hiTjP//5j8O6//M//2Nce+215vwbb7xhuLi4GB9//LFDXXJysiHJ+OSTT8wxSYaLi4vx5Zdflunp559/dpgvLi42OnXqZNx6663m2O7duw1JxuTJkx1qx4wZY0gypk+fbo6NHTvWCAwMNH788UeH2uHDhxve3t5lXu+3WrZsafTv39/Izc01cnNzjc8//9y4++67DUnGxIkTzbqPP/7YkGQsW7bMYf3U1NQy4x07djR69+5d5rWmT59ulPcWvHjxYkOSkZmZ6dCXJCM1NdWh9qOPPjIkGe3btzeKiorM8Xnz5hmSjM8//9wwDMPYu3evIclYtWrVRfcfsBIugQEWsWzZMvn7+6tv376Szl+aGjZsmJYvX66SkhJJ0q233iofHx+tWLHCXO/kyZPauHGjhg0bZo6tWrVK7du3V7t27fTjjz+a06233ipJ+uijjxxeu3fv3urQoUOZnjw8PBxeJy8vT7169dKePXvM8QuXy+6//36HdR944AGHecMwtHr1ag0aNEiGYTj0FRUVpby8PIftVmTDhg3y9fWVr6+vwsLC9MYbbyg2NlbPPfecw/57e3vrtttuc3idbt26qVGjRmX2vyqEhoYqKiqq3GWxsbEOZ+x69eolSfruu+8kyTzDs379ev38889V3htQF3EJDLCAkpISLV++XH379lVmZqY5Hh4ertmzZystLU39+/dXgwYNdPvtt+vNN99UUVGR7Ha71qxZo7NnzzoEoP3792vfvn3y9fUt9/WOHz/uMB8aGlpu3bvvvquZM2cqIyPD4d6hX98b8/3338vFxaXMNn779Fpubq5OnTqlBQsWaMGCBZfVV3nCw8M1c+ZMlZSU6IsvvtDMmTN18uRJh4Cxf/9+5eXlyc/Pr9Kvc6Uq+hlKUosWLRzmL1yuu3A/UmhoqOLj4zVnzhwtW7ZMvXr10uDBg3XXXXdx+QuWRQACLODDDz9UVlaWli9fruXLl5dZvmzZMvXv31+SNHz4cL366qtat26dYmJitHLlSrVr105dunQx60tLSxUWFqY5c+aU+3rBwcEO878+03PBxx9/rMGDB+uWW27Ryy+/rMDAQDVs2FCLFy/Wm2++ecX7WFpaKkm66667NHr06HJrOnfufMnt+Pj4KDIyUpIUFRWldu3a6Y9//KPmzZun+Ph487X8/PwqfIquomD4a+XdAC3JPBv3W+X9DC9wdXUtd9z41aeczJ49W2PGjNE777yjDRs26MEHH1RiYqK2b9+u5s2bX7JfoL4hAAEWsGzZMvn5+Wn+/Plllq1Zs0Zvv/22kpOT5eHhoVtuuUWBgYFasWKFbr75Zn344YfmDbwXtGrVSp9++qn69etX4R/yS1m9erXc3d21fv162e12c3zx4sUOdS1btlRpaakyMzPVpk0bc/y3Tzn5+vqqcePGKikpMQNMVRg4cKB69+6tf/zjH5owYYI8PT3VqlUrffDBB+rZs+dFg4lUcdC5cJbm1KlTatKkiTn+/fffV1nvvxUWFqawsDA98cQT2rp1q3r27Knk5GTNnDmz2l4TqK24Bwio586cOaM1a9boj3/8o+64444yU1xcnE6fPq1///vfkiQXFxfdcccd+s9//qM33nhD586dc7j8JUl33nmnjh49qoULF5b7eoWFhZfsy9XVVTabzeGMx6FDh8o8QXbhvpeXX37ZYfzFF18ss73bb79dq1ev1hdffFHm9XJzcy/ZU0UeffRRnThxwtzfO++8UyUlJXr66afL1J47d06nTp0y5z09PR3mL2jVqpUkafPmzeZYYWGhlixZUuk+K5Kfn69z5845jIWFhcnFxaXMxxYAVsEZIKCe+/e//63Tp09r8ODB5S6/8cYbzQ9FvBB0hg0bphdffFHTp09XWFiY2rdv77DO3XffrZUrV+qvf/2rPvroI/Xs2VMlJSX6+uuvtXLlSvPzai5m4MCBmjNnjgYMGKC//OUvOn78uObPn6/WrVvrs88+M+u6deum22+/XUlJSTpx4oT5GPy3334ryfEMy6xZs/TRRx8pPDxc48ePV4cOHfTTTz9pz549+uCDD/TTTz9V6mcYHR2tTp06ac6cOZo4caJ69+6tCRMmKDExURkZGerfv78aNmyo/fv3a9WqVZo3b57uuOMOs/9XXnlFM2fOVOvWreXn56dbb71V/fv3V4sWLTR27FhNmTJFrq6uWrRokXx9fXX48OFK9VmRDz/8UHFxcRo6dKiuu+46nTt3Tm+88YYZGgFLcvJTaACq2aBBgwx3d3ejsLCwwpoxY8YYDRs2NB8fLy0tNYKDgw1JxsyZM8tdp7i42HjmmWeMjh07Gna73WjatKnRrVs3Y8aMGUZeXp5Zp988Qv5rr7/+utGmTRvDbrcb7dq1MxYvXlzu4+GFhYXGxIkTjWbNmhmNGjUyYmJijG+++caQZMyaNcuhNicnx5g4caIRHBxsNGzY0AgICDD69etnLFiw4JI/q5YtWxoDBw4sd1lKSoohyVi8eLE5tmDBAqNbt26Gh4eH0bhxYyMsLMx45JFHjGPHjpk12dnZxsCBA43GjRsbkhweid+9e7cRHh5uuLm5GS1atDDmzJlT4WPw5fV14TH43z7enpmZ6dDrd999Z9xzzz1Gq1atDHd3d6NZs2ZG3759jQ8++OCSPxOgvuK7wADUSRkZGbr++uv1z3/+UyNHjnR2OwDqGO4BAlDrlfe9V0lJSXJxcdEtt9zihI4A1HXcAwSg1nv22We1e/du9e3bVw0aNNC6deu0bt063XvvvWUeuQeAy8ElMAC13saNGzVjxgx99dVXKigoUIsWLXT33Xfr8ccfV4MG/HccgCtHAAIAAJbDPUAAAMByCEAAAMByuHhejtLSUh07dkyNGzeu9Mf8AwCAmmUYhk6fPq2goCC5uFz8HA8BqBzHjh3jyRIAAOqoI0eOXPJLfglA5WjcuLGk8z9ALy8vJ3cDAAAuR35+voKDg82/4xdDACrHhcteXl5eBCAAAOqYy7l9hZugAQCA5RCAAACA5RCAAACA5RCAAACA5RCAAACA5RCAAACA5RCAAACA5RCAAACA5RCAAACA5RCAAACA5Tg1ACUmJuoPf/iDGjduLD8/P8XExOibb7655HqrVq1Su3bt5O7urrCwML3//vsOyw3D0LRp0xQYGCgPDw9FRkZq//791bUbAACgjnFqANq0aZMmTpyo7du3a+PGjTp79qz69++vwsLCCtfZunWrRowYobFjx2rv3r2KiYlRTEyMvvjiC7Pm2Wef1QsvvKDk5GTt2LFDnp6eioqK0i+//FITuwUAAGo5m2EYhrObuCA3N1d+fn7atGmTbrnllnJrhg0bpsLCQr377rvm2I033qiuXbsqOTlZhmEoKChIDz30kB5++GFJUl5envz9/ZWSkqLhw4dfso/8/Hx5e3srNze3zJeh2mw2NWzY0JwvLi6ucDu/rT179qwq+nFXV60kubm5Var23LlzKi0trZLahg0bml9OV121JSUlKikpqZLaBg0ayMXFpdbUlpaW6ty5cxXWurq6ytXVtdbUGoahs2fPVkmti4uLGjRoUK210sV/l6+klveIytXyHvH7amvD731teI/Iy8tTkyZNlJeXd8kvM69V3wafl5cnSWrWrFmFNdu2bVN8fLzDWFRUlNauXStJyszMVHZ2tiIjI83l3t7eCg8P17Zt28oNQEVFRSoqKjLn8/PzJUmzZ8+Wu7u7Q23Lli01ZswYc37evHn6+eefy+01KChI48ePN+fnz59v7uNv+fr66v777zfnFy5cqNzc3HJrvb29NXnyZHM+JSVFx44dK7f2qquu0pQpU8z5ZcuW6fvvvy+3tmHDhvr73/9uzq9cufKilw6nT59u/vvtt9/WV199VWFtQkKC+Wb47rvv6tNPP62w9uGHH5anp6ckaf369dq1a1eFtZMmTVKTJk0kSWlpadq2bVuFtffdd5/8/PwkSR9//LE2bdpUYe24ceN0zTXXSJK2b9+uDz74oMLa0aNHKyQkRJK0e/durVu3rsLaESNG6LrrrpMkff7553rnnXcqrL3jjjvUsWNHSdK+ffv0r3/9q8LaIUOGqGvXrpKkAwcO6K233qqwNjo6Wj169JAkHT58WEuWLKmwNjIyUj179pQkZWVl6bXXXquwtnfv3urTp4+k8/8x88orr1RYGxERof79+0s6/3s/b968Cmu7d++ugQMHSpJ+/vlnPf/88xXWdunSRTExMZLO/yFPTEyssLZDhw4aOnSoOX+x2jZt2ugvf/mLOf/8889X+IbMe8T/4T3iPN4jzqup94jLVWtugi4tLdXkyZPVs2dPderUqcK67Oxs+fv7O4z5+/srOzvbXH5hrKKa30pMTJS3t7c5BQcH/55dAQAAtVytuQR23333ad26ddqyZYuaN29eYZ2bm5uWLFmiESNGmGMvv/yyZsyYoZycHG3dulU9e/bUsWPHFBgYaNbceeedstlsWrFiRZltlncGKDg4mEtgnN6uNbW14ZR1bTi9zSUw3iN+Ty3vEfX/PaLOXQKLi4vTu+++q82bN180/EhSQECAcnJyHMZycnIUEBBgLr8w9usAlJOTY57++y273S673V5m3M3NzeEXuDyXWv5rv35Dqgu1v37Drwu1v/6FqW+1Li4ul/3/tdpQa7PZ6lStdGW/y9VVWxt+73mPqJu1teH3vra8R1wup14CMwxDcXFxevvtt/Xhhx8qNDT0kutEREQoLS3NYWzjxo2KiIiQJIWGhiogIMChJj8/Xzt27DBrAACAtTn1DNDEiRP15ptv6p133lHjxo3Ne3S8vb3l4eEhSRo1apSuueYa8wbFSZMmqXfv3po9e7YGDhyo5cuXa9euXVqwYIGk8+lv8uTJmjlzptq0aaPQ0FBNnTpVQUFB5s2RAADA2pwagC7cAX7hrvALFi9ebD5FcfjwYfMapyTddNNNevPNN/XEE0/o73//u9q0aaO1a9c63Dj9yCOPqLCwUPfee69OnTqlm2++WampqWWe6AIAANZUa26Crk0ufA7Q5dxEBQAAaocr+ftdax6DBwAAqCkEIAAAYDkEIAAAYDkEIAAAYDkEIAAAYDkEIAAAYDkEIAAAYDkEIAAAYDkEIAAAYDkEIAAAYDkEIAAAYDkEIAAAYDkEIAAAYDkEIACohwoLC2Wz2WSz2VRYWOjsdoBahwAEAAAshwAEAAAshwAEAAAshwAEAAAshwAEAAAshwAEAAAshwAEAEAdwccbVB0CEAAAsBwCEAAAsBwCEAAAsBwCEGBx3FMAwIoIQAAAwHIIQAAAwHIIQAAAwHIIQAAAwHIIQAAAwHIIQAAAwHIIQAAAwHIIQAAAwHKcGoA2b96sQYMGKSgoSDabTWvXrr1o/ZgxY8wPbPv11LFjR7PmySefLLO8Xbt21bwnAACgLnFqACosLFSXLl00f/78y6qfN2+esrKyzOnIkSNq1qyZhg4d6lDXsWNHh7otW7ZUR/sAAKCOauDMF4+OjlZ0dPRl13t7e8vb29ucX7t2rU6ePKnY2FiHugYNGiggIKDK+gQAAPVLnb4H6PXXX1dkZKRatmzpML5//34FBQXp2muv1ciRI3X48OGLbqeoqEj5+fkOEwAAqL/qbAA6duyY1q1bp3HjxjmMh4eHKyUlRampqXrllVeUmZmpXr166fTp0xVuKzEx0Ty75O3treDg4OpuHwAAOFGdDUBLlixRkyZNFBMT4zAeHR2toUOHqnPnzoqKitL777+vU6dOaeXKlRVuKyEhQXl5eeZ05MiRau4eAAA4k1PvAaoswzC0aNEi3X333XJzc7tobZMmTXTdddfpwIEDFdbY7XbZ7faqbhMAANRSdfIM0KZNm3TgwAGNHTv2krUFBQU6ePCgAgMDa6AzAABQFzg1ABUUFCgjI0MZGRmSpMzMTGVkZJg3LSckJGjUqFFl1nv99dcVHh6uTp06lVn28MMPa9OmTTp06JC2bt2qP/3pT3J1ddWIESOqdV8AAEDd4dRLYLt27VLfvn3N+fj4eEnS6NGjlZKSoqysrDJPcOXl5Wn16tWaN29eudv84YcfNGLECJ04cUK+vr66+eabtX37dvn6+lbfjgAAgDrFZhiG4ewmapv8/Hx5e3srLy9PXl5ezm4HqFaFhYVq1KiRpPNnZT09PZ3cEaoCx7V+4rhe3JX8/a6T9wABAAD8HgQgAABgOQQgAABgOQQgAABgOQQgAABgOQQgAABgOQQgAABgOQQgAABgOQQgAABgOQQgAABgOQQgAABgOQQgAABgOQQgAABgOQQgAABgOQQgAABgOQQgAABgOQQgAABgOQQgAABgOQQgAABgOQQgAABgOQQgAABgOQQgAABgOQQgAABgOQQgAABgOQQgAABgOQQgAABgOQQgAABgOQQgAABgOQQgAABgOQQgAABgOQQgAABgOQQgAABgOQQgAABgOU4NQJs3b9agQYMUFBQkm82mtWvXXrQ+PT1dNputzJSdne1QN3/+fIWEhMjd3V3h4eHauXNnNe4FAACoa5wagAoLC9WlSxfNnz//itb75ptvlJWVZU5+fn7mshUrVig+Pl7Tp0/Xnj171KVLF0VFRen48eNV3T4AAKijGjjzxaOjoxUdHX3F6/n5+alJkyblLpszZ47Gjx+v2NhYSVJycrLee+89LVq0SI899tjvaRcAANQTdfIeoK5duyowMFC33XabPvnkE3O8uLhYu3fvVmRkpDnm4uKiyMhIbdu2rcLtFRUVKT8/32ECAAD1V50KQIGBgUpOTtbq1au1evVqBQcHq0+fPtqzZ48k6ccff1RJSYn8/f0d1vP39y9zn9CvJSYmytvb25yCg4OrdT8AAIBzOfUS2JVq27at2rZta87fdNNNOnjwoObOnas33nij0ttNSEhQfHy8OZ+fn08IAgCgHqtTAag8PXr00JYtWyRJPj4+cnV1VU5OjkNNTk6OAgICKtyG3W6X3W6v1j4BAEDtUacugZUnIyNDgYGBkiQ3Nzd169ZNaWlp5vLS0lKlpaUpIiLCWS0CAIBaxqlngAoKCnTgwAFzPjMzUxkZGWrWrJlatGihhIQEHT16VEuXLpUkJSUlKTQ0VB07dtQvv/yi1157TR9++KE2bNhgbiM+Pl6jR49W9+7d1aNHDyUlJamwsNB8KgwAAMCpAWjXrl3q27evOX/hPpzRo0crJSVFWVlZOnz4sLm8uLhYDz30kI4ePaqrrrpKnTt31gcffOCwjWHDhik3N1fTpk1Tdna2unbtqtTU1DI3RgMAAOuyGYZhOLuJ2iY/P1/e3t7Ky8uTl5eXs9sBqlVhYaEaNWok6fxZWU9PTyd3hKrAca2fOK4XdyV/v+v8PUAAAABXigAEAAAsp84/Bg8A1S3ksfec3cIVKy3+xfx3+6mpcnFzd2I3lXNo1kBnt4B6jDNAAADAcjgDBACwJM7sOUdtObPHGSAAAGA5BCAAAGA5BCAAAGA5BCAAAGA5BCAAAGA5BCAAAGA5BCAAAGA5BCAAAGA5BCAAAGA5BCAAAGA5BCAAAGA5BCAAAGA5BCAAAGA5BCAAAGA5DZzdAFCfhDz2nrNbuGKlxb+Y/24/NVUubu5O7KZyDs0a6OwWANQxnAECAACWQwACAACWQwACAACWQwACAACWQwACAACWQwACAACWQwACAACWQwACAACWQwACAACWQwACAACWQwACAACWQwACAACWQwACAACW49QAtHnzZg0aNEhBQUGy2Wxau3btRevXrFmj2267Tb6+vvLy8lJERITWr1/vUPPkk0/KZrM5TO3atavGvQAAAHWNUwNQYWGhunTpovnz519W/ebNm3Xbbbfp/fff1+7du9W3b18NGjRIe/fudajr2LGjsrKyzGnLli3V0T4AAKijGjjzxaOjoxUdHX3Z9UlJSQ7z//jHP/TOO+/oP//5j66//npzvEGDBgoICKiqNgEAQD1Tp+8BKi0t1enTp9WsWTOH8f379ysoKEjXXnutRo4cqcOHD190O0VFRcrPz3eYAABA/VWnA9Dzzz+vgoIC3XnnneZYeHi4UlJSlJqaqldeeUWZmZnq1auXTp8+XeF2EhMT5e3tbU7BwcE10T4AAHCSOhuA3nzzTc2YMUMrV66Un5+fOR4dHa2hQ4eqc+fOioqK0vvvv69Tp05p5cqVFW4rISFBeXl55nTkyJGa2AUAAOAkTr0HqLKWL1+ucePGadWqVYqMjLxobZMmTXTdddfpwIEDFdbY7XbZ7faqbhMAANRSde4M0FtvvaXY2Fi99dZbGjhw4CXrCwoKdPDgQQUGBtZAdwAAoC5w6hmggoIChzMzmZmZysjIULNmzdSiRQslJCTo6NGjWrp0qaTzl71Gjx6tefPmKTw8XNnZ2ZIkDw8PeXt7S5IefvhhDRo0SC1bttSxY8c0ffp0ubq6asSIETW/gwAAoFZy6hmgXbt26frrrzcfYY+Pj9f111+vadOmSZKysrIcnuBasGCBzp07p4kTJyowMNCcJk2aZNb88MMPGjFihNq2bas777xTV199tbZv3y5fX9+a3TkAAFBrOfUMUJ8+fWQYRoXLU1JSHObT09Mvuc3ly5f/zq4AAEB9V+fuAQIAAPi9CEAAAMByCEAAAMByCEAAAMByCEAAAMByCEAAAMByCEAAAMByCEAAAMByCEAAAMByCEAAAMByKvVVGIWFhZo1a5bS0tJ0/PhxlZaWOiz/7rvvqqQ5AACA6lCpADRu3Dht2rRJd999twIDA2Wz2aq6LwAAgGpTqQC0bt06vffee+rZs2dV9wMAAFDtKnUPUNOmTdWsWbOq7gUAAKBGVCoAPf3005o2bZp+/vnnqu4HAACg2lXqEtjs2bN18OBB+fv7KyQkRA0bNnRYvmfPnippDgAAoDpUKgDFxMRUcRsAAAA154oD0Llz52Sz2XTPPfeoefPm1dETAABAtbrie4AaNGig5557TufOnauOfgAAAKpdpW6CvvXWW7Vp06aq7gUAAKBGVOoeoOjoaD322GP6/PPP1a1bN3l6ejosHzx4cJU0BwAAUB0qFYDuv/9+SdKcOXPKLLPZbCopKfl9XQEAAFSjSgWg3373FwAAQF3Ct8EDAADLqdQZoKeeeuqiy6dNm1apZgAAAGpCpQLQ22+/7TB/9uxZZWZmqkGDBmrVqhUBCAAA1GqVCkB79+4tM5afn68xY8boT3/60+9uCgAAoDpV2T1AXl5emjFjhqZOnVpVmwQAAKgWVXoTdF5envLy8qpykwAAAFWuUpfAXnjhBYd5wzCUlZWlN954Q9HR0VXSGAAAQHWpVACaO3euw7yLi4t8fX01evRoJSQkVEljAAAA1aVSASgzM7Oq+wAAAKgxlboH6J577tHp06fLjBcWFuqee+753U0BAICyXNzc1fLRd9Xy0Xfl4ubu7HbqtEoFoCVLlujMmTNlxs+cOaOlS5de9nY2b96sQYMGKSgoSDabTWvXrr3kOunp6brhhhtkt9vVunVrpaSklKmZP3++QkJC5O7urvDwcO3cufOyewIAAPXfFQWg/Px85eXlyTAMnT59Wvn5+eZ08uRJvf/++/Lz87vs7RUWFqpLly6aP3/+ZdVnZmZq4MCB6tu3rzIyMjR58mSNGzdO69evN2tWrFih+Ph4TZ8+XXv27FGXLl0UFRWl48ePX8muAgCAeuyK7gFq0qSJbDabbDabrrvuujLLbTabZsyYcdnbi46OvqKnxpKTkxUaGqrZs2dLktq3b68tW7Zo7ty5ioqKknT+G+rHjx+v2NhYc5333ntPixYt0mOPPXbZrwUAddmFSyUAyndFAeijjz6SYRi69dZbtXr1ajVr1sxc5ubmppYtWyooKKjKm7xg27ZtioyMdBiLiorS5MmTJUnFxcXavXu3w5NoLi4uioyM1LZt2yrcblFRkYqKisz5/Pz8qm0cAADUKlcUgHr37i3p/KWoFi1ayGazVUtTFcnOzpa/v7/DmL+/v/Lz83XmzBmdPHlSJSUl5dZ8/fXXFW43MTHxis5cAQCAuq1SN0G3bNlSW7Zs0V133aWbbrpJR48elSS98cYb2rJlS5U2WBMSEhLMT7HOy8vTkSNHnN0SAACoRpUKQKtXr1ZUVJQ8PDy0Z88e8/JRXl6e/vGPf1Rpg78WEBCgnJwch7GcnBx5eXnJw8NDPj4+cnV1LbcmICCgwu3a7XZ5eXk5TAAAoP6qVACaOXOmkpOTtXDhQjVs2NAc79mzp/bs2VNlzf1WRESE0tLSHMY2btyoiIgISefvQ+rWrZtDTWlpqdLS0swaAACASgWgb775RrfcckuZcW9vb506deqyt1NQUKCMjAxlZGRIOn9vUUZGhg4fPizp/KWpUaNGmfV//etf9d133+mRRx7R119/rZdfflkrV67U3/72N7MmPj5eCxcu1JIlS7Rv3z7dd999KiwsNJ8KAwAAqNRXYQQEBOjAgQMKCQlxGN+yZYuuvfbay97Orl271LdvX3M+Pj5ekjR69GilpKQoKyvLDEOSFBoaqvfee09/+9vfNG/ePDVv3lyvvfaa+Qi8JA0bNky5ubmaNm2asrOz1bVrV6Wmppa5MRoAAFhXpQLQ+PHjNWnSJC1atEg2m03Hjh3Ttm3b9NBDD2natGmXvZ0+ffrIMIwKl5f3Kc99+vTR3r17L7rduLg4xcXFXXYfAADAWioVgB577DGVlpaqX79++vnnn3XLLbfIbrdrypQpGjduXFX3CAAAUKUqdQ+QzWbT448/rp9++klffPGFtm/frtzcXHl7eys0NLSqewQAAKhSVxSAioqKlJCQoO7du6tnz556//331aFDB3355Zdq27at5s2b53BDMgAAQG10RZfApk2bpldffVWRkZHaunWrhg4dqtjYWG3fvl2zZ8/W0KFD5erqWl29AgAAVIkrCkCrVq3S0qVLNXjwYH3xxRfq3Lmzzp07p08//bTGvxYDAACgsq7oEtgPP/ygbt26SZI6deoku92uv/3tb4QfAABQp1xRACopKZGbm5s536BBAzVq1KjKmwIAAKhOV3QJzDAMjRkzRna7XZL0yy+/6K9//as8PT0d6tasWVN1HQIAAFSxKwpAo0ePdpi/6667qrQZAACAmnBFAWjx4sXV1QcAAECNqdQHIQIAANRlBCAAAGA5BCAAAGA5BCAAAGA5lfo2eAD1h4ubu1o++q6z2wCAGsUZIAAAYDkEIAAAYDkEIAAAYDkEIAAAYDkEIAAAYDkEIAAAYDkEIAAAYDkEIAAAYDkEIAAAYDkEIFy2wsJC2Ww22Ww2FRYWOrsdAAAqjQAEAAAshwAEAAAshwAEAAAshwAEAAAshwAEAAAshwAEAAAshwAEAAAshwAEAAAsp1YEoPnz5yskJETu7u4KDw/Xzp07K6zt06eP+WF8v54GDhxo1owZM6bM8gEDBtTErgAAgDqggbMbWLFiheLj45WcnKzw8HAlJSUpKipK33zzjfz8/MrUr1mzRsXFxeb8iRMn1KVLFw0dOtShbsCAAVq8eLE5b7fbq28nAABAneL0M0Bz5szR+PHjFRsbqw4dOig5OVlXXXWVFi1aVG59s2bNFBAQYE4bN27UVVddVSYA2e12h7qmTZvWxO4AAIA6wKkBqLi4WLt371ZkZKQ55uLiosjISG3btu2ytvH6669r+PDh8vT0dBhPT0+Xn5+f2rZtq/vuu08nTpyocBtFRUXKz893mAAAQP3l1AD0448/qqSkRP7+/g7j/v7+ys7OvuT6O3fu1BdffKFx48Y5jA8YMEBLly5VWlqannnmGW3atEnR0dEqKSkpdzuJiYny9vY2p+Dg4MrvFAAAqPWcfg/Q7/H6668rLCxMPXr0cBgfPny4+e+wsDB17txZrVq1Unp6uvr161dmOwkJCYqPjzfn8/PzCUEAANRjTj0D5OPjI1dXV+Xk5DiM5+TkKCAg4KLrFhYWavny5Ro7duwlX+faa6+Vj4+PDhw4UO5yu90uLy8vhwkAANRfTg1Abm5u6tatm9LS0syx0tJSpaWlKSIi4qLrrlq1SkVFRbrrrrsu+To//PCDTpw4ocDAwN/dMwAAqPuc/hRYfHy8Fi5cqCVLlmjfvn267777VFhYqNjYWEnSqFGjlJCQUGa9119/XTExMbr66qsdxgsKCjRlyhRt375dhw4dUlpamoYMGaLWrVsrKiqqRvYJAADUbk6/B2jYsGHKzc3VtGnTlJ2dra5duyo1NdW8Mfrw4cNycXHMad988422bNmiDRs2lNmeq6urPvvsMy1ZskSnTp1SUFCQ+vfvr6effprPAgIAAJJqQQCSpLi4OMXFxZW7LD09vcxY27ZtZRhGufUeHh5av359VbYHAADqGadfAgMAAKhpBCAAAGA5BCAAAGA5BCAAAGA5BCAAAGA5BCAAAGA5BCAAAGA5BCAAAGA5BCAAAGA5BCAAAGA5BCAAAGA5BCAAAGA5BCAAAGA5BCAAAGA5BCAAAGA5BCAAAGA5BCAAAGA5BCAAAGA5BCAAAGA5BCAAAGA5BCAAAGA5BCAAAGA5BCAAAGA5BCAAAGA5DZzdgFWFPPaes1u4YqXFv5j/bj81VS5u7k7spnIOzRro7BYAALUAZ4AAAIDlEIAAAIDlEIAAAIDlEIAAAIDlEIAAAIDlEIAAAIDlEIAAAIDlEIAAAIDl1IoANH/+fIWEhMjd3V3h4eHauXNnhbUpKSmy2WwOk7u74wfyGYahadOmKTAwUB4eHoqMjNT+/furezcAAEAd4fQAtGLFCsXHx2v69Onas2ePunTpoqioKB0/frzCdby8vJSVlWVO33//vcPyZ599Vi+88IKSk5O1Y8cOeXp6KioqSr/88ksFWwQAAFbi9AA0Z84cjR8/XrGxserQoYOSk5N11VVXadGiRRWuY7PZFBAQYE7+/v7mMsMwlJSUpCeeeEJDhgxR586dtXTpUh07dkxr166tgT0CAAC1nVMDUHFxsXbv3q3IyEhzzMXFRZGRkdq2bVuF6xUUFKhly5YKDg7WkCFD9OWXX5rLMjMzlZ2d7bBNb29vhYeHV7jNoqIi5efnO0wAAKD+cmoA+vHHH1VSUuJwBkeS/P39lZ2dXe46bdu21aJFi/TOO+/on//8p0pLS3XTTTfphx9+kCRzvSvZZmJiory9vc0pODj49+4aAACoxZx+CexKRUREaNSoUeratat69+6tNWvWyNfXV6+++mqlt5mQkKC8vDxzOnLkSBV2DAAAahunBiAfHx+5uroqJyfHYTwnJ0cBAQGXtY2GDRvq+uuv14EDByTJXO9Ktmm32+Xl5eUwAQCA+supAcjNzU3dunVTWlqaOVZaWqq0tDRFRERc1jZKSkr0+eefKzAwUJIUGhqqgIAAh23m5+drx44dl71NAABQvzVwdgPx8fEaPXq0unfvrh49eigpKUmFhYWKjY2VJI0aNUrXXHONEhMTJUlPPfWUbrzxRrVu3VqnTp3Sc889p++//17jxo2TdP4JscmTJ2vmzJlq06aNQkNDNXXqVAUFBSkmJsZZuwkAAGoRpwegYcOGKTc3V9OmTVN2dra6du2q1NRU8ybmw4cPy8Xl/05UnTx5UuPHj1d2draaNm2qbt26aevWrerQoYNZ88gjj6iwsFD33nuvTp06pZtvvlmpqallPjARAABYk9MDkCTFxcUpLi6u3GXp6ekO83PnztXcuXMvuj2bzaannnpKTz31VFW1CAAA6pE69xQYAADA70UAAgAAlkMAAgAAlkMAAgAAlkMAAgAAlkMAAgAAlkMAAgAAlkMAAgAAlkMAAgAAlkMAAgAAlkMAAgAAlkMAAgAAlkMAAgAAlkMAAgAAlkMAAgAAlkMAAgAAlkMAAgAAlkMAAgAAlkMAAgAAlkMAAgAAlkMAAgAAlkMAAgAAlkMAAgAAltPA2Q2g7nBxc1fLR991dhsAAPxunAECAACWQwACAACWQwACAACWQwACAACWQwACAACWQwACAACWQwACAACWQwACAACWQwACAACWUysC0Pz58xUSEiJ3d3eFh4dr586dFdYuXLhQvXr1UtOmTdW0aVNFRkaWqR8zZoxsNpvDNGDAgOreDQAAUEc4PQCtWLFC8fHxmj59uvbs2aMuXbooKipKx48fL7c+PT1dI0aM0EcffaRt27YpODhY/fv319GjRx3qBgwYoKysLHN66623amJ3AABAHeD0ADRnzhyNHz9esbGx6tChg5KTk3XVVVdp0aJF5dYvW7ZM999/v7p27ap27drptddeU2lpqdLS0hzq7Ha7AgICzKlp06Y1sTsAAKAOcGoAKi4u1u7duxUZGWmOubi4KDIyUtu2bbusbfz88886e/asmjVr5jCenp4uPz8/tW3bVvfdd59OnDhR4TaKioqUn5/vMAEAgPrLqQHoxx9/VElJifz9/R3G/f39lZ2dfVnbePTRRxUUFOQQogYMGKClS5cqLS1NzzzzjDZt2qTo6GiVlJSUu43ExER5e3ubU3BwcOV3CgAA1HoNnN3A7zFr1iwtX75c6enpcnd3N8eHDx9u/jssLEydO3dWq1atlJ6ern79+pXZTkJCguLj4835/Px8QhAAAPWYU88A+fj4yNXVVTk5OQ7jOTk5CggIuOi6zz//vGbNmqUNGzaoc+fOF6299tpr5ePjowMHDpS73G63y8vLy2ECAAD1l1MDkJubm7p16+ZwA/OFG5ojIiIqXO/ZZ5/V008/rdTUVHXv3v2Sr/PDDz/oxIkTCgwMrJK+AQBA3eb0p8Di4+O1cOFCLVmyRPv27dN9992nwsJCxcbGSpJGjRqlhIQEs/6ZZ57R1KlTtWjRIoWEhCg7O1vZ2dkqKCiQJBUUFGjKlCnavn27Dh06pLS0NA0ZMkStW7dWVFSUU/YRAADULk6/B2jYsGHKzc3VtGnTlJ2dra5duyo1NdW8Mfrw4cNycfm/nPbKK6+ouLhYd9xxh8N2pk+frieffFKurq767LPPtGTJEp06dUpBQUHq37+/nn76adnt9hrdNwAAUDs5PQBJUlxcnOLi4spdlp6e7jB/6NChi27Lw8ND69evr6LOAABAfeT0S2AAAAA1jQAEAAAshwAEAAAshwAEAAAshwAEAAAshwAEAAAshwAEAAAshwAEAAAshwAEAAAshwAEAAAshwAEAAAshwAEAAAshwAEAAAshwAEAAAshwAEAAAshwAEAAAshwAEAAAshwAEAAAshwAEAAAshwAEAAAshwAEAAAshwAEAAAshwAEAAAshwAEAAAshwAEAAAshwAEAAAshwAEAAAshwAEAAAshwAEAAAshwAEAAAshwAEAAAshwAEAAAshwAEAAAsp1YEoPnz5yskJETu7u4KDw/Xzp07L1q/atUqtWvXTu7u7goLC9P777/vsNwwDE2bNk2BgYHy8PBQZGSk9u/fX527AAAA6hCnB6AVK1YoPj5e06dP1549e9SlSxdFRUXp+PHj5dZv3bpVI0aM0NixY7V3717FxMQoJiZGX3zxhVnz7LPP6oUXXlBycrJ27NghT09PRUVF6Zdffqmp3QIAALWY0wPQnDlzNH78eMXGxqpDhw5KTk7WVVddpUWLFpVbP2/ePA0YMEBTpkxR+/bt9fTTT+uGG27QSy+9JOn82Z+kpCQ98cQTGjJkiDp37qylS5fq2LFjWrt2bQ3uGQAAqK0aOPPFi4uLtXv3biUkJJhjLi4uioyM1LZt28pdZ9u2bYqPj3cYi4qKMsNNZmamsrOzFRkZaS739vZWeHi4tm3bpuHDh5fZZlFRkYqKisz5vLw8SVJ+fn6l9+1SSot+rrZto2LVeUwljquzcFzrJ45r/VSdx/XCtg3DuGStUwPQjz/+qJKSEvn7+zuM+/v76+uvvy53nezs7HLrs7OzzeUXxiqq+a3ExETNmDGjzHhwcPDl7QjqDO8kZ3eA6sBxrZ84rvVTTRzX06dPy9vb+6I1Tg1AtUVCQoLDWaXS0lL99NNPuvrqq2Wz2ZzYWe2Tn5+v4OBgHTlyRF5eXs5uB1WE41o/cVzrJ45rxQzD0OnTpxUUFHTJWqcGIB8fH7m6uionJ8dhPCcnRwEBAeWuExAQcNH6C/+bk5OjwMBAh5quXbuWu0273S673e4w1qRJkyvZFcvx8vLiF68e4rjWTxzX+onjWr5Lnfm5wKk3Qbu5ualbt25KS0szx0pLS5WWlqaIiIhy14mIiHCol6SNGzea9aGhoQoICHCoyc/P144dOyrcJgAAsBanXwKLj4/X6NGj1b17d/Xo0UNJSUkqLCxUbGysJGnUqFG65pprlJiYKEmaNGmSevfurdmzZ2vgwIFavny5du3apQULFkiSbDabJk+erJkzZ6pNmzYKDQ3V1KlTFRQUpJiYGGftJgAAqEWcHoCGDRum3NxcTZs2TdnZ2eratatSU1PNm5gPHz4sF5f/O1F100036c0339QTTzyhv//972rTpo3Wrl2rTp06mTWPPPKICgsLde+99+rUqVO6+eablZqaKnd39xrfv/rGbrdr+vTpZS4Zom7juNZPHNf6ieNaNWzG5TwrBgAAUI84/YMQAQAAahoBCAAAWA4BCAAAWA4BCAAAWA4BCIAk6cknn5S/v79sNhtfHFwH9enTR5MnT3Z2G7gMHKvagQAEQPv27dOMGTP06quvKisrS9HR0QoJCVFSUpKzWwNQzWbNmmV+hp6VOP1zgFB3FRcXy83NzdltoAocPHhQkjRkyBC+/w6ox377vv3f//5Xr776qjp37uzErpyDM0Aw9enTR3FxcYqLi5O3t7d8fHw0depUXfioqJCQED399NMaNWqUvLy8dO+990qStmzZol69esnDw0PBwcF68MEHVVhY6MxdQQX+9a9/KSwsTB4eHrr66qsVGRmpKVOmaNCgQZIkFxcX2Ww29enTR99//73+9re/yWazEYpqmcLCQo0aNUqNGjVSYGCgZs+e7bD8wu/qiBEj5OnpqWuuuUbz5893qDl8+LCGDBmiRo0aycvLS3feeWeZ71nE7+fsY/Xkk0+qa9eueu211xQaGurwgcAFBQUaOXKkFi5cqKZNm/7+na1jCEBwsGTJEjVo0EA7d+7UvHnzNGfOHL322mvm8ueff15dunTR3r17NXXqVB08eFADBgzQ7bffrs8++0wrVqzQli1bFBcX58S9QHmysrI0YsQI3XPPPdq3b5/S09P15z//WdOnT9fixYvNmqysLK1Zs0bNmzfXU089ZY6h9pgyZYo2bdqkd955Rxs2bFB6err27NnjUPPcc8+Zv6uPPfaYJk2apI0bN0o6/52LQ4YM0U8//aRNmzZp48aN+u677zRs2DBn7E69VhuO1YEDB7R69WqtWbNGGRkZ5vjEiRM1cOBARUZGVsm+1jkG8P/17t3baN++vVFaWmqOPfroo0b79u0NwzCMli1bGjExMQ7rjB071rj33nsdxj7++GPDxcXFOHPmTPU3jcu2e/duQ5Jx6NChMsvefvtt47dvBy1btjTmzp1bQ93hcp0+fdpwc3MzVq5caY6dOHHC8PDwMCZNmmQYxvljN2DAAIf1hg0bZkRHRxuGYRgbNmwwXF1djcOHD5vLv/zyS0OSsXPnzurfCYuoDcdq+vTpRsOGDY3jx487jL/11ltGp06dzPfp3r17mz1ZBWeA4ODGG290uNwRERGh/fv3q6SkRJLUvXt3h/pPP/1UKSkpatSokTlFRUWptLRUmZmZNdo7Lq5Lly7q16+fwsLCNHToUC1cuFAnT550dlu4QgcPHlRxcbHCw8PNsWbNmqlt27YOdREREWXm9+3bJ+n8Te/BwcEKDg42l3fo0EFNmjQxa/D71ZZj1bJlS/n6+przR44c0aRJk7Rs2TJLf0cmN0Hjinh6ejrMFxQUaMKECXrwwQfL1LZo0aKm2sJlcHV11caNG7V161Zt2LBBL774oh5//HHt2LHD2a0BqEa/fd/evXu3jh8/rhtuuMEcKykp0ebNm/XSSy+pqKhIrq6uNd1mjeMMEBz89o/h9u3b1aZNmwp/GW644QZ99dVXat26dZmJJ8RqH5vNpp49e2rGjBnau3ev3Nzc9Pbbb5db6+bmZp75Q+3RqlUrNWzY0OF39eTJk/r2228d6rZv315mvn379pKk9u3b68iRIzpy5Ii5/KuvvtKpU6fUoUOHauzeWmrrserXr58+//xzZWRkmFP37t01cuRIZWRkWCL8SJwBwm8cPnxY8fHxmjBhgvbs2aMXX3yxzFMLv/boo4/qxhtvVFxcnMaNGydPT0999dVX2rhxo1566aUa7ByXsmPHDqWlpal///7y8/PTjh07lJubq/bt26uoqKhMfUhIiDZv3qzhw4fLbrfLx8fHCV3jtxo1aqSxY8dqypQpuvrqq+Xn56fHH39cLi6O/z37ySef6Nlnn1VMTIw2btyoVatW6b333pMkRUZGKiwsTCNHjlRSUpLOnTun+++/X7179y5zmRuVV1uPVePGjdWpUyeHMU9PT1199dVlxuszAhAcjBo1SmfOnFGPHj3k6uqqSZMmmY+7l6dz587atGmTHn/8cfXq1UuGYahVq1Y8TVILeXl5afPmzUpKSlJ+fr5atmyp2bNnKzo6utxPfn7qqac0YcIEtWrVSkVFRebHIcD5nnvuORUUFGjQoEFq3LixHnroIeXl5TnUPPTQQ9q1a5dmzJghLy8vzZkzR1FRUZLOnwl855139MADD+iWW26Ri4uLBgwYoBdffNEZu1OvcaxqL5vBuxr+vz59+qhr1658+i9Qx4WEhGjy5MmW+2Tfuohj5TzcAwQAACyHAAQAQB3VsWNHh48h+fW0bNkyZ7dXq3EJDACAOur777/X2bNny13m7++vxo0b13BHdQcBCAAAWA6XwAAAgOUQgAAAgOUQgAAAgOUQgAAAgOUQgAAAgOUQgAAAgOUQgAAAgOX8P0lyUUF5FxUaAAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.bar(x=list(returns.keys()), \n",
    "        height=list(map(lambda df: df['reward'].mean(), returns.values())), \n",
    "        yerr=list(map(lambda df: df['reward'].std(), returns.values()))\n",
    ")\n",
    "plt.hlines([2.0],[-0.7],[3.7], linestyles=\"--\", color=\"gray\")\n",
    "plt.xlim(-0.6, (len(returns.keys()) - 1) + .6)\n",
    "plt.title(\"Average Returns\")\n",
    "plt.ylabel(\"Return\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b6156efb",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "environment": {
   "kernel": "conda-root-py",
   "name": "workbench-notebooks.m113",
   "type": "gcloud",
   "uri": "gcr.io/deeplearning-platform-release/workbench-notebooks:m113"
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}