notebook/Introduction_to_ReLM.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "4bb26c3c",
   "metadata": {},
   "source": [
    "# Introduction to ReLM"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "51f15126",
   "metadata": {},
   "source": [
    "ReLM is a <u>r</u>egular <u>e</u>xpression (regex) search engine for <u>l</u>anguage <u>m</u>odels (LMs).\n",
    "At a high level, a user inputs a query to ReLM in the form of a [regular expression](https://en.wikipedia.org/wiki/Regular_expression), the regular expression is compiled to a representation of the space of matching strings, and the ReLM engine executes the language model over that space.\n",
    "\n",
    "One area that ReLM can be applied to is _model validation_, the act of ensuring that a model conforms to specifications of correctness.\n",
    "For example, it is clear that a language model should be accurate in its predictions, but it may also be desirable for it to _not_ have other properties, such as the ability to generate biased, toxic, or memorized text.\n",
    "Such testing is specifically useful for autoregressive large language models (LLMs), which consume and produce _arbitrary strings_, and thus have more degrees of freedom than traditional machine learning models."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7b0ce230",
   "metadata": {},
   "source": [
    "##  Model Loading"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cc253b6e",
   "metadata": {},
   "source": [
    "To start, let's load the XL variant of [GPT-2](https://openai.com/research/better-language-models) model using Hugging Face Transformers.\n",
    "Note that you can use a smaller model (e.g., \"gpt2\") if you need to (e.g., limited GPU memory), though some of this notebook's commentary will make less sense.\n",
    "\n",
    "At this point, we're just loading a model and its tokenizer, and ReLM is not yet needed.\n",
    "If you need more information on [PyTorch](https://pytorch.org/) or Hugging Face [Transformers](https://huggingface.co/docs/transformers/index), you can check out their tutorials\n",
    "[\\[1\\]](https://pytorch.org/tutorials/)\n",
    "[\\[2\\]](https://huggingface.co/docs/transformers/quicktour)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "894c92ff",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-03-31T02:45:37.237795Z",
     "start_time": "2023-03-31T02:45:23.388044Z"
    }
   },
   "outputs": [],
   "source": [
    "import torch\n",
    "torch.manual_seed(42)\n",
    "\n",
    "from transformers import AutoModelForCausalLM\n",
    "from transformers import AutoTokenizer\n",
    "\n",
    "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
    "model_id = \"gpt2-xl\"  # Change this to \"gpt2\" if you get memory issues\n",
    "\n",
    "tokenizer = AutoTokenizer.from_pretrained(model_id, use_fast=True)\n",
    "model = AutoModelForCausalLM.from_pretrained(model_id,\n",
    "                                             return_dict_in_generate=True,\n",
    "                                             pad_token_id=tokenizer.eos_token_id).to(device)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "38a2d12c",
   "metadata": {},
   "source": [
    "## A Validation Warmup"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6782b3b7",
   "metadata": {},
   "source": [
    "Let's now pretend we are testing the model.\n",
    "We want to answer the question: \"Does the model know the birth date of George Washington?\".\n",
    "One way to do this test is to sample from the model given the prefix, and see what happens.\n",
    "You can see that we can't glean much from this information---some of the responses aren't even dates, and they have all this extra stuff at the end.\n",
    "We can see some patterns in the data (e.g., date ranges and sentence structure) which may allow us to be more or less confident that the model knows _something_.\n",
    "\n",
    "However, analyzing the entire distribution seems ***hard*** because we don't even have a consistent format of the \n",
    "date (e.g., \"May 10, 1732\" vs. \"this day in 1732\").\n",
    "The phrase \"this day in 1732\" is technically correct one day of the year, but that sort of answer is not something we _want_ to evaluate.\n",
    "Can we test the set of responses in a way where the output _is_ structured (i.e., where we know we will get a date for sure)? 🤔"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "b68288aa",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-03-31T02:45:41.279964Z",
     "start_time": "2023-03-31T02:45:37.244578Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "George Washington was born on May 10, 1732 and died on March 4, 1799. George Washington became president under the\n",
      "George Washington was born on the day Abraham Lincoln would have been buried.[1] It was in 1799 and the US was\n",
      "George Washington was born on August 21, 1732 in New Kent, New York to David and Mary Washington — a slave woman\n",
      "George Washington was born on January 22, 1732 in Williamsburg, Virginia. He and his brother, Thomas, who died\n",
      "George Washington was born on this day in 1732. He became one of the greatest U.S. leaders of all time\n",
      "George Washington was born on October 8, 1732, the second of five children who died shortly after his birth. Washington had\n",
      "George Washington was born on April 19, 1732, in Williamsburg, Virginia. His family joined the British colony of Virginia\n",
      "George Washington was born on November 19, 1732. He died on January 21, 1799 and was buried in Arlington National\n",
      "George Washington was born on November 13, 1732 during an important time in American history as well. It was during this time\n",
      "George Washington was born on this day in 1732.\n",
      "\n",
      "George Washington was born on this day in 1732, one\n"
     ]
    }
   ],
   "source": [
    "# Create a prefix/prompt\n",
    "prefix = \"George Washington was born on\"\n",
    "# Convert it to tokens. We add BOS token (as mirrored below).\n",
    "input_ids = torch.tensor([tokenizer.bos_token_id,] + tokenizer.encode(prefix)).reshape(1, -1).to(device)\n",
    "# Generate responses from the model (in tokens)\n",
    "tokens = model.generate(input_ids,\n",
    "                        max_new_tokens=20,\n",
    "                        num_return_sequences=10,\n",
    "                        do_sample=True).sequences\n",
    "# Print the strings representing the responses\n",
    "for t in tokens:\n",
    "    print(tokenizer.decode(t[1:]))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "94ef0e86",
   "metadata": {},
   "source": [
    "##  Continuing Validation with ReLM"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "471037f5",
   "metadata": {},
   "source": [
    "To demonstrate ReLM, let's do a simple knowledge verification query of the model, building off the prior example.\n",
    "Specifically, let's test for George Washington's birthday.\n",
    "One way to do this is to ask \"George Washington was born on <b><u>\\<date\\></u></b>\".\n",
    "Let's construct the query in ReLM."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "684aea62",
   "metadata": {},
   "source": [
    "### Query Construction"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fb78d2bc",
   "metadata": {},
   "source": [
    "Below, we construct a regular expression query using ReLM's abstractions.\n",
    "To start, we have to define what strings we are looking for, using a `relm.QueryString`.\n",
    "The first parameter, `query_str`, defines exactly what strings we are looking for.\n",
    "In regular expression syntax, we are saying \"George Washington was born on <b><u>\\<date\\></u></b>\", where \"<b><u>\\<date\\></u></b>\" is a month, day, and year.\n",
    "Notice we also fill in the `prefix_str` parameter.\n",
    "`prefix_str` is a substring of `query_str`, and it indicates that the user wants that prefix to be treated as if it were fixed.\n",
    "If you are familiar with [prompting](https://en.wikipedia.org/wiki/Prompt_engineering), the `prefix_str` parameter is trying to capture the prompt.\n",
    "Importantly, since the `prefix_str` is treated as fixed, ReLM always traverses these prefixes, even if they would otherwise be rejected due to other query constraints.\n",
    "While `query_str` is in some sense a _rejection_ of strings a user is interested in (i.e., reject all strings that don't match the regular expression pattern), the `prefix_str` is in a similar sense an unconditional _acceptance_ of strings a user is interested in."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "558ded3c",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-03-31T02:45:41.995157Z",
     "start_time": "2023-03-31T02:45:41.280919Z"
    }
   },
   "outputs": [],
   "source": [
    "import relm\n",
    "query_string = relm.QueryString(query_str=(\"George Washington was born on \"\n",
    "                                           \"((January)|(February)|(March)|(April)|\"\n",
    "                                           \"(May)|(June)|(July)|(August)|(September)|\"\n",
    "                                           \"(October)|(November)|(December)) \"\n",
    "                                           \"[0-9]{1,2}, [0-9]{4}\"),\n",
    "                                prefix_str=\"George Washington was born on\"\n",
    "                               )"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "79033a67",
   "metadata": {},
   "source": [
    "Now, we need to _execute_ the query.\n",
    "To do so, ReLM needs some additional information, which is specified to the `relm.SimpleSearchQuery` object.\n",
    "Namely, we specify:\n",
    "1. What strings are we interested in?\n",
    "2. What is the traversal order over the space of strings?\n",
    "3. What type of tokenizations of the strings do we want to explore?\n",
    "4. What application-specific parameters do we have?\n",
    "\n",
    "To start, notice we set `top_k` to `None`.\n",
    "_top-k_ is used to reject sequences which are very unlikely compared to alternatives.\n",
    "By setting it to `None`, we are saying that we don't want to apply this option.\n",
    "Some applications use this parameter, so it is important to address it.\n",
    "We could have alternatively set `top_k = 40`, which is a common value for the parameter.\n",
    "In that case, `prefix_str` would have been important to not reject strings starting with \"George Washington\" in case the tokens for \"George Washington\" were not all in the top 40 tokens.\n",
    "\n",
    "Now, we begin by constructing the `relm.SimpleSearchQuery` object.\n",
    "First, notice we pass our `relm.QueryString` object to the `query_string` parameter to specify the strings we are interested in.\n",
    "Second, we say that the `search_strategy` is a `relm.QuerySearchStrategy.SHORTEST_PATH`, which means our traversal order finds the most likely strings first.\n",
    "Alternatively, we could have set this parameter to `relm.QuerySearchStrategy.RANDOM_SAMPLING`, to sample from the set of strings.\n",
    "Third, we specify that the `tokenization_strategy` is a `relm.QueryTokenizationStrategy.ALL_TOKENS`, which means we are interested in all tokenizations of the strings.\n",
    "If we wanted to only use the most compact representation of a string (i.e., what a tokenization encoder would return for that string), we would pass `relm.QueryTokenizationStrategy.CANONICAL_TOKENS`.\n",
    "Fourth, we set the `top_k_sampling` to our `top_k` parameter and set `sequence_length=None` to indicate that for our application, we want to not use `top_k` and our sequences are unlimited in terms of the number of tokens, barring limitations of the model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "4ccd0c47",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-03-31T02:45:41.998559Z",
     "start_time": "2023-03-31T02:45:41.996455Z"
    }
   },
   "outputs": [],
   "source": [
    "top_k = None\n",
    "query = relm.SimpleSearchQuery(query_string=query_string,\n",
    "                               search_strategy=relm.QuerySearchStrategy.SHORTEST_PATH,\n",
    "                               tokenization_strategy=relm.QueryTokenizationStrategy.ALL_TOKENS,\n",
    "                               top_k_sampling=top_k,\n",
    "                               sequence_length=None,\n",
    "                              )"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0684710e",
   "metadata": {},
   "source": [
    "### Search Construction"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "40f1afeb",
   "metadata": {},
   "source": [
    "Now that we have the `query` object, we need to do something with it to get results.\n",
    "To do so, we launch a `relm.search` procedure, which binds the `model` and `tokenizer` to the `query`.\n",
    "In return, we get an [iterator](https://wiki.python.org/moin/Iterator) over the solution space.\n",
    "The iterator, `ret_iter`, will return tokens—the model-specific integers representing the strings—that match our query.\n",
    "Note that search construction will build internal-specific data structures for ReLM, and thus may take a moment to complete."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "aa4d85e4",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-03-31T02:45:43.634121Z",
     "start_time": "2023-03-31T02:45:41.999436Z"
    }
   },
   "outputs": [],
   "source": [
    "ret_iter = relm.search(model, tokenizer, query)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f9a56ef2",
   "metadata": {},
   "source": [
    "## Sampling"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "89ae67b7",
   "metadata": {},
   "source": [
    "We can now launch the query.\n",
    "We'll create a helper function `process_relm_iterator` for processing the iterator.\n",
    "By default, the iterator may return much more strings that we are willing to inspect.\n",
    "For this demo, we truncate the iterator after the first `num_samples=100` samples by setting `itertools.islice(ret_iter, num_samples)`.\n",
    "\n",
    "ReLM comes with some utilities to help us with common tasks, such as predicting the probability of a token sequence.\n",
    "To use these, we need to wrap the model and tokenizer in a model wrapper that ReLM interacts with, a `relm.model_wrapper.TestableModel`.\n",
    "This wrapper is essentially a translation layer between the model + tokenizer and the ReLM backend.\n",
    "\n",
    "In the loop, we return the tuples of tokens that match on the query in the variable `x`.\n",
    "We then add the Beginning of Sequence (BOS) Token back to `x`, since it is used internally as a prefix to the query.\n",
    "We can evaluate the probability of the tokens in `x` by iteratively computing the probability of each token, and we store that value in `p`.\n",
    "Since `p` represents length $n$ vector of probabilities (one for each token), where $n$ is the sequence length, we can calculate the total probability $\\prod_{i=1}^n p_i$ of the sequence.\n",
    "We can also compute the conditional probability $\\prod_{i=j}^n p_i$ for the suffix, where the suffix starts at token $j$.\n",
    "Finally, we convert the sequence `x` to a string `match_string`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "f1ae3084",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-03-31T02:46:27.655680Z",
     "start_time": "2023-03-31T02:45:43.634990Z"
    }
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "10835b59f8b142018f9d909cd357259d",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import itertools\n",
    "\n",
    "def end_of_prefix_idx(test_relm, prefix, tokens):\n",
    "    \"\"\"Find first index where tokens are not in prefix.\"\"\"\n",
    "    i = 0\n",
    "    curr_str = \"\"\n",
    "    stack = list(reversed(tokens))\n",
    "    while not curr_str.startswith(prefix):\n",
    "        curr = stack[-1]\n",
    "        stack.pop(-1)\n",
    "        s = test_relm.tokens_to_words([curr])\n",
    "        curr_str += s\n",
    "        i += 1\n",
    "    return i\n",
    "\n",
    "def process_relm_iterator(ret_iter, num_samples=100):\n",
    "    \"\"\"Retrieve num_samples items and return processed data.\"\"\"\n",
    "    test_relm = relm.model_wrapper.TestableModel(model, tokenizer)\n",
    "\n",
    "    xs = []\n",
    "    matches = []\n",
    "    probs = []\n",
    "    conditional_probs = []\n",
    "    for x in itertools.islice(ret_iter, num_samples):\n",
    "        x = (tokenizer.bos_token_id,) + x  # Add BOS back\n",
    "        p = test_relm.point_query_tokens(x, top_k=top_k)\n",
    "        # Get (conditional) probability of non-prefix\n",
    "        conditional_p_idx = end_of_prefix_idx(\n",
    "            test_relm, query_string.prefix_str, x[1:])\n",
    "        conditional_p = p[conditional_p_idx:]\n",
    "        conditional_p = np.prod(conditional_p)\n",
    "        p = np.prod(p)  # Get total prob\n",
    "        match_string = test_relm.tokens_to_words(x)\n",
    "        xs.append(x)\n",
    "        matches.append(match_string)\n",
    "        probs.append(p)\n",
    "        conditional_probs.append(conditional_p)\n",
    "        \n",
    "    return xs, matches, probs, conditional_probs\n",
    "\n",
    "xs, matches, probs, conditional_probs = process_relm_iterator(ret_iter)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6811b7c8",
   "metadata": {},
   "source": [
    "For this query, let's see what the most likely matches are."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "06a199da",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-03-31T02:46:27.660134Z",
     "start_time": "2023-03-31T02:46:27.656656Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['George Washington was born on July 4, 1732',\n",
       " 'George Washington was born on November 22, 1732',\n",
       " 'George Washington was born on December 22, 1732',\n",
       " 'George Washington was born on January 22, 1732',\n",
       " 'George Washington was born on January 20, 1732',\n",
       " 'George Washington was born on February 22, 1732',\n",
       " 'George Washington was born on April 30, 1732',\n",
       " 'George Washington was born on April 22, 1732',\n",
       " 'George Washington was born on September 22, 1732',\n",
       " 'George Washington was born on December 25, 1732']"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "matches[:10]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "805352be",
   "metadata": {},
   "source": [
    "Hmm, the top answer is not what we wanted 🤔.\n",
    "The expected [birth date](https://en.wikipedia.org/wiki/George_Washington) is February 22, 1732.\n",
    "However, we can see that the correct answer is 6th in this list, so the model is reasonably aware of the correct answer.\n",
    "Unlike the opening example, we know for sure that we get a date in exactly the format we wanted.\n",
    "\n",
    "In fact, let's check that all matches are valid matches according to the regular expression.\n",
    "Just for fun, let's use the Python [re](https://docs.python.org/3/library/re.html) module.\n",
    "Note that ReLM uses a different, internal regular-expression backend, so we should be careful that the syntax is the same.\n",
    "However, in this case, the `query_str` means the same thing in both cases."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "6655fc27",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-03-31T02:46:27.668467Z",
     "start_time": "2023-03-31T02:46:27.661206Z"
    }
   },
   "outputs": [],
   "source": [
    "import re\n",
    "\n",
    "prog = re.compile(query_string.query_str)\n",
    "for match in matches:\n",
    "    assert re.match(prog, match)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "68c0ddb8",
   "metadata": {},
   "source": [
    "✅ Looks good.\n",
    "\n",
    "Finally, let's see that the traversal order goes from most likely to least in terms of total probability.\n",
    "If we were using random sampling, we wouldn't expect this to be the case."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "2f20f0c1",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-03-31T02:46:28.106871Z",
     "start_time": "2023-03-31T02:46:27.670036Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Reference probability: 1.195227810057986e-06\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAagAAAEYCAYAAAAJeGK1AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Il7ecAAAACXBIWXMAAAsTAAALEwEAmpwYAAApXklEQVR4nO3deXRcZ33/8fd3du2yJVnyGmdx7DibnSjbjyUJhWwFwtaShRIoHJcWSrryg5ZfQ5MuLKUUEiDkBBNoIaGEEFIaCIEkZIEscjY7ixNncWzHi7xKstaZ+f7+uFf2RJEs2dLMHUmf1zlzZu4289WciT957vPc55q7IyIiUm5iURcgIiIyHAWUiIiUJQWUiIiUJQWUiIiUJQWUiIiUJQWUiIiUpSkXUGa20sy2mdmaCXq/X5jZbjP72ZD1h5vZQ2a2zsx+aGapifg8EREJTLmAAm4AzpvA9/sS8EfDrP8C8BV3PwrYBXxkAj9TRGTam3IB5e73AjsL15nZkWFLaJWZ3WdmSw7i/X4NdA55PwPeAtwcrvou8K5xFS4iIq+RiLqAErkO+Ji7P29mpwHfIAiYQ9UA7Hb3bLi8EZg7zhpFRKTAlA8oM6sG/g/wo6DhA0A63PYe4MphDtvk7ueWpkIRERnOlA8ogtOYu9192dAN7n4LcMshvOcOoN7MEmErah6waVxViojIa0y5Pqih3L0DeMnM/gCC/iMzO3Gc7+nA3cD7wlWXAT8dV6EiIvIaNtVmMzezG4GzgEZgK3AFcBfwTWA2kARucvfhTu0N9373AUuAaoKW00fc/Q4zOwK4CZgJPAZ8wN37JvavERGZvqZcQImIyNQw5U/xiYjI5DSlBkk0Njb6woULoy5DREQOwqpVq7a7e9PQ9VMqoBYuXEhbW1vUZYiIyEEws/XDrdcpPhERKUsKKBERKUsKKBERKUsKKBERKUsKKBERKUsKKBERKUsKKBERKUsKqNCengGe39o5+o4iIlISCqjQt+97kXP+415yec1NKCJSDhRQocaaNO6wc29/1KWIiAhFDCgzm29md5vZ02b2lJldPsw+ZmZfM7N1ZvakmZ1UsO0yM3s+fFxWrDoHNVSlAdixV3fMEBEpB8Wciy8L/LW7P2pmNcAqM7vT3Z8u2Od8YFH4OI3gnk2nmdlMgvs4tQIeHnubu+8qVrEN1SkAdnSpBSUiUg6K1oJy983u/mj4uhN4Bpg7ZLcLge954EGC26jPBs4F7nT3nWEo3QmcV6xaARrDgNrepRaUiEg5KEkflJktBJYDDw3ZNBfYULC8MVw30vrh3nuFmbWZWVt7e/sh17jvFJ9aUCIiZaHoAWVm1cCPgb9w946Jfn93v87dW929tanpdbcTGbO6iiTxmKkPSkSkTBQ1oMwsSRBO33f3W4bZZRMwv2B5XrhupPVFE4sZDVUptneqBSUiUg6KOYrPgG8Dz7j7v4+w223AB8PRfKcDe9x9M3AHcI6ZzTCzGcA54bqiaqhOqwUlIlImijmK7w3AHwGrzezxcN3fAQsA3P1a4HbgAmAd0A18ONy208yuAh4Jj7vS3XcWsVYgGCixXX1QIiJloWgB5e73AzbKPg58fIRtK4GVRShtRA1VKV7esbeUHykiIiPQTBIFGqrTGsUnIlImFFAFGqvTdPfn6O7PRl2KiMi0p4AqoNkkRETKhwKqgGaTEBEpHwqoAppNQkSkfCigCuw7xadroUREIqeAKtBYHbSgdC2UiEj0FFAFMsk41emE+qBERMqAAmqIhuqU+qBERMqAAmqIhqqU+qBERMqAAmoIzSYhIlIeFFBDNFanNUhCRKQMKKCGaKxOsXNvH/m8R12KiMi0poAaoqEqRd5hV7daUSIiUVJADdEQXgu1Y68CSkQkSgqoIRo0H5+ISFlQQA3RVK35+EREykHR7qhrZiuBtwPb3P24Ybb/LXBpQR3HAE3h7d5fBjqBHJB199Zi1TnUvlN8akGJiESqmC2oG4DzRtro7l9y92Xuvgz4DPAbd99ZsMvZ4faShRNAfUWSmKkPSkQkakULKHe/F9g56o6Bi4Ebi1XLwYjFjJlVafVBiYhELPI+KDOrJGhp/bhgtQO/NLNVZrai1DU1Vqd0sa6ISMSK1gd1EN4BPDDk9N4b3X2Tmc0C7jSzZ8MW2euEAbYCYMGCBRNSUGN1Wn1QIiIRi7wFBVzEkNN77r4pfN4G/AQ4daSD3f06d29199ampqYJKaihOqU+KBGRiEUaUGZWB5wJ/LRgXZWZ1Qy+Bs4B1pSyroYqTRgrIhK1Yg4zvxE4C2g0s43AFUASwN2vDXd7N/BLd99bcGgz8BMzG6zvB+7+i2LVOZyG6hRdfVl6B3JkkvFSfrSIiISKFlDufvEY9rmBYDh64boXgROLU9XYNBbMJjFvRmWUpYiITFvl0AdVdho1m4SISOQUUMPYP2GsRvKJiERFATWMhqrwFF+nWlAiIlFRQA1jVm3QgtrW2RtxJSIi05cCahjpRJz6yiRbO3SKT0QkKgqoETTXZNjaoRaUiEhUFFAjmFWbZmunWlAiIlFRQI2guTbDNrWgREQio4AaQXNtmvbOPvJ5j7oUEZFpSQE1glk1GbJ5Z2e3hpqLiERBATWC5nCouQZKiIhEQwE1glm1GQC2aai5iEgkFFAjaA4DSi0oEZFoKKBG0FQ9OJuEWlAiIlFQQI0glYjRUJVSC0pEJCIKqANoqklruiMRkYgooA6guTajCWNFRCKigDqA5tq0TvGJiESkaAFlZivNbJuZrRlh+1lmtsfMHg8f/1Cw7TwzW2tm68zs08WqcTTNtRnaO/vIaTYJEZGSK2YL6gbgvFH2uc/dl4WPKwHMLA58HTgfWApcbGZLi1jniGbVZsi77qwrIhKFogWUu98L7DyEQ08F1rn7i+7eD9wEXDihxY1Rc0041FwDJURESi7qPqgzzOwJM/u5mR0brpsLbCjYZ2O4blhmtsLM2sysrb29fUKLm6WLdUVEIhNlQD0KHObuJwJXA7ceypu4+3Xu3ururU1NTRNZX8F8fGpBiYiUWmQB5e4d7t4Vvr4dSJpZI7AJmF+w67xwXck1VqcxUwtKRCQKkQWUmbWYmYWvTw1r2QE8Aiwys8PNLAVcBNwWRY3JeIyGqrSmOxIRiUCiWG9sZjcCZwGNZrYRuAJIArj7tcD7gD81syzQA1zk7g5kzewTwB1AHFjp7k8Vq87RNNemdWddEZEIFC2g3P3iUbZfA1wzwrbbgduLUdfBaq7NsFWzSYiIlFzUo/jK3izNxyciEgkF1Chm1WbY3tVHNpePuhQRkWlFATWK5to07rBjb3/UpYiITCsKqFE01+hiXRGRKCigRrH/1u/qhxIRKSUF1Cj2zyahFpSISCkpoEbRUJ0mZuhaKBGRElNAjSIeMxqrNdRcRKTUFFBj0FybYYtaUCIiJaWAGoNFs6p56tUOgpmYRESkFBRQY3Dywhls7+pj/Y7uqEsREZk2FFBjcMrCmQC0rd8VcSUiItOHAmoMjmqqpq4iSdvLh3IHexERORQKqDGIxYzWw2bwiAJKRKRkFFBj1LpwJi+072VHl4abi4iUwpgCyszeYWbTOsxOWTgDgFXqhxIRKYmxhs77gefN7ItmtqSYBZWr4+bWkYrHNFBCRKRExhRQ7v4BYDnwAnCDmf3OzFaYWc1Ix5jZSjPbZmZrRth+qZk9aWarzey3ZnZiwbaXw/WPm1nbQf5NRZFJxjlhXp36oURESmTMp+3cvQO4GbgJmA28G3jUzP58hENuAM47wFu+BJzp7scDVwHXDdl+trsvc/fWsdZYbK0LZ7Jm0x56+nNRlyIiMuWNtQ/qQjP7CXAPkAROdffzgROBvx7uGHe/FxixueHuv3X3wfNlDwLzDqLuSJyycAYDOeeJjbujLkVEZMobawvqPcBX3P14d/+Su28DcPdu4CMTUMdHgJ8XLDvwSzNbZWYrJuD9J8TJhwUDJXQ9lIhI8Y01oLaELaJ9zOwLAO7+6/EUYGZnEwTU/y1Y/UZ3Pwk4H/i4mb35AMevMLM2M2trb28fTymjqq9MsWhWtQZKiIiUwFgD6m3DrDt/vB9uZicA1wMXuvuOwfXuvil83gb8BDh1pPdw9+vcvdXdW5uamsZb0qhaF85k1cu76B1QP5SISDEdMKDM7E/NbDWwJBxxN/h4CXhyPB9sZguAW4A/cvfnCtZXDY4ONLMq4Bxg2JGAUXjb0ll09mU5+9/u4b/bNpDLa4ZzEZFisAPdQsLM6oAZwL8Cny7Y1OnuB+yIMbMbgbOARmArcAXBAAvc/Vozux54L7A+PCTr7q1mdgRBqwkgAfzA3f95LH9Ma2urt7UVf1T6gy/u4F9vf4YnNu5hcXMNV1+ynKObRxxxLyIiB2Bmq4YbsT1aQNW6e4eZzRxu+2ghVWqlCigAd+f21Vv47K2rWdxSw00rzijJ54qITDUjBVRilON+ALwdWEUwss4KtjlwxIRVOMmYGb9/wmy2dPRy1c+e5uGXdnLq4cPmuIiIHIID9kG5+9vD58Pd/YjwefAxbcOp0CWnLqCxOsXVdz0fdSkiIlPKAVtQZnbSgba7+6MTW87kU5GKs+LNR/Avtz/LqvW79l0rJSIi4zPaKb4vH2CbA2+ZwFomrUtPO4xrf/MiV9/1PDd8eMQR8SIichAOGFDufnapCpnMqtIJPvqmw/niL9by5MbdnDCvPuqSREQmvdGug3pL+Pye4R6lKXFy+OAZC6mrSHLNXeuiLkVEZEoY7RTfmcBdwDuG2eYEF9oKUJ1OcP5xLdz59NaoSxERmRJGO8V3Rfj84dKUM7nNrqtgx95++rI50ol41OWIiExqY73dRoOZfc3MHg1nGP+qmTUUu7jJpqUuDcC2jr6IKxERmfzGOlnsTUA7wdRE7wtf/7BYRU1WzbUZALZ19kZciYjI5DdaH9Sg2e5+VcHyP5nZ+4tR0GTWUhcE1JY9akGJiIzXWFtQvzSzi8wsFj7+ELijmIVNRs01YUB1qAUlIjJeo80k0cn+Ofj+AvivcFMM6AL+ppjFTTb1lUlSiRhbFVAiIuM22ig+3UPiIJgZLbUZBZSIyAQYax8UZjYDWARkBtcNvQ28QEtthi17FFAiIuM1poAys48ClwPzgMeB04Hfobn4Xqe5LsPqjbujLkNEZNIb6yCJy4FTgPXh/HzLgd3FKmoya65Js6WjlwPdCFJEREY31oDqdfdeADNLu/uzwOLilTV5tdRl6B3I09GbjboUEZFJbawBtdHM6oFbgTvN7KfA+tEOMrOVZrbNzNaMsN3CGSrWmdmThfefMrPLzOz58HHZGOuM3ODFuhooISIyPmPqg3L3d4cvP2dmdwN1wC/GcOgNwDXA90bYfj7BwItFwGnAN4HTzGwmcAXQSjDMfZWZ3ebuu8ZSb5T2X6zby9HNGgQpInKoxtqCwsxOMrNPAicAG929f7RjwlF+Ow+wy4XA9zzwIFBvZrOBc4E73X1nGEp3AueNtdYo6WJdEZGJMdbJYv8B+C7QADQC3zGzz07A588FNhQsbwzXjbR+uNpWmFmbmbW1t7dPQEnjM6s2mDB2q4aai4iMy1ivg7oUOLFgoMTnCYab/1OR6hozd78OuA6gtbU18qFzmWScGZVJtmrCWBGRcRnrKb5XKbhAF0gDmybg8zcB8wuW54XrRlo/KTTXZjRhrIjIOI12y/erzexrwB7gKTO7wcy+A6xhYq6Dug34YDia73Rgj7tvJpiI9hwzmxHOYHEOk2hy2mZNdyQiMm6jneJrC59XAT8pWH/PWN7czG4EzgIazWwjwci8JIC7XwvcDlwArAO6gQ+H23aa2VXAI+FbXenuBxpsUVZaajM8vbkj6jJERCa10SaL/e7gazNLAUeHi2vdfWC0N3f3i0fZ7sDHR9i2Elg52meUo+a6DNu7+sjm8iTiYx4oKSIiBcY6iu8s4Hng68A3gOfM7M3FK2tya6nN4A7tXeqHEhE5VGMdxfdl4Bx3XwtgZkcDNwInF6uwyaylLhhqvmVPL7PrKiKuRkRkchrr+afkYDgBuPtzhH1J8nqzajTdkYjIeI21BbXKzK5n/x11L2X/AAoZYnC6o60dOsUnInKoxhpQHyMYzPDJcPk+gr4oGcbMyhTJuGm6IxGRcRg1oMwsDjzh7kuAfy9+SZNfLGbMqslouiMRkXEYtQ/K3XPAWjNbUIJ6pozm2rRaUCIi4zDWU3wzCGaSeBjYO7jS3d9ZlKqmgJa6DM9u6Yy6DBGRSWusAfX/ilrFFNRcm+He57ZHXYaIyKR1wIAyswzBAImjgNXAt91d9zIfg5baDF19Wbr6slSnx/r/ASIiMmi0PqjvEtzVdjXB3W+/XPSKpojCO+uKiMjBGy2glrr7B9z9W8D7gDeVoKYpYUlLLWbw7ftfjLoUEZFJabSA2jchrE7tHZzFLTV87MwjufHhDdy+enPU5YiITDqjBdSJZtYRPjqBEwZfm5nuJzGKv3rb0Zw4v55P//hJNu3uibocEZFJ5YAB5e5xd68NHzXunih4XVuqIierZDzG1y5aRt7hL296nFw+8jvSi4hMGrpZUZEd1lDFVe86lodf3qn+KBGRg6CAKoF3L5/HGUc08F8PvkJwj0YRERlNUQPKzM4zs7Vmts7MPj3M9q+Y2ePh4zkz212wLVew7bZi1lkK7z15Hq/s7ObRV3ZHXYqIyKRQtIAKJ5n9OsH1U0uBi81saeE+7v6X7r7M3ZcBVwO3FGzuGdw2FaZUOvfYZjLJGLc+tinqUkREJoVitqBOBda5+4vu3g/cBFx4gP0vJrhL75RUk0nytqUt/OzJV+nP5qMuR0Sk7BUzoOYCGwqWN4brXsfMDgMOB+4qWJ0xszYze9DM3jXSh5jZinC/tvb29gkou3jevXwOu7oHuPe58q5TRKQclMsgiYuAm8Nbeww6zN1bgUuA/zCzI4c70N2vc/dWd29tamoqRa2H7E2LmphZleInj+s0n4jIaIoZUJuA+QXL88J1w7mIIaf33H1T+PwicA+wfOJLLK1kPMY7TpjNr57eSkfvwOgHiIhMY8UMqEeARWZ2uJmlCELodaPxzGwJwf2mflewboaZpcPXjcAbgKeLWGvJvGv5XPqyeX6xZkvUpYiIlLWiBVQ4d98ngDuAZ4D/dvenzOxKMysclXcRcJO/9gKhY4A2M3sCuBv4vLtPiYBaNr+ehQ2VGs0nIjKKot6oyN1vB24fsu4fhix/bpjjfgscX8zaomJmXHD8bK79zQv0DuTIJONRlyQiUpbKZZDEtHLc3DryDuu2dUVdiohI2VJARWBxSw0Az27pjLgSEZHypYCKwMKGKtKJGGu36I4lIiIjUUBFIB4zFjVXqwUlInIACqiILG6uVUCJiByAAioiS1pqaO/sY+fe/qhLEREpSwqoiOwfKKF+KBGR4SigIrIkDKi1Os0nIjIsBVREmmrSzKhMKqBEREaggIqImbG4pUYDJURERqCAitCSllqe29pJPu+j7ywiMs0ooCK0pKWG7v4cG3f1RF2KiEjZUUBFSCP5RERGpoCK0NHNGsknIjISBVSEqtIJFsys5NmtCigRkaEUUBFb3FKjFpSIyDAUUBFb0lLDS9v30juQi7oUEZGyooCK2OKWGnJ5180LRUSGKGpAmdl5ZrbWzNaZ2aeH2f4hM2s3s8fDx0cLtl1mZs+Hj8uKWWeUTpxXT8zgUzc/yUvb90ZdjohI2ShaQJlZHPg6cD6wFLjYzJYOs+sP3X1Z+Lg+PHYmcAVwGnAqcIWZzShWrVGaP7OS6y9r5dU9Pbzj6vv5nydejbokEZGyUMwW1KnAOnd/0d37gZuAC8d47LnAne6+0913AXcC5xWpzsi9ZUkz//vJN3F0czV/fuNj/OP/PEVOs0uIyDRXzICaC2woWN4YrhvqvWb2pJndbGbzD/JYzGyFmbWZWVt7e/tE1B2JufUV/PBPzuBD/2ch33ngZT5502P0ZTVwQkSmr6gHSfwPsNDdTyBoJX33YN/A3a9z91Z3b21qaprwAkspGY/xuXcey99dsIT/fXIzf3zDI3T1ZaMuS0QkEokivvcmYH7B8rxw3T7uvqNg8XrgiwXHnjXk2HsmvMIyteLNR9JQleZTP36SC6+5n7cubWbp7FqOnVPHUbOqoy5PRKQkihlQjwCLzOxwgsC5CLikcAczm+3um8PFdwLPhK/vAP6lYGDEOcBnilhr2XnvyfOYWZ3iy79cy8r7X2IgF/RJfeLso/ibcxdHXJ2ISPEVLaDcPWtmnyAImziw0t2fMrMrgTZ3vw34pJm9E8gCO4EPhcfuNLOrCEIO4Ep331msWsvV2YtncfbiWfRn87zQ3sW3fvMC19y9jlMOn8mZR0/u05kiIqMx96kzWqy1tdXb2tqiLqNoegdyXHjNA2zv6uPnl7+JWbWZqEsSERk3M1vl7q1D10c9SEIOQiYZ55pLltPdn+Pymx7XUHQRmdIUUJPMouYa/vHCY/ndizv46q+ei7ocEZGiKeYgCSmSPzh5Hg+/tJOv3bWOgbzzqXMXY2ZRlyUiMqEUUJOQmfGF955AKhHjm/e8QHtnH//6nuNJxtUgFpGpQwE1ScVjxj+/6ziaazJ85VfPsb2rj7+/4BgWhXfpFRGZ7BRQk5iZcflbF9FYk+Jztz3F275yL8vm1/MHrfM4cV49dRVJajIJajJJ4jGdAhSRyUXDzKeI7V193PrYJn7UtpG1Q24h31id5vLfO4qLTl2g04AiUnZGGmaugJpi3J1nNneyYVc3HT0DdPRmuWPNFh5+eSdHNFbxt+cu5txjW4ipRSUiZUIBNY25O79+Zhuf/8WzrNvWRUtthguXzeHCZXM5ZnaNRgCKSKQUUEI2l+fna7Zw62Ob+M1z7WTzzpFNVVxw/GzOP262wkpEIqGAktfYubef/33yVW5fvYWHXtpB3uGIpio+duaRvHv5XPVViUjJKKBkRNu7+rjz6a18/6H1rNnUwbwZFfzZWUfx3pPnkk7Eoy5PRKY4BZSMyt25e+02vvrrdTyxYTeN1SkuOXUBl55+GM2amFZEikQBJWPm7jywbgc3/PYlfv3sNuJmnLJwJvNnVjBvRiVHNFXx1mOaySTVuhKR8RspoHShrryOmfHGRY28cVEj63fs5T9/t55Vr+zi7rXttHf2AdBUk+YjbzycS09bQE0mGXHFIjIVqQUlB6V3IEfby7u49jcvcP+67dRmEpx2RAMLZlZyWEMls+sqqKtIUl+ZpKEqRUN1OuqSRaTMqQUlEyKTjO9rXT2xYTffeeAlnt7cwX3Pt9M7kH/d/u9aNofPXHCM+rBE5KAVtQVlZucBXyW45fv17v75Idv/CvgowS3f24E/dvf14bYcsDrc9RV3f+don6cWVHTcnfauPrbs6WVPzwB7egZYvXEP33ngZRJx48/fsogPv2Gh+q1E5HVKPkjCzOLAc8DbgI3AI8DF7v50wT5nAw+5e7eZ/Slwlru/P9zW5e7VB/OZCqjys37HXq762TP86pmtpOIxjp1by0kLZrB8QT3HzqnjsJmVmnZJZJqL4hTfqcA6d38xLOAm4EJgX0C5+90F+z8IfKCI9UgEDmuo4vrLWvndCzu4Z+02Hn1lF//54Hq+ff9LAFSnExwzu4bj59Zzwrw6jp9Xx8KGKs2+LiJFDai5wIaC5Y3AaQfY/yPAzwuWM2bWRnD67/PufutwB5nZCmAFwIIFC8ZTrxTRGUc2cMaRDQD0Z/M8t7WTp17dw9OvdrDm1Q5+8PB6Vj4Q9GHFY0ZDVYqmmjQzq1LEY0bcjHjMSMZjJOPBc21FkgUzK1kws5I59RWkEjEMiJkRjxupeIxUIkZlKq6ZMUQmobIYJGFmHwBagTMLVh/m7pvM7AjgLjNb7e4vDD3W3a8DroPgFF9JCpZxSSViHDe3juPm1u1bl83leaF9L09s3M2Gnd20d/axrbOPnXv7ybuTywePbN4ZyOUZyObZ1T1Az0Bu1M9LxIyjZlWzdHYtS+fUsmx+PcfNrVN/mEiZK2ZAbQLmFyzPC9e9hpm9Ffh74Ex37xtc7+6bwucXzeweYDnwuoCSqSERj7G4pYbFLWO/I7C7s72rn1d27uXV3b3k8k7enbxDLp+nP5unL5tnx95+ntncwf3rtnPLY8FPMBk3ls6pY0lzDS11GWbXZWiuzVBbEdzgsTaTpLYiQUUyrgl0RSJSzIB6BFhkZocTBNNFwCWFO5jZcuBbwHnuvq1g/Qyg2937zKwReAPwxSLWKpOQmdFUk6apJs3Jh43tmG2dvTz+ym4efWU3j76yi7vXbqO9q4+RxgolYkZdRZJMMo4ZwYPXBlYyblSk4lQk41SlE8yoTDGjMkV9ZZJMMkYiFiOZiDGvvoLlC+qpr0yN8y8XmR6KFlDunjWzTwB3EAwzX+nuT5nZlUCbu98GfAmoBn4U/l/q4HDyY4BvmVkeiBH0QT097AeJHIRZNRnOObaFc45t2beuP5tnW2cv2zr76OgZoLM3S2dvlo7eATrCIfM9AzlwcIKW22Cryt0ZyDk9Azl6+nPs6Opn3bYudncP0NWXHbaGI5uqOGXhTM5aPIs3LmqkOl0WZ9pFyo5mkhApkoFcPuwvc/pyOV5s38uq9bt4dP0uHn55J529WVLxGKcePpMjm6poqE7TUB20vqrSCarTcWozSVrqMppOSqY0zSQhUmLBiMMYpACSzKrJcPoRwUjGgVyetpd3cdezW7nv+e08uXE3Hb3Dt7gAatIJZtdnSCfi+/rZUokYzTVpmmszzKmv4G1LZ3HUrLH34YmUO7WgRMpEfzbPjr197OkZYG9fcJpxT88AW/b0snlPL5v39DCQc4JLxIy+bI5tHX1s7exld/cAAMvm1/O+k+fxpkWNzKmv0PB6mRTUghIpc6lEjNl1FcyuqzjoY9s7+/jp45v4UdtGPnvrGiC4nmxOfYaW2gzJeIxEPEYiFgzoqErFqUwlmFmVYk59BXPqMsyqTROP7b+WLBFeb5ZKxPZdU6YLqKWU1IISmULcnac3d/DUqx28sqObV3Z2s7Wjd981ZNl8nu7+HN19uaCVNsJAjpEkYkY6EaMiFSeTDEYuZpJx0okY6WSMdCJORSpOZTJOZSpOZTpBdTpBZTjKMRkPRjSm4jGq0sGox6pUgkx47OBzMh5cmK0h/tODWlAi04CZceycOo6dUzf6zgS3T9myp5dX9/TQ3hkMt3/NtWQ5ZyC8nqw/m6c/l6N3IE/PQI7e/hzd/Tn6sjn6snn6BvLsDi+e7ukPArC7P0c2f2j/E2wW9uPFjGQiGK6fiAXBFYsF2yrCkKxIxalOJ6jJJKhOh8P7C45NJ/a3BIPgCy4XSMZjVKRiZBJx0skYMQtCMWYEYZuMk0nF9oVwKh5TaJaQAkpkGssk4yxsrGJhY1VR3t/d6c/l2dsXBNlA1l8TcoMh1jsQrBsMu4FsMAKyL5cnm3OyuTz9uXw4o0gQov25PL39OXoGcnT2Ztm8p5eu3iydvQP0ZfOHHIyjScb3t+wMSCdiVIWtxJpMktl1mfBUbYa6yiS1YWjuvwg8QW1FUv2DY6CAEpGiMTPSiTjpROmnlXLfPzXW4KwifQN58u77rmcbyDm9A0HI9Q7k9q3P56E/F5wOHWwt9ueC9xjI5XEHDy+M68vm6e7Psrc/x+7uftZu7eSete2jTsM1ozK570LzimSCRCzo90uFoz9TiRiJuAWf5U7OnWQ8mFuyMpWgKhWnrjJJfUWKusogGGfVZKZUP6ECSkSmJDPbN7FwqSfvcHc6erN09AzQ0Rtc/N0VXvzd2Ztld/cA7V29tHf20d7Zx669A2TzQWuxf/D6ufD0qhnEYkbMjIFsnu6BHLkRWoeJmNFSl2FGZWrfKc10MrbvNGhFMh6c4gy/n3QyRn1FMOtJbSYZTMwcC05xxgomaR6cqDkVD0JzcB8wajKJot2QVAElIjLBzIIpsuoqJv4C68LTpnt6Btjd3c+u7n5e3d3Lq7t72LS7h46eAfrDluPevVl6wpZgT3+OnPu+VlnvQHDqdDx+//jZfP3Skybor3stBZSIyCRSeNp0ZlUKOPT+w8GQ2t3TT0dPlmw+OH2ZywenFPP5/XcSGMj7vr7B/L7BNM6c+oO/LGKsFFAiItOUWTjRcaqC2WMb+FlSGkYiIiJlSQElIiJlSQElIiJlSQElIiJlSQElIiJlSQElIiJlSQElIiJlSQElIiJlaUrdD8rM2oH143iLRmD7BJUzFej72E/fxX76Ll5L38d+h/pdHObuTUNXTqmAGi8zaxvuplnTlb6P/fRd7Kfv4rX0few30d+FTvGJiEhZUkCJiEhZUkC91nVRF1Bm9H3sp+9iP30Xr6XvY78J/S7UByUiImVJLSgRESlLCigRESlLCqiQmZ1nZmvNbJ2ZfTrqekrJzOab2d1m9rSZPWVml4frZ5rZnWb2fPg8I+paS8XM4mb2mJn9LFw+3MweCn8fPzSzVNQ1loqZ1ZvZzWb2rJk9Y2ZnTNffhpn9ZfjfyBozu9HMMtPpt2FmK81sm5mtKVg37G/BAl8Lv5cnzeyg7wuvgCL4xwj4OnA+sBS42MyWRltVSWWBv3b3pcDpwMfDv//TwK/dfRHw63B5urgceKZg+QvAV9z9KGAX8JFIqorGV4FfuPsS4ESC72Xa/TbMbC7wSaDV3Y8D4sBFTK/fxg3AeUPWjfRbOB9YFD5WAN882A9TQAVOBda5+4vu3g/cBFwYcU0l4+6b3f3R8HUnwT9Acwm+g++Gu30XeFckBZaYmc0Dfh+4Plw24C3AzeEu0+m7qAPeDHwbwN373X030/S3ASSACjNLAJXAZqbRb8Pd7wV2Dlk90m/hQuB7HngQqDez2QfzeQqowFxgQ8HyxnDdtGNmC4HlwENAs7tvDjdtAZqjqqvE/gP4FJAPlxuA3e6eDZen0+/jcKAd+E54yvN6M6tiGv423H0T8G/AKwTBtAdYxfT9bQwa6bcw7n9XFVCyj5lVAz8G/sLdOwq3eXA9wpS/JsHM3g5sc/dVUddSJhLAScA33X05sJchp/Om0W9jBkGr4HBgDlDF6093TWsT/VtQQAU2AfMLlueF66YNM0sShNP33f2WcPXWwSZ5+LwtqvpK6A3AO83sZYJTvW8h6IOpD0/rwPT6fWwENrr7Q+HyzQSBNR1/G28FXnL3dncfAG4h+L1M19/GoJF+C+P+d1UBFXgEWBSOxkkRdHzeFnFNJRP2sXwbeMbd/71g023AZeHry4Cflrq2UnP3z7j7PHdfSPA7uMvdLwXuBt4X7jYtvgsAd98CbDCzxeGq3wOeZhr+NghO7Z1uZpXhfzOD38W0/G0UGOm3cBvwwXA03+nAnoJTgWOimSRCZnYBQd9DHFjp7v8cbUWlY2ZvBO4DVrO/3+XvCPqh/htYQHAbkz9096EdpFOWmZ0F/I27v93MjiBoUc0EHgM+4O59EZZXMma2jGDASAp4Efgwwf/cTrvfhpn9I/B+gpGvjwEfJehXmRa/DTO7ETiL4LYaW4ErgFsZ5rcQhvg1BKdBu4EPu3vbQX2eAkpERMqRTvGJiEhZUkCJiEhZUkCJiEhZUkCJiEhZUkCJiEhZUkCJFJmZ/X04A/aTZva4mZ1WxM+6x8xai/X+IqWUGH0XETlUZnYG8HbgJHfvM7NGguuJRGQUakGJFNdsYPvghZvuvt3dXzWzfzCzR8L7Cl0XXtQ42AL6ipm1hfdeOsXMbgnvtfNP4T4Lw3szfT/c52Yzqxz6wWZ2jpn9zsweNbMfhXMtikwaCiiR4volMN/MnjOzb5jZmeH6a9z9lPC+QhUEraxB/e7eClxLMG3Mx4HjgA+ZWUO4z2LgG+5+DNAB/Fnhh4Yttc8Cb3X3k4A24K+K8yeKFIcCSqSI3L0LOJnghm3twA/N7EPA2eFdWFcTTEh7bMFhg/NArgaeCu/X1UcwzdDg5Jsb3P2B8PV/AW8c8tGnE9x88wEze5xgjrTDJvJvEyk29UGJFJm754B7gHvCQPoT4ASCO7NuMLPPAZmCQwbnccsXvB5cHvxvdugcZUOXDbjT3S8e9x8gEhG1oESKyMwWm9miglXLgLXh6+1hv9D7Xnfg6BaEAzAALgHuH7L9QeANZnZUWEeVmR19CJ8jEhm1oESKqxq42szqCWbAXkdwum83sIbgDqSPHML7rgU+bmYrCW758M3Cje7eHp5KvNHM0uHqzwLPHcJniURCs5mLTDJmthD4WTjAQmTK0ik+EREpS2pBiYhIWVILSkREypICSkREypICSkREypICSkREypICSkREytL/BxpK5qTDGZxRAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Calculate non-date conforming response as a baseline\n",
    "ref_response = \"George Washington was born on this day in 1732\"\n",
    "test_relm = relm.model_wrapper.TestableModel(model, tokenizer)\n",
    "input_ids = torch.tensor([tokenizer.bos_token_id,] +\n",
    "                         tokenizer.encode(ref_response)).reshape(1, -1).to(device)\n",
    "ref_p = test_relm.point_query_tokens(input_ids, top_k=top_k)[1:]  # Don't include BOS prob\n",
    "ref_p = np.prod(ref_p)  # Get total prob\n",
    "print(\"Reference probability: {}\".format(ref_p))\n",
    "\n",
    "def plot_sample_probability(probs, show_ref_prob=False):\n",
    "    \"\"\"Show total probabilities of ReLM's outputs.\"\"\"\n",
    "    plt.plot(probs, label=\"ReLM Output\")\n",
    "    plt.ylabel(\"Probability\")\n",
    "    plt.xlabel(\"Sample\")\n",
    "    if show_ref_prob:\n",
    "        plt.hlines(xmin=0, xmax=len(probs), y=ref_p, colors=\"r\",\n",
    "                   linestyles=\"dashed\", label=\"Example Probability\")\n",
    "    plt.tight_layout()\n",
    "    \n",
    "plot_sample_probability(probs, show_ref_prob=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cb5a1ed2",
   "metadata": {},
   "source": [
    "✅ We see the probability is decreasing over the samples, indicating responses are ordered by likelihood.\n",
    "We also calculate a reference probability for \"George Washington was born on this day in 1732\".\n",
    "We can see that the reference is actually _higher_ likelihood than the dates ReLM found—perhaps because the model doesn't have to commit to a particular date."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ca7d4ddb",
   "metadata": {},
   "source": [
    "# Extra Queries"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "705f20f1",
   "metadata": {},
   "source": [
    "### Anything Goes and Free Response"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9474e61c",
   "metadata": {},
   "source": [
    "Building on the introduction example, what if we didn't constrain ReLM to use a date?\n",
    "`(( )|([a-zA-Z0-9])|(,))+` represents spaces, commas, and alphanumeric characters 1+ times."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "d57c1a5c",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-03-31T02:46:38.811091Z",
     "start_time": "2023-03-31T02:46:28.108544Z"
    }
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "52bddfc0160040bcbcf6e53bed51b867",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "['George Washington was born on this',\n",
       " 'George Washington was born on December',\n",
       " 'George Washington was born on this day',\n",
       " 'George Washington was born on January',\n",
       " 'George Washington was born on April',\n",
       " 'George Washington was born on this day in',\n",
       " 'George Washington was born on July',\n",
       " 'George Washington was born on this day in 17',\n",
       " 'George Washington was born on February',\n",
       " 'George Washington was born on March',\n",
       " 'George Washington was born on November',\n",
       " 'George Washington was born on this day in 1732',\n",
       " 'George Washington was born on the',\n",
       " 'George Washington was born on May',\n",
       " 'George Washington was born on June',\n",
       " 'George Washington was born on September',\n",
       " 'George Washington was born on October',\n",
       " 'George Washington was born on July 4',\n",
       " 'George Washington was born on August',\n",
       " 'George Washington was born on July 4,']"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "query_string = relm.QueryString(query_str=\"George Washington was born on (( )|([a-zA-Z0-9])|(,))+\",\n",
    "                                prefix_str=\"George Washington was born on\",\n",
    "                               )\n",
    "top_k = None\n",
    "query = relm.SimpleSearchQuery(query_string=query_string,\n",
    "                               search_strategy=relm.QuerySearchStrategy.SHORTEST_PATH,\n",
    "                               tokenization_strategy=relm.QueryTokenizationStrategy.ALL_TOKENS,\n",
    "                               top_k_sampling=top_k,\n",
    "                               sequence_length=None,\n",
    "                              )\n",
    "ret_iter = relm.search(model, tokenizer, query)\n",
    "\n",
    "xs, matches, probs, conditional_probs = process_relm_iterator(ret_iter, num_samples=20)\n",
    "matches"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "03bda1e4",
   "metadata": {},
   "source": [
    "Look at that: \"George Washington was born on this day in 1732\" appears again.\n",
    "Random sampling sees it come up often because it's likely.\n",
    "Notice that we have limited control over how complete a sentence may be, since our regular expression technically allows a sequence to be complete with only one character."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7c326649",
   "metadata": {},
   "source": [
    "### Multiple Choice"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ea33d9f1",
   "metadata": {},
   "source": [
    "We can also use ReLM to construct multiple choice queries. Here, we pick between the 4 dates: `((February 23, 1973)|(March 30, 1973)|(February 1, 1873)|(February 22, 1732))`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "1a00af27",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-03-31T02:47:14.271937Z",
     "start_time": "2023-03-31T02:46:38.811959Z"
    }
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "9e07127a45ff4fb8938a7d757e51c3a3",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "['George Washington was born on February 22, 1732',\n",
       " 'George Washington was born on February 22, 1732',\n",
       " 'George Washington was born on February 1, 1873',\n",
       " 'George Washington was born on February 23, 1973',\n",
       " 'George Washington was born on February 22, 1732',\n",
       " 'George Washington was born on March 30, 1973',\n",
       " 'George Washington was born on February 22, 1732',\n",
       " 'George Washington was born on February 22, 1732',\n",
       " 'George Washington was born on February 22, 1732',\n",
       " 'George Washington was born on February 23, 1973',\n",
       " 'George Washington was born on February 22, 1732',\n",
       " 'George Washington was born on March 30, 1973',\n",
       " 'George Washington was born on February 22, 1732',\n",
       " 'George Washington was born on February 22, 1732',\n",
       " 'George Washington was born on February 1, 1873',\n",
       " 'George Washington was born on February 23, 1973',\n",
       " 'George Washington was born on February 1, 1873',\n",
       " 'George Washington was born on February 22, 1732',\n",
       " 'George Washington was born on March 30, 1973',\n",
       " 'George Washington was born on February 22, 1732']"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "query_string = relm.QueryString(query_str=(\"George Washington was born on ((February 23, 1973)|\"\n",
    "                                           \"(March 30, 1973)|(February 1, 1873)|(February 22, 1732))\"),\n",
    "                                prefix_str=\"George Washington was born on\",\n",
    "                               )\n",
    "top_k = None\n",
    "query = relm.SimpleSearchQuery(query_string=query_string,\n",
    "                               search_strategy=relm.QuerySearchStrategy.SHORTEST_PATH,\n",
    "                               tokenization_strategy=relm.QueryTokenizationStrategy.ALL_TOKENS,\n",
    "                               top_k_sampling=top_k,\n",
    "                               sequence_length=None,\n",
    "                              )\n",
    "ret_iter = relm.search(model, tokenizer, query)\n",
    "\n",
    "xs, matches, probs, conditional_probs = process_relm_iterator(ret_iter, num_samples=20)\n",
    "matches"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2dd096a5",
   "metadata": {},
   "source": [
    "✅ Here, the model is able to guess the right answer.\n",
    "But why are there duplicates? 🤔\n",
    "\n",
    "Well, technically there aren't.\n",
    "The token sequences are unique, but two sequences can map to the same string due to the way tokenization is performed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "b51628e7",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-03-31T02:47:14.276336Z",
     "start_time": "2023-03-31T02:47:14.272810Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('George Washington was born on February 22, 1732',\n",
       "  (50256, 20191, 2669, 373, 4642, 319, 3945, 2534, 11, 1596, 2624)),\n",
       " ('George Washington was born on February 22, 1732',\n",
       "  (50256, 20191, 2669, 373, 4642, 319, 3158, 622, 560, 2534, 11, 1596, 2624)),\n",
       " ('George Washington was born on February 1, 1873',\n",
       "  (50256, 10082, 3643, 2669, 373, 4642, 319, 3945, 352, 11, 1248, 4790)),\n",
       " ('George Washington was born on February 23, 1973',\n",
       "  (50256, 10082, 3643, 2669, 373, 4642, 319, 3945, 2242, 11, 15674)),\n",
       " ('George Washington was born on February 22, 1732',\n",
       "  (50256, 20191, 2669, 373, 4642, 319, 3158, 81, 2838, 2534, 11, 1596, 2624))]"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(zip(matches, xs))[:5]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9cee786f",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-03-29T14:36:47.592090Z",
     "start_time": "2023-03-29T14:36:47.590137Z"
    }
   },
   "source": [
    "Let's remove the duplicates by enforcing the tokenization is canonical, which requires each string to have a unique encoding.\n",
    "Notice that `tokenization_strategy=relm.QueryTokenizationStrategy.CANONICAL_TOKENS`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "1353e2ad",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-03-31T02:47:17.289476Z",
     "start_time": "2023-03-31T02:47:14.277186Z"
    }
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "69091bd22f9f4132b73ed4e9b831793b",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "['George Washington was born on February 22, 1732',\n",
       " 'George Washington was born on March 30, 1973',\n",
       " 'George Washington was born on February 23, 1973',\n",
       " 'George Washington was born on February 1, 1873']"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "query_string = relm.QueryString(query_str=(\"George Washington was born on ((February 23, 1973)|\"\n",
    "                                           \"(March 30, 1973)|(February 1, 1873)|(February 22, 1732))\"),\n",
    "                                prefix_str=\"George Washington was born on\",\n",
    "                               )\n",
    "top_k = None\n",
    "query = relm.SimpleSearchQuery(query_string=query_string,\n",
    "                               search_strategy=relm.QuerySearchStrategy.SHORTEST_PATH,\n",
    "                               tokenization_strategy=relm.QueryTokenizationStrategy.CANONICAL_TOKENS,\n",
    "                               top_k_sampling=top_k,\n",
    "                               sequence_length=None,\n",
    "                              )\n",
    "ret_iter = relm.search(model, tokenizer, query)\n",
    "\n",
    "xs, matches, probs, conditional_probs = process_relm_iterator(ret_iter, num_samples=20)\n",
    "matches"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "b1ca7bf9",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-03-31T02:47:17.292578Z",
     "start_time": "2023-03-31T02:47:17.290288Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(set(xs)) == len(matches)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "14dd7620",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-03-29T14:39:35.496563Z",
     "start_time": "2023-03-29T14:39:35.493481Z"
    }
   },
   "source": [
    "✅ We see that there are only 4 choices, as expected.\n",
    "Furthermore, the right answer is at the top."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "b06be920",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-03-31T02:47:17.358116Z",
     "start_time": "2023-03-31T02:47:17.293378Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAH6CAYAAAAKi0slAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Il7ecAAAACXBIWXMAAAsTAAALEwEAmpwYAAAzN0lEQVR4nO3deZgsVZXu/+8LCCIyCaedQEHEAZXJA6Joi1M3aCOKqOCENopja2u33U6tNNqOV71XRPvyEwW1BQUnfojgxCQyHeZBUURREOXILMj83j8iCpKi6tSQuSsqcr+f56nnZERk1VmVz6pcuXes2CHbREREvVbqOoCIiOhWCkFEROVSCCIiKpdCEBFRuRSCiIjKpRBERFSul4VA0hclXSnp/BH9vKMlXSvpyEn7N5Z0qqSLJX1d0qqj+P8iIhaTXhYC4CBgxxH+vE8Ar5xi/8eAT9t+JHANsNcI/8+IiEWhl4XA9gnA1YP7JG3SfrI/Q9KJkh4zh5/3Y+CGST9PwDOBw9tdBwMvGCrwiIhFaJWuAxihA4A32P6VpCcBn6N5I5+v9YBrbd/ebl8GPHTIGCMiFp2xKASS7g88BTis+SAPwGrtsV2Bfaf4tstt//3CRBgRsXiNRSGgmeK61vaWkw/Y/hbwrXn8zKuAdSSt0o4KNgAuHyrKiIhFqJfnCCazfT3wG0kvhmZ+X9IWQ/5MA8cCu7W79gS+O1SgERGLkPq4+qikQ4AdgPWBPwEfAH4CfB54MHAf4FDbU00JTfXzTgQeA9yfZiSwl+1jJD0COBR4AHAW8Arbt4z2t4mI6FYvC0FERIzOWEwNRUTE/PXuZPH666/vjTbaqOswIiJ65Ywzzviz7SVTHetdIdhoo41YtmxZ12FERPSKpEunO5apoYiIyqUQRERULoUgIqJyKQQREZVLIYiIqFwKQURE5VIIIiIql0IQEVG5FIKIiMr17sriYWz0ru91HUKnfvvR53UdQkQsQhkRRERULoUgIqJyKQQREZVLIYiIqFwKQURE5VIIIiIql0IQEVG5FIKIiMqlEEREVC6FICKicikEERGVSyGIiKhcCkFEROVSCCIiKpdCEBFRuRSCiIjKpRBERFQuhSAionIpBBERlUshiIioXApBRETlihUCSV+UdKWk86c5LkmfkXSxpHMlbV0qloiImF7JEcFBwI4rOL4TsGn7tTfw+YKxRETENIoVAtsnAFev4Cm7AF924xRgHUkPLhVPRERMrctzBA8Ffj+wfVm7714k7S1pmaRly5cvX5DgIiJq0YuTxbYPsL3U9tIlS5Z0HU5ExFjpshBcDmw4sL1Buy8iIhZQl4XgCOBVbffQdsB1tq/oMJ6IiCqtUuoHSzoE2AFYX9JlwAeA+wDY/m/gKOC5wMXATcBrSsUSERHTK1YIbO8xw3EDby71/0dExOz04mRxRESUk0IQEVG5FIKIiMqlEEREVC6FICKicikEERGVSyGIiKhcCkFEROVSCCIiKpdCEBFRuRSCiIjKpRBERFQuhSAionIpBBERlUshiIioXApBRETlUggiIiqXQhARUbkUgoiIyqUQRERULoUgIqJyKQQREZVLIYiIqFwKQURE5VIIIiIql0IQEVG5FIKIiMqlEEREVK5oIZC0o6SLJF0s6V1THH+YpGMlnSXpXEnPLRlPRETcW7FCIGllYH9gJ2AzYA9Jm0162vuAb9jeCtgd+FypeCIiYmolRwTbAhfbvsT2rcChwC6TnmNgrfbx2sAfCsYTERFTKFkIHgr8fmD7snbfoH2AV0i6DDgK+KepfpCkvSUtk7Rs+fLlJWKNiKhW1yeL9wAOsr0B8FzgK5LuFZPtA2wvtb10yZIlCx5kRMQ4K1kILgc2HNjeoN03aC/gGwC2TwbuC6xfMKaIiJikZCE4HdhU0saSVqU5GXzEpOf8DngWgKTH0hSCzP1ERCygYoXA9u3AW4BjgJ/TdAddIGlfSc9vn/YvwOsknQMcArzatkvFFBER97ZKyR9u+yiak8CD+94/8PhCYPuSMURExIp1fbI4IiI6lkIQEVG5FIKIiMqlEEREVC6FICKicikEERGVm1UhkLTzVEs/RERE/832zf2lwK8kfVzSY0oGFBERC2tWhcD2K4CtgF8DB0k6uV0RdM2i0UVERHGznu6xfT1wOM19BR4MvBA4U9KUS0dHREQ/zPYcwS6Svg0cB9wH2Nb2TsAWNOsFRURET812raFdgU/bPmFwp+2bJO01+rAiImKhzHZq6I+Ti4CkjwHY/vHIo4qIiAUz20LwnCn27TTKQCIiohsrnBqS9EbgTcAmks4dOLQmcFLJwCIiYmHMdI7ga8D3gY8A7xrYf4Ptq4tFFRERC2amQmDbv5X05skHJD0gxSAiov9mMyL4B+AMwIAGjhl4RKG4IiJigaywENj+h/bfjRcmnIiIWGgznSzeekXHbZ852nAiImKhzTQ19MkVHDPwzBHGEhERHZhpaugZCxVIRER0Y6apoWfa/omkXac6bvtbZcKKiIiFMtPU0NOBnwA7T3HMQApBRETPzTQ19IH239csTDgREbHQZrsM9XqSPiPpTElnSPo/ktYrHVxERJQ320XnDgWWAy8Cdmsff71UUBERsXBmWwgebPuDtn/Tfn0IeOBM3yRpR0kXSbpY0rumec5LJF0o6QJJX5tL8BERMbzZ3pjmB5J2B77Rbu8GHLOib5C0MrA/zRLWlwGnSzrC9oUDz9kUeDewve1rJP3NXH+BiIgYzkztozdw9xpD/wx8tT20EvAX4F9X8O3bAhfbvqT9WYcCuwAXDjzndcD+tq8BsH3l3H+FiIgYxgqnhmyvaXut9t+VbK/Sfq1ke60ZfvZDgd8PbF/W7hv0KOBRkk6SdIqkHaf6QZL2lrRM0rLly5fP9DtFRMQczHZqCEnrApsC953YN/n2lfP8/zcFdgA2AE6Q9ATb1w4+yfYBwAEAS5cu9ZD/Z0REDJhVIZD0WuBtNG/WZwPbASez4rWGLgc2HNjeoN036DLgVNu3Ab+R9EuawnD6bOKKiIjhzbZr6G3ANsCl7fpDWwHXzvA9pwObStpY0qrA7sARk57zHZrRAJLWp5kqumSWMUVExAjMthDcbPtmAEmr2f4F8OgVfYPt24G30HQX/Rz4hu0LJO0r6fnt044BrpJ0IXAs8E7bV83nF4mIiPmZ7TmCyyStQ/MJ/oeSrgEunembbB8FHDVp3/sHHht4R/sVEREdmFUhsP3C9uE+ko4F1gaOLhZVREQsmLl0DW0NPJXmuoKTbN9aLKqIiFgws1107v3AwcB6wPrAlyS9r2RgERGxMGY7Ing5sMXACeOP0rSRfqhQXBERsUBm2zX0BwYuJANW497XBERERA/NtNbQfjTnBK4DLpD0w3b7OcBp5cOLiIjSZpoaWtb+ewbw7YH9xxWJJiIiFtxMt6o8eOJxe3Xwo9rNi9plISIioudmu9bQDjRdQ7+lWZJ6Q0l7jmDRuYiI6Nhsu4Y+Cfyd7YsAJD0KOAR4YqnAIiJiYcy2a+g+E0UAwPYvgfuUCSkiIhbSbEcEZ0j6Anffoezl3H0iOSIiemy2heANwJuBt7bbJwKfKxJRREQsqBkLQXsT+nNsPwb4VPmQIiJiIc14jsD2HcBFkh62APFERMQCm+3U0Lo0VxafBtw4sdP286f/loiI6IPZFoL/KBpFRER0Zqa1hu5Lc6L4kcB5wIHtLSgjImJMzHSO4GBgKU0R2InmwrKIiBgjM00NbWb7CQCSDiQrjkZEjJ2ZRgR3LSyXKaGIiPE004hgC0nXt48FrN5uC7DttYpGFxERxc20DPXKCxVIRER0Y7aLzkVExJhKIYiIqFwKQURE5VIIIiIqV7QQSNpR0kWSLpb0rhU870WSLGlpyXgiIuLeihWCdvnq/WmuSN4M2EPSZlM8b03gbcCppWKJiIjplRwRbAtcbPsS27cChwK7TPG8DwIfA24uGEtEREyjZCF4KPD7ge3L2n13kbQ1sKHt763oB0naW9IyScuWL18++kgjIirW2cliSSvR3PHsX2Z6ru0DbC+1vXTJkiXlg4uIqEjJQnA5sOHA9gbtvglrAo8HjpP0W2A74IicMI6IWFglC8HpwKaSNpa0KrA7cMTEQdvX2V7f9ka2NwJOAZ5ve1nBmCIiYpJihaBdrfQtwDHAz4Fv2L5A0r6ScovLiIhFYra3qpwX20cBR03a9/5pnrtDyVgiImJqubI4IqJyKQQREZVLIYiIqFwKQURE5VIIIiIql0IQEVG5FIKIiMqlEEREVC6FICKicikEERGVSyGIiKhcCkFEROVSCCIiKpdCEBFRuRSCiIjKpRBERFQuhSAionIpBBERlUshiIioXApBRETlUggiIiqXQhARUbkUgoiIyqUQRERULoUgIqJyKQQREZVLIYiIqFzRQiBpR0kXSbpY0rumOP4OSRdKOlfSjyU9vGQ8ERFxb8UKgaSVgf2BnYDNgD0kbTbpaWcBS21vDhwOfLxUPBERMbWSI4JtgYttX2L7VuBQYJfBJ9g+1vZN7eYpwAYF44mIiCmULAQPBX4/sH1Zu286ewHfn+qApL0lLZO0bPny5SMMMSIiFsXJYkmvAJYCn5jquO0DbC+1vXTJkiULG1xExJhbpeDPvhzYcGB7g3bfPUh6NvBe4Om2bykYT0RETKHkiOB0YFNJG0taFdgdOGLwCZK2Av4v8HzbVxaMJSIiplGsENi+HXgLcAzwc+Abti+QtK+k57dP+wRwf+AwSWdLOmKaHxcREYWUnBrC9lHAUZP2vX/g8bNL/v8RETGzRXGyOCIiupNCEBFRuRSCiIjKpRBERFQuhSAionIpBBERlUshiIioXApBRETlUggiIiqXQhARUbkUgoiIyqUQRERULoUgIqJyKQQREZVLIYiIqFwKQURE5VIIIiIql0IQEVG5FIKIiMqlEEREVC6FICKicikEERGVSyGIiKhcCkFEROVSCCIiKpdCEBFRuRSCiIjKpRBERFSuaCGQtKOkiyRdLOldUxxfTdLX2+OnStqoZDwREXFvxQqBpJWB/YGdgM2APSRtNulpewHX2H4k8GngY6XiiYiIqZUcEWwLXGz7Etu3AocCu0x6zi7Awe3jw4FnSVLBmCIiYpJVCv7shwK/H9i+DHjSdM+xfbuk64D1gD8PPknS3sDe7eZfJF1UJOLy1mfS77aQ1P/xVqev35jIazicPr9+D5/uQMlCMDK2DwAO6DqOYUlaZntp13H0VV6/4eU1HM64vn4lp4YuBzYc2N6g3TflcyStAqwNXFUwpoiImKRkITgd2FTSxpJWBXYHjpj0nCOAPdvHuwE/se2CMUVExCTFpobaOf+3AMcAKwNftH2BpH2BZbaPAA4EviLpYuBqmmIxzno/vdWxvH7Dy2s4nLF8/ZQP4BERdcuVxRERlUshiIioXApBRETlUggKknSfKfat30UsfSPpQZIe1D5eImlXSY/rOq4+kbSSpJXax6tK2lrSA7qOqw/a/Pu8pP0lrSdpH0nnSfqGpAd3Hd+opRAUIOkZki4DrpD0g0mL6f2go7B6Q9LrgZOBUyS9ETgSeB7wLUl7dRpcT0h6AXAFcLmkXYATgU8A50raucvYeuIg4EKalQ+OBf4KPJfmdfzv7sIqI11DBUg6HXh12y67G/AR4JW2T5F0lu2tOg5xUZN0Hs1yJKsDlwKPtP1HSesCx9ressv4+kDSWTQLPq4OnANsY/siSQ8HvjmOV8eO0uDfqaTf2X7YwLGzxy0He7HERA+tavsCANuHS/o5zafZfwdSeWd2m+2bgJsk/dr2HwFsXyMpr98sTbxu7RvZRe2+Syemi2KFBl+jL6/g2FgYu19okbhtYn4boC0KzwL2ATbtKqge8cD5ledN7JR0X5Kzszbwhv+PA/tWBlbtJqJe+a6k+wPYft/ETkmPBH7ZWVSFZGqoAEnPBpbbPmfS/nWAN9v+r04C6wlJDwOusH3bpP0PBR5r+0fdRNYfkrYBzrN986T9GwFPtf3VTgKLRSmFICJiEklvBb5l+7KuY1kIGWYXIOkxkr4v6XuSNpF0kKRrJZ0m6bFdx7fYSbpa0hck5UZF8yTpTEnvk7RJ17H01AeB0ySdKOlNkpZ0HVBJKQRlHAB8Dvgq8BPgaGBdmuT6bIdx9cVy4GxgX+AySf9H0nbdhtQ76wLrAMe2H0DeLukhHcfUJ5fQLJ3/QeCJwIWSjpa0p6Q1uw1t9DI1VMCk1rOL23syTxw70/bW3UW3+A2+Ru35gt3br3WAQ22/p8PwemHSa/g0YA9gV+DnwCHtzZ5iGpP/TtvmhZ1oXsdn2x6rEUJGBGWsPPD4U5OOpWNjZndNB9n+ne2Pt3+UzwVu6S6sfrJ9ou030dwa9mPAkzsOqQ/uMSVp+zbbR9jegxXc8rGvch1BGftLur/tv9j+3MTOtvUsHS8zO3aqnbZ/AfznAsfSV/dqcbR9B8005dELH07vvHS6A+01LmMlU0MREVNopyWvt31t23a7FPiF7fO7jWz0UggKkPQpmsv4T+o6lr6S9AzgRTT3tL6D5hPuF2xf3GlgPSLpETTnBQZfw6/Zvr7TwHpA0ruA19NMRf4v4F+Bk4DtgANtT57y7bUUggIkLadZI2cJ8HWak3NndRtVf0j6CPAg4MfAC4Df0LyJvQn4sO3DuouuHyS9jeaq7BNozq2cBVwLvBB4k+3jOguuByRdQDMCuB/wW+ARtpdLWgM41fbju4xv1FIICpjoGpL0KJq5xt1pTiAfQlMUxu4S9VGSdJ7tJ7SPVwGOt719u+jcieP2R1hCu3DflrbvkHQ/4CjbO7TTHd/NwocrJulc25u3S3JcATzI9p3tsfPHLQfTNVSGAWz/0vYHbT8OeAlwX+CoTiPrhzsH1s1/CG0Xlu1rmNTNESs00QyyGjCxbs7vgHvdJyPu5UxJXwO+RTMyPVjSyyUdSLM89VhJ11AZ93qzsn0ucC7w7oUPp3c+DJwl6ZfAo4E3QnODGpollWNmXwBOl3Qq8DSattGJ1/DqLgPridcCL6b5UHc4sC3wMuAiYP8O4yoiU0MFTLSOdh1Hn7UjgkcAF9u+tuNweknNHd0eC5zftt5GTCmFYIFJekz+KOcvr9/w8kFlOJK+b3unruMYpRSCBTb5bkcxN3n9hpfXcGaSplsGRsCRtsfqvsU5R1CApM9Md4hmvZxYgbx+w5P0jukO0Z44jhU6HTieqZsT1lnYUMrLiKAASTcA/8LU6+J80vb6CxxSr+T1G56km2luVn/7FIffbnudhY2oXySdD7zQ9q+mOPZ72xt2EFYxGRGUcTrNCbqfTT4gaZ+FD6d38voN70zgO7bPmHxA0ms7iKdv9mH69vp/WsA4FkRGBAW0HS83j+PiVAshr9/wJD0auMr2n6c49kDbf+ogrFikUggiIiqXK4sjIiqXQhARUbkUgoiIWZK0dBzv/ZxzBAtI0oeB62jW1b+q63j6Jq/f8CS9CbiK5n4ZU7WWxgpIOhjYHPil7WnvYtY3GREsrNNo+ro/3XUgPZXXb3gCnkqzqmbMke092yW8x6oFNyOCiIg5GMf1rjIiKETS30vaq73X6eD+f+wopN6QtIqk10s6WtK57df3Jb1BUtbSnwU1XiLpxe3jZ0n6jKQ3Scrf/XB+0HUAo5YRQQHtXPZTaa7u3Bn437b3a4+daXu6Ba0CkHQIzW0VDwYua3dvAOwJPGCc5mZLkfQ54G+AVYHraW5OcwTN7Sv/ZPttHYa36M2w3tWettdayHhKSyEooL1N4Fa2b5e0DvA14CLbb5+4jWW3ES5ukn5p+1FzPRZ3m7jdZzuC+iPwYNu3trf+PNP25h2HuKjVtt5V1hoqY5WJjgzb10raGThA0mE0n9Bixa6W9GKazpaJ+8SuRHPHqGs6jaw/JvLvNkmn27613b5d0p3dhtYLVa13lbnCMn4t6ekTG7bvsL0XzW3uHttdWL2xO7Ab8CdJv5T0K+BPwK7tsZjZHyVN3Kd4x4mdkh4E3NpZVP2xG3D2VAdsb7ywoZSXqaECJK0OYPuvUxx7qO3LFz6qfpK0HkCuGxgNSWsAa9i+sutYYvHIiKAA23+1/ddpOlymmnOMSSRtK2mbtgA8UNI7JI3V7QEXwuQctH0jkKmhuIcUggIkPUPSZcAVkn4wqYV07FrPRk3SB4DPAJ+X9BHgs8AawLslvbfT4HoiORhzkUJQxseBv287Cw4Afihpu/bYVLe+i3vaDdge+FvgzcALbH8Q+HsgraOzkxwcAUlP6DqGhZBCUMaqti8AsH048ALgYEkvAHJSZma3tyfYbwJ+bft6uOucS6Y1Zic5OBqfk3RaeyHe2l0HU0oKQRm3td0ZALR/kM+iuf3dpl0F1SO3Srpf+/iJEzvbP8QUgtlJDo6A7acBLwc2BM6Q9DVJz+k4rJFL11ABkp4NLLd9zqT9awNvsf1f3UTWD5JWs32vk+qS1qe5MOq8DsLqleTgaElamWZU9RmaK7UFvMf2WCzel0IQETENSZsDr6FZmuOHwIG2z2zvSXCy7Yd3GuCIpBBERExD0vHAF4DDJ18XJOmVtr/STWSjlUIQETGFdjroK7Zf1nUspeVkcUG1tJ7F4pUcnD/bdwAbShr79cEyIihI0ok0y/8eBPyP7eu6jahfJO0KfIxmOWW1Xx63JYBLSg4OR9KXadYHOwK4cWK/7U91FlQBGREUVEvrWUEfB55ve23ba9leM0VgbpKDQ/s1cCTNe+WaA19jJSOCBTDurWelSDrJ9vZdxzEOkoOxIikEBdXSejZq7ZQQwNOBBwHfYWCxvrx5zV5ycDiSlgD/BjwOuO/EftvP7CyoAnJjmrL2o2k9e89g65ntP0h6X3dhLXo7Dzy+Cfi7gW0DKQSzlxwczv8AXwf+AXgDze1Sl3caUQEZERRSU+tZLE7JweFJOsP2EyWdO3F7z/aOb9t0Hdso5WRxITW1npUi6eD2ns8T2+tK+mKHIfVKcnAkbmv/vULS8yRtBTygy4BKyNRQWb8BTpI01q1nBW1u+9qJDdvXtH+IMXvJweF8qF2f6V9optnWAt7ebUijl0JQ1q/br4nWs5iblSSta/saAEkPIDk7V8nBIdg+sn14HfCMLmMpKecIYtGS9CrgPcBh7a4XA/81Luu7xOIn6UtMcf8G2//YQTjF5NNVQbW0npUgaSXgYmBXYOL12tX2hd1F1T/JwaEdOfD4vsALgT90FEsxKQRlVdF6VoLtOyXtb3srIG/+85ccHILtbw5uSzoE+GlH4RSTrqGy1rN9IHCb7ePb4WQ+ic3ejyW9SFLusTt/ycHR2pRm7auxkhFBWfdoPaMZUo5d61lBrwfeAdwu6Way6Nx8JAeHIOkG7nmO4I/Av3cUTjE5WVyQpH8ATqRZ8Gui9ew/bR/RaWBRjeTg/LUj0Q1t/67rWEpLIYhFTdK6NMPxwROdJ3QXUdRE0nm2x/6eDpkaKqiW1rNSJL0WeBuwAXA2sB1wMpnjnrXk4NDOlLSN7dO7DqSkFIKyqmg9K+htwDbAKbafIekxwIc7jqlvkoPDeRLwckmX0lyZPXGeavNuwxqtTA0toLY3/qe2n9J1LH0wsbiXpLOBJ9m+RdIFth/XdWx9lRycG0lTLtNt+9KFjqWkjAgW1li2nhV0Wbvo3HeAH0q6BhirP8AOJAfnwPalkrYGnkozxXaS7TM7DmvkMiIoaJrWs3dPvkglZibp6cDawNG2b+06nr5IDg5H0vtpljaZuAfGC4DDbH+os6AKSCEopKbWs1FrF5eblu2rFyqWPksODk/SRcAWtm9ut1cHzrb96G4jG61MDRVi25K+B4x961kBfwYuA25vtwevLDbwiAWPqIeSgyPxB5qT7De326sBl3cXThkpBGVV0XpWwGdolvw9CTiE5uRmhq7zkxycB0n70XzouA64QNIP2+3nAKd1GVsJmRoqSNIvgEfSnOAc29azEtppjR2APYBtgR8An7f9my7j6pvk4PxI2nNFx20fvFCxLIQUgoJqaT0rqe0a2h34IM0N2P+/biPql+Tg8NrzAg+zfVHXsZSS1UcLav/Y1gN2AZ5PsxJk/gBnIGkNSS+T9F3gKOD+wBNTBOYuOTgcSTvTXNV+dLu9ZXvbz7GSEUFBtbSejZqkG4FfAYe2/94jSW1/a6rvi3tLDg5H0hk0S5oc194bA0nn2358t5GNVgpBQbW0no2apIOYYn2clrNOzuwlB4cj6RTb20k6a6AQnDtu51jSNVRWFa1no2b71V3HMEaSg8O5QNLLgJUlbQq8FfhZxzGNXApBAbW1nsXikxwcmX8C3gvcAnwNOAYYu2m1TA0VUFvrWSw+ycHhSHqL7c+2jx9n+4KuYyophaCwGlrPYnFLDs6dpDNtbz358bhK+2hBtbSelSTpKW0r6asmvrqOqU+SgyOhmZ/SbzlHUNY+NFfFHgdg+2xJWSdnliR9BdiE5o3sjna3gS93FVMP7UNycD7WkfRCmg/La0nadfDguLUwpxCUdZvt65rVEu5yZ1fB9NBSYLOsMzSU5OD8HE9zAR7ACcDOA8fM3ddljIUUgrKqaD0r6HzgQcAVXQfSY8nBebD9mq5jWEg5WVyQpPvRtJ79XbvrGOBDExf3xIpJOhbYkqbd8ZaJ/bafP933xD0lB2M2UggKqK31rJT2rmT3Yvv4hY6lb5KDMRcpBAXU1npWkqQHAtu0m6fZvrLLePoiORhzkXME5Y1961kpkl4CfIKm40XAfpLeafvwTgPrn+TgECQ9BdiIgfdL22PVuZZCUEZVrWcFvRfYZmIUIGkJ8CMghWBmycERqKWFOVNDBUj60goOZ/XMWZJ0nu0nDGyvBJwzuC+mlhwcDUk/p4IW5owICqit9aygoyUdQ3PfYoCX0tyoJmaQHByZKlqYMyKIRa2d0nhqu3mi7W93GU/UpZYW5hSCiIhp1NLCnEIQEbECNbQwpxAUVkPrWSxuycH5m6KF+WnA2LUwpxAUNF3rme23dhZUVCU5OBxJ5wDPmdzCbHuLbiMbrXQNlZXVM4cgaXuaZZQfTpOronkTyzLKs5ccHM5Kk6aCrmIM7+OSQlBWFa1nBR0IvB04g7s/zcbcJAeHU0ULc6aGCqql9awUSafaflLXcfRZcnB4NbQwpxAUVEvrWSmSPgqsTHMTkME3sTM7C6pnkoMxGykEhdXQelZK+2l2Mtt+5oIH02PJwZhJCkFBtbSelSBpZeCttj/ddSx9lhyM2UghKKiW1rNSJJ1me9uu4+iz5GDMRrqGyqqi9aygkyR9Fvg6cOPEzpwjmJPk4BBqaWFOISiritazgrZs/913YJ+BnCOYveTgcKpoYc7UUGE1tJ7F4pYcnL9aWphTCGLRkrQ28AHgb9tdxwP72r6uu6iiJrW0MKcQxKIl6Zs0V8Ye3O56JbCF7V2n/66I0amlhTmFIBYtSWfb3nKmfREl1NTCnO6BWMz+Kmlibnuig+OvHcYTFbF9B7BH13EshIwICqql9awUSVvSTAutTfPaXQ3safvcLuPqk+TgcCR9GrgPY97CnEJQkKRfMEXrme2rOguqhyStBWD7+q5j6Zvk4HByjiCGVkvrWSmS1qPpGnoqzfUDP6XpGsqb2CwlB2M2UggKqqX1rBRJPwROAL7a7no5sIPtZ3cXVb8kB4dTSwtzCkFBtQwrS5F0vu3HT9p3nu0ndBVT3yQHh1NLC3OWmCikbT07oobWs4J+IGl34Bvt9m7AMR3G0yvJwZHYxPaLBrb/U9LZXQVTStpHC6mp9WzUJN0g6XrgdcDXaKY0bgEOBfbuMrY+SQ6ORBUtzJkaKqiW1rNYvJKDw6mlhTmFoKDMz0bXkoOjMe4tzCkEERHTqKWFOecICpK0tqRPSVrWfn2ybUeLWBDJwaEdCiwHXkTTrLCcZpptrGREUFAtrWelSNoEuMz2LZJ2ADYHvmz72i7j6pPk4HBqaWFOISgoq2cOp23TWwpsRHNXre8Cj7P93A7D6pXk4HAkfQo4jXu2MG9r+1+7i2r0MjVUVhWtZwXdaft24IXAfrbfCTy445j6Jjk4D7W1MOeCsrLeCBzczsne1XrWbUi9cpukPWhes53bfffpMJ4+Sg7Og+01u45hIWVqaAGMe+tZKZI2A94AnGz7EEkbAy+x/bGOQ+ud5GCsSApBQbW0nsXilRyM2cg5grKqaD0rRdKmkg6XdKGkSya+uo6rZ5KDMaOMCAqqpfWsFEk/pfk0+2macwSvAVay/f5OA+uR5OBwamlhzoigrB9I2l3SSu3XS8jqmXOxuu0f03xgudT2PsDzOo6pb5KDw/kmcIekRwIHABvSdBGNlYwICpB0A818rIA1uPsWgSsDf7G9Vlex9Ymkn9HMbR8O/AS4HPio7Ud3GlgPJAdHQ9KZtreW9E7gZtv7STrL9lZdxzZKaR8toLbWs4LeBtwPeCvwQeAZpPVxVpKDI1NFC3NGBLFoSdrE9q+7jiPqVUsLcwpBLFqSjgc2AE4HTgROsH1et1FFjJ8UgljUJK0KbAPsALweuL/tB3QaVFRD0qbAR4DNgPtO7Lf9iM6CKiDnCAqqpfWslHaNnKe1X+sAR9KMDGKWkoND+xJ3tzA/g7aFudOICsiIoKCsnjkcSbcDZ9B8IjvK9q0dh9Q7ycHhSDrD9hMHr72Y2Nd1bKOUEUFZd9q+XdLE6pn7STqr66B6ZH1ge+BvgbdKupPmpN1/dBtWryQHh3OLpJWAX0l6C00L8/07jmnkxm6Is8gMtp4d2e4bu9azUtrpi0uA3wBXAJvQFIWYveTgcAZbmJ8IvIIxbGHO1FBBtbSeldKuK/QLmvMCJwKnZXpobpKDw6mlhTmFIBYtSSvZvrPrOKJetbQwpxAUVEvrWSxeycHh1dDCnJPFZVXRehaLWnJwCLW0MGdEUFAtrWexeCUHh1NLC3NGBGVV0XpWiqTVaG6oshEDuWp7365i6qHk4HCqaGHOELGsKlrPCvousAtwO3DjwFfMXnJwCLW0MGdqqKBaWs9KmeruWjE3ycHh1NLCnKmhsr4oaexbzwr6maQn5DUbSnJwOI+soYU5I4LCamg9K0XShcAjaYblt9Dcbcu2N+80sJ5JDsZMMiIoqJbWs4J26jqAvksOxmxkRFBQLa1nJUnaguZNDOBE2+d0GU/fJAdjNlIICpK0Dne3nm0DjGXrWSmS3ga8DvhWu+uFwAG29+suqn5JDg6nlhbmTA0VZPvatutgQ5r1Sp5CVn6ci72AJ9m+EUDSx4CTgRSCWUoODu27wHU0o6pbOo6lmBSCgia1nn0eeE2G5nMi4I6B7TvafTFLycGhbWB7x66DKC2FoKwqWs8K+hJwqqRvt9svAL7YXTi9lBwcThUtzDlHEIuapK2Bp7abJ9rO3bViwdTSwpxCEIuWpK/YfuVM+yJKkfTwqfbbvnShYykpaw3FYva4wQ1JK9OslxOxINo3/HWAnduvdcatCEDOERRVS+vZqEl6N/AeYHVJ13P3CeJbgQM6C6yHkoPDmaKF+auSxq6FOVNDBUk6mrtbz+7qfrH9yc6C6hFJH7H97q7j6LPk4HAknQs8eaCFeQ2a6zDG6hxBRgRlVdF6VtBh7cniQdcBl9q+vYuAeig5OJwqWphTCMqqovWsoM8BWwPn0vzxPQE4H1hb0htt/6DL4HoiOTicKlqYMzVUUC2tZ6VI+hbwH7YvaLc3A/YF/g34lu0tOwyvF5KDw6uhhTkjgrKyeuZwHjVRBABsXyjpMbYvkcZudF5KcnAIA+3KZ06xb2ykEBRk+9KsnjmUCyR9Hji03X4pcGHbCXNbd2H1R3JwaFW0MOc6goLa1rP/Af6m/fqqpH/qNqpeeTVwMfDP7dcl7b7bgGd0FFOvJAfnR9K7Jd0AbC7pekk3tNtX0ixEN1ZyjqCgWlrPYvFKDg6nlhbmTA2VVUXrWSmStgf2AR7OPS+GekRXMfVQcnA4VbQwpxCUVUXrWUEHAm9n0sVQMSfJweFU0cKcqaHCamg9K0XSqbaf1HUcfZccnL9aWphTCArK6pnDkfRRYGWadV7uujuU7TOn/aa4h+TgcCSdb/vxU+2TdPa4FIJMDZVVRetZQROjgaUD+ww8s4NY+io5OJwqWpgzIihgcPVM4CYmrZ5ZQxdCdCs5OBqSVgfexN1TayfRnDe4Gbif7b90FdsopRAUVEvr2ahJeoXtr0p6x1THbX9qoWPqq+RgzEamhsqqovWsgDXaf9fsNIrxkBwcQi0tzBkRFCTpFKZpPQPGpvUsFq/k4HAk/YIpWphtX9VZUAVkRFDWH4C9pms9A/JHuAKSltDcHWoj7vlp7B+7iqmHkoPDuc7297sOorQUgrKyeuZwvgucCPyIXFA2X8nB4Rwr6ROMeQtzCkFZVbSeFXQ/2//edRA9lxwcThUtzDlHUFAtrWelSPoQ8DPbR3UdS18lB2M2Ughi0WmX+zXNyc01aIbkt3H33bXW6jC8qEBtLcyZGiqoltazUbOdttERSQ7OW1UtzBkRFFRL61kp7ZvY2bZvlPQKmjbI/237dx2H1hvJwZiNFIKCsnrmcNqbqmwBbA4cBHwBeIntp3cZV58kB4dTSwtzpobKqqL1rKDbbVvSLsBnbR8oaa+ug+qZ5OBwqmhhTiEoq4rWs4JuaBdPewXwt5JWAu7TcUx9kxwcThUtzJkaikVL0oOAlwGn2z5R0sOAHWx/uePQohK1tDCnEBRQW+tZLD7JweHU1sKcqaEyqmo9K0XSdsB+wGOBVWnuVvYX22t3Glg/JAeHUFsLc0YEsWhJWgbsDhxGM8f9Kpq1c7K+fiyIWlqYUwgKqqX1rBRJy2wvlXSu7c3bfWfZ3qrr2PoiOTicWlqYMzVUVhWtZwXdJGlV4GxJHweuAFbqOKa+SQ4Op4oW5owICpJ0tu0tu46jryQ9HPgTzfmBt9PcTOVzti/uNLAeSQ4OR9LxwNHAa4C/Ba4EzrH9hE4DG7F8uirrSEnP7TqIvpF0laSjaK4feDLNp7L/tP2OFIE5Sw4O56U0HUN72f4jsAHwiW5DGr2MCAqorfVs1CStBWwHPKX9eiLwG5ollE+y/Y0Ow+uF5GDMRQpBLHqS1qAZmv8zsLHtlbuNKGpRSwtzpoYKkrR9+yaGpFdI+lR7dWysgKSHSNqtfb1OpJmjfSTwPiDLJ89BcnBonwX2AH4FrA68lubGPmMlI4KCamk9GzVJdwJnAp8GDrN9a8ch9VZycDi1tDBnRFDW7W4q7UTr2f7kSs/Z2B74GvBC4GRJ35T0r+2n29U6jq1vkoPDuUcLs6S3M4bvmxkRFFRL61lpkjYCdgbeBmxg+77dRtQfycHh1NLCnEJQUFbPnD9Jj+HurqHtgXWAU2i6hv5Xh6H1SnJwfiRdBZxK06n2M+BU2zd1G1U5KQSx6Ej6M/AH4GTaP8Rx+wQWi1ttLcwpBAXV0no2apLWtn1d13GMg+TgaIx7C3PWGirrs0yxemanEfVAisBIJQfnQdJDuHs0sE27+wyaFuaTu4qrlIwICqql9SwWr+Tg/NTWwpwRQVlZPTO6lhycn+1p1rl6IfAOSb+lGQmcDCyzfUuHsY1cRgQF1dJ6VoqkBwIfBh5ieydJmwFPtn1gx6H1RnJwNMa9hTmFoIDaWs9KkfR94EvAe21vIWkV4Kz0wM8sOTi8mlqYUwgKqK31rBRJp9veZnBOO+vrz05ycDi1tTCnECyAcW89K0XSccCLgB/a3rpthfxY1smZu+Tg3NTWwpxCUMAKWs9OAU62fWlXsfWJpK1peuAfD5wPLAF2s31up4H1QHIw5iKFoIDaWs9Kas8LPJrmhioX2b6t45B6ITkYc5FCUICkJ9O0nj0F2Bj4LWPcelaKpF2n2H0dcJ7tKxc6nj5JDsZcpBAsgHFvPStF0vdo3syObXftQDO9sTGwr+2vdBRa7yQH56eWFuZcUFbIClrP/rvDsPpmFeCxtv8Ed/1Rfhl4EnACkEKwAsnBkTiItoW53f4l8HUghSBWbFLr2QnAR8e59aygDSeKQOvKdt/VknKuYAWSgyOzvu1vSHo3gO3bJd3RdVCjlkJQxiY1tZ4VdJykI2kWTIOmlfS4thXy2s6i6ofk4GjcKGk9wHDXaq5j97rmHEEsapJeBDy13TwJ+KaTtLFAamlhTiGIRUnSysAFth/TdSxRtxpamDM1FIuS7TskXSTpYbZ/13U8UacpWpgfJWnsWphTCAqqpfWsoHWBCySdBtw4sdP287sLqV+Sg0Pbi2lamCWNTQtzpoYKyuqZw5E05ZpCto9f6Fj6Kjk4HEnHAK+aooV5D+AE24/vMr5RyQ0qylq/XeXxTmhaz4Cxaz0rpX3D/wWwZvv18xSBOUsODmfaFmZgbM4VpBCUVUXrWSmSXgKcBrwYeAlwqqTduo2qd5KDwzlO0pGS9pS0J/BdxrCFOVNDBdXSelaKpHOA50yclJO0BPiR7S26jaw/koPDq6GFOYWgsBpaz0qRdN7gXLaklYBzMr89N8nB+amphTldQwXV0npW0NHtybpD2u2XAt/vMJ7eSQ7OX00tzBkRFJTVM4fXvpFNDMtPtP3tLuPpm+TgcCSdAGxFc65qbFuYMyIoK6tnDu8M4HrbP5J0P0lr2r6h66B6JDk4nP/oOoCFkK6hsqpoPStF0uuAw4H/2+56KPCdzgLqp+TgEGppYc6IoKysnjmcNwPbAqcC2P6VpL/pNqTeSQ4OoW1h/gRwHM3J9v0kvdP24Z0GNmI5R1BYDa1npUg61faTJJ1le6u2++VM25t3HVufJAfnr5YW5owICpnUevbNruPpqeMlvQdYXdJzgDcB/3/HMfVGcnAkVprUXXUVYzilPna/0GJh+w7gIkkP6zqWHnsXsBw4D3g9cBTwvk4j6pHk4EgcLekYSa+W9Grge4xhC3OmhgqqpfUsFq/k4PBqaGHO1FBZVbSejZqkXYANbO/fbp9KszQCwL/bPmzab47JkoPDG/sW5owICmv7trdpN0/L1Zwzk3QSsLvt37fbZwPPAtYAvmT7WR2G1zvJwflrW5j3Bh5gexNJmwL/PW45mHMEBWX1zHlbdaIItH5q+6r2Mv81ugqqj5KDQ3szsD1wPTQtzMDYtTBnaqis9wLbTG49o7lIKqa37uCG7bcMbC4h5iI5OJxbbN8qCbhrAb+xm0bJiKCsKlrPCji1HZLfg6TX03y6jdlLDg5ncgvzYYxhC3POERQk6RPA5txz9czzbP9bd1Etfu3Vw98BbgHObHc/EVgNeMGkJRNiBZKDw2mXPt8L+DuaK4uPAb4wbhfkpRAUVkPrWSmSngk8rt28wPZPuoynr5KDMZMUgsIkPRzYdKL1DFh53FrPYnFLDs5dbS3MmSssKKtnRteSg/P2b8ARA9ur0bTg7gC8oYuASkohKKuK1rNY1JKD81NVC3MKQVm32L51YmNcW89iUUsOzk9VLcwpBGVV0XoWi1pycH6qamHOyeKCamk9i8UrOTg/tbUwpxBEREyjlhbmFIICams9i8UnORhzkXMEZVTVehaLUnIwZi2LzpUxZesZcFV70/CI0pKDMWsZEZRRVetZLErJwZi1FIIyqmo9i0UpORizlpPFBdTWehaLT3Iw5iKFoKBaWs9i8UoOxmykEEREVC7nCCIiKpdCEBFRuRSCiIjKpRBERFTu/wECXQBZs2aWdAAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.bar(matches, probs)\n",
    "plt.xticks(rotation=90)\n",
    "_ = plt.ylabel(\"Probability\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "39cd2e09",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-03-30T00:36:41.854284Z",
     "start_time": "2023-03-30T00:36:41.851459Z"
    }
   },
   "source": [
    "Since 3 of the 4 bars are invisible, we can plot the negative log conditional probability to better distinguish the trends.\n",
    "Here, lower is more likely."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "b9641df1",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-03-31T02:47:17.418863Z",
     "start_time": "2023-03-31T02:47:17.358977Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.bar(matches, -np.log(conditional_probs))\n",
    "plt.xticks(rotation=90)\n",
    "_ = plt.ylabel(\"Conditional Negative Log Probability\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f4ececfb",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-03-29T15:04:59.376046Z",
     "start_time": "2023-03-29T15:04:59.371795Z"
    }
   },
   "source": [
    "😈 Any idea how we can make the model guess wrong?\n",
    "Well, we already know that \"George Washington was born on July 4, 1732\" is a very likely answer, given the first ReLM query.\n",
    "Let's add that in the answers to throw the model off."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "17717f43",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-03-31T02:47:20.327093Z",
     "start_time": "2023-03-31T02:47:17.419643Z"
    }
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "aa19a176d81d412eb3813cd1978b9498",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "0it [00:00, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "['George Washington was born on July 4, 1732',\n",
       " 'George Washington was born on February 22, 1732',\n",
       " 'George Washington was born on March 30, 1973',\n",
       " 'George Washington was born on February 1, 1873']"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "query_string = relm.QueryString(query_str=(\"George Washington was born on ((July 4, 1732)|\"\n",
    "                                           \"(March 30, 1973)|(February 1, 1873)|(February 22, 1732))\"),\n",
    "                                prefix_str=\"George Washington was born on\",\n",
    "                               )\n",
    "top_k = None\n",
    "query = relm.SimpleSearchQuery(query_string=query_string,\n",
    "                               search_strategy=relm.QuerySearchStrategy.SHORTEST_PATH,\n",
    "                               tokenization_strategy=relm.QueryTokenizationStrategy.CANONICAL_TOKENS,\n",
    "                               top_k_sampling=top_k,\n",
    "                               sequence_length=None,\n",
    "                              )\n",
    "ret_iter = relm.search(model, tokenizer, query)\n",
    "\n",
    "xs, matches, probs, conditional_probs = process_relm_iterator(ret_iter, num_samples=20)\n",
    "matches"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "ba228612",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-03-31T02:47:20.413612Z",
     "start_time": "2023-03-31T02:47:20.328141Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.bar(matches, probs)\n",
    "plt.xticks(rotation=90)\n",
    "_ = plt.ylabel(\"Probability\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "27b71bfa",
   "metadata": {},
   "source": [
    "😎 As expected, we can always be an adversary with access to a model's predictions outside the multiple choice set.\n",
    "We can always take the most likely incorrect answer and use it to \"poison\" the multiple choice set.\n",
    "If the solution space we draw from is larger than the multiple choice space, it's likely that the most likely answer in that set would displace the most likely answer in the original multiple choice set.\n",
    "\n",
    "Essentially, a multiple choice question can be arbitrarily easy or hard depending on how difficult it is for a model to do the \"process of elimination\" on wrong answers.\n",
    "Notice that the choices which are off by 100+ years are very unlikely, and thus unlikely to be chosen by the model.\n",
    "Even if you didn't know anything about George Washington, you wouldn't guess he was born in the year 3000, would you? 😉\n",
    "\n",
    "That brings us to the main point: why bother with multiple choice if you can query a potentially massive solution space directly?\n",
    "With 12 months, 100 days, and 1000 years, ReLM can look at $12 \\times 100 \\times 1000 = 1200000$ date strings.\n",
    "Why evaluate a model on 4 choices when you can evaluate it on 1200000?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f9ae13da",
   "metadata": {},
   "source": [
    "## Conclusion"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c4b70e9d",
   "metadata": {},
   "source": [
    "So that's it!\n",
    "We have seen how a simple query can be modified in both string space as well as token space to get different results.\n",
    "The power of ReLM is that _you_ can decide exactly what type query is important, and ReLM handles the details for you."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.7.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}