014 Attention and dropout.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# `014` Attention mechanisms (and dropout)\n",
    "\n",
    "Requirements: 012 Recurrent neural networks\n",
    "\n",
    "There is a problem with RNNs when dealing with sequential data. Imagine we're trying to summarize a text about \"the **big** house\" that has several sentences describing its features. Our RNN would treat each word individually and try to capture the context in the same way for every single word. However, we want our model to focus on specific parts of the input sequence while processing it.\n",
    "\n",
    "For instance, when processing the sentence \"That is a **big** house\", we want our model to focus on the word \"that\" which refers to the specific house being described. We also want it to recognize that the adjective \"big\" is modifying the noun \"house\".\n",
    "\n",
    "This is where **Attention mechanisms** come in. They allow us to selectively focus on certain parts of the input sequence while processing it, such as paying attention to specific nouns or adjectives. This helps resolve the ambiguity problem and allows us to model long-range dependencies much better.\n",
    "\n",
    "In addition to Attention, we will also cover another important technique: **Dropout**. Dropout randomly sets a fraction of neurons during training, which prevents overfitting and improves generalization performance. By combining these two techniques, we can create more powerful and robust RNNs that are capable of handling complex sequential data.\n",
    "\n",
    "Let's start by loading our already familiar language classification dataset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from json import loads\n",
    "from matplotlib import pyplot as plt\n",
    "from string import ascii_letters, digits\n",
    "from time import time\n",
    "from unicodedata import category, normalize\n",
    "import torch\n",
    "\n",
    "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "vocabulary = ascii_letters + digits + ' .,;\\'!'\n",
    "c2i = {c: i for i, c in enumerate(vocabulary)}\n",
    "i2c = {i: c for i, c in enumerate(vocabulary)}\n",
    "\n",
    "def vectorize_sentence(s):\n",
    "\treturn [c2i[c] for c in normalize('NFD', s) if category(c) != 'Mn' and c in vocabulary]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loaded 6232944 sentences from 8 languages using 68 different characters\n",
      "tensor([17, 12, 19, 62,  4,  4, 13, 62,  7,  4, 11,  3,  4, 17,  1, 11,  0, 20,\n",
      "        22,  4, 62, 14, 15, 11, 14, 18, 18,  8, 13,  6, 62, 21]) tensor(5) -> rmt een helderblauwe oplossing v nl\n"
     ]
    }
   ],
   "source": [
    "with open('custom-data/sentences.json', encoding='utf-8') as f:\n",
    "\tdata = loads(f.read())\n",
    "\n",
    "languages = list(data.keys())\n",
    "\n",
    "X, Y = [], []\n",
    "block_size = 32\n",
    "for language, sentences in data.items():\n",
    "\tfor sentence in sentences:\n",
    "\t\tsentence = vectorize_sentence(sentence)\n",
    "\t\tfor i in range(len(sentence) - block_size + 1):\n",
    "\t\t\tX.append(sentence[i:i+block_size])\n",
    "\t\t\tY.append(languages.index(language))\n",
    "ix = torch.randperm(len(X))\n",
    "X = torch.tensor([X[i] for i in ix], device=device)\n",
    "Y = torch.tensor([Y[i] for i in ix], device=device)\n",
    "\n",
    "print(f'Loaded {len(X)} sentences from {len(languages)} languages using {len(vocabulary)} different characters')\n",
    "print(X[0], Y[0], '->', ''.join(i2c[i.item()] for i in X[0]), languages[Y[0]])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, let's see an example of how attention works. The idea of this mechanism, is to provide with meaning to the tokens, using other tokens for that. They way it works is by modelling a system by which tokens communicate with each other:\n",
    "* First, each token is multiplied by a matrix $W_k$ that transforms them into the **key vector**. This vector tells which information our token contains that can be useful to give context to others.\n",
    "* Then, each token is multiplied by a matrix $W_q$ that transforms them into the **query vector**. This vector tells which information our token is looking for in others.\n",
    "* By multiplying the key token of each vector with the query token of each other vector, we can obtain an **attention matrix**. In this matrix, the position $i, j$ tells how much information from the $j$-th token does the $i$-th token wants.\n",
    "* Then, we don't give the information from the embedding directly, we first map the tokens into the **value space** by multipliying by a matrix $W_v$.\n",
    "* Finally, by multiplying the value vectors by the attention matrix, we convert each token into a linear combination of every other token value.\n",
    "\n",
    "Since $W_k$, $W_q$ and $W_v$ are learnable parameters, the idea of the attention matrix is that during the gradient descent our model learns how each token should communicate with each other based on its content. Let's see it in code with an example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "input = torch.tensor([vectorize_sentence('Hello, World!')])  # (batch_size=1, context_length=13)\n",
    "\n",
    "embed_dim = 8\n",
    "embeddings = torch.randn(len(vocabulary), embed_dim)  # (vocabulary_size, embedding_channels=8)\n",
    "input = embeddings[input]  # (batch_size=1, context_length=13, embedding_channels=8)\n",
    "\n",
    "head_size = 16\n",
    "# key space mapping: what each has to offer\n",
    "W_k = torch.randn(embed_dim, head_size)  # (embedding_channels=8, head_size=16)\n",
    "# query space mapping: what each token is looking for\n",
    "W_q = torch.randn(embed_dim, head_size)  # (embedding_channels=8, head_size=16)\n",
    "\n",
    "k = input @ W_k  # (batch_size=1, context_length=13, head_size=16)\n",
    "q = input @ W_q  # (batch_size=1, context_length=13, head_size=16)\n",
    "\n",
    "# dot product of what each token is looking for and what each has to offer -> attention weights: how much each token should pay attention to each other token\n",
    "# note that you swap the last two dimensions of k to make a square matrix of dot products\n",
    "attention_weights = q @ k.transpose(-2, -1)  # (batch_size=1, context_length=13, context_length=13)\n",
    "# now, divide it by the square root of the head size to make the dot products more stable\n",
    "attention_weights /= head_size ** 0.5\n",
    "# apply a softmax to make the attention weights sum to 1\n",
    "attention_weights = attention_weights.softmax(dim=-1)  # (batch_size=1, context_length=13, context_length=13)\n",
    "\n",
    "# value space: what each token is contributing\n",
    "W_v = torch.randn(embed_dim, head_size)  # (embedding_channels=8, head_size=16)\n",
    "\n",
    "v = input @ W_v  # (batch_size=1, context_length=13, head_size=16)\n",
    "\n",
    "# weighted sum of what each token is contributing, based on how much each token should pay attention to each other token\n",
    "output = attention_weights @ v  # (batch_size=1, context_length=13, head_size=16)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, let's make it into a pytorch layer:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class SimpleAttention(torch.nn.Module):\n",
    "\tdef __init__(self, embedding_channels, head_size):\n",
    "\t\tsuper().__init__()\n",
    "\t\tself.W_k = torch.nn.Linear(embedding_channels, head_size, bias=False)\n",
    "\t\tself.W_q = torch.nn.Linear(embedding_channels, head_size, bias=False)\n",
    "\t\tself.W_v = torch.nn.Linear(embedding_channels, head_size, bias=False)\n",
    "\tdef forward(self, x):\n",
    "\t\tk = self.W_k(x)\n",
    "\t\tq = self.W_q(x)\n",
    "\t\tattention = q @ k.transpose(-2, -1) / k.size(-1) ** 0.5\n",
    "\t\tattention = attention.softmax(dim=-1)\n",
    "\t\tv = self.W_v(x)\n",
    "\t\treturn attention @ v"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice we called it **simple** attention? This is because something that works well with attention is to have multiple layers like this stacked, in parallel. This way, each **attention head** (which is how we call each of them) is paying attention to a different feature. One might be looking for ways to disambiguate words like \"that\", while other might be looking for ways to give adjectives the context of which noun they refer to.\n",
    "\n",
    "But since all those layers run in parallel, we risk that they all start paying attention to the same stuff. To avoid this, we are going to randomly deactivate some weights in the network, so that **not all neurons fire at once**. This technique is called **Dropout**, and it helps prevent overfitting by reducing the reliance on individual neurons."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Dropout(torch.nn.Module):\n",
    "\tdef __init__(self, ratio):\n",
    "\t\tsuper().__init__()\n",
    "\t\tself.ratio = ratio\n",
    "\tdef forward(self, x):\n",
    "\t\tmask = (torch.rand_like(x) > self.ratio).float()\n",
    "\t\treturn mask * x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that we have all the ingredients we need, let's create a MultiHeadAttention layer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MultiHeadAttention(torch.nn.Module):\n",
    "\tdef __init__(self, embed_dim, num_heads, dropout_ratio):\n",
    "\t\tsuper().__init__()\n",
    "\t\tself.heads = torch.nn.ModuleList([\n",
    "\t\t\tSimpleAttention(embed_dim, embed_dim // num_heads)\n",
    "\t\t\tfor _ in range(num_heads)\n",
    "\t\t])\n",
    "\t\tself.fc = torch.nn.Linear(embed_dim, embed_dim)\n",
    "\t\tself.dropout = Dropout(dropout_ratio)\n",
    "\n",
    "\tdef forward(self, x):\n",
    "\t\tx = torch.cat([head(x) for head in self.heads], dim=-1)\n",
    "\t\tx = self.fc(x)\n",
    "\t\tx = self.dropout(x)\n",
    "\t\treturn x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And let's place it in the RNN from the previous notebook, and test the result with and without it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Created model with attention and 112520 parameters\n",
      "Created model with no attention and 112520 parameters\n"
     ]
    }
   ],
   "source": [
    "class RNN(torch.nn.Module):\n",
    "\tdef __init__(self, input_size, output_size, use_attention=False, emb_dim=128, hidden_size=128, num_heads=4, dropout_ratio=.2):\n",
    "\t\tsuper().__init__()\n",
    "\t\tself.hidden_size = hidden_size\n",
    "\t\tself.tok_emb = torch.nn.Embedding(input_size, emb_dim)\n",
    "\t\tself.pos_emb = torch.nn.Embedding(block_size, emb_dim)\n",
    "\t\tself.attention = MultiHeadAttention(emb_dim, num_heads, dropout_ratio) if use_attention else None\n",
    "\t\tself.i2h = torch.nn.Linear(emb_dim, hidden_size)\n",
    "\t\tself.h2h = torch.nn.Linear(hidden_size, hidden_size)\n",
    "\t\tself.h2o = torch.nn.Linear(hidden_size, output_size)\n",
    "\n",
    "\tdef forward(self, x):\n",
    "\t\tx = self.tok_emb(x) + self.pos_emb(torch.arange(x.size(-1)))\n",
    "\t\tif self.attention is not None: x = self.attention(x)\n",
    "\t\thidden = torch.zeros(x.size(0), self.hidden_size, device=device)\n",
    "\t\tfor i in range(input.size(1)):\n",
    "\t\t\ti = x[:, i]\n",
    "\t\t\ti = self.i2h(i)\n",
    "\t\t\th = self.h2h(hidden)\n",
    "\t\t\thidden = (h + i).tanh()\n",
    "\t\treturn self.h2o(hidden)\n",
    "\n",
    "model_with_attention = RNN(len(vocabulary), len(languages), use_attention=True).to(device)\n",
    "print(f'Created model with attention and {sum(p.numel() for p in model_with_attention.parameters())} parameters')\n",
    "model_without_attention = RNN(len(vocabulary), len(languages), use_attention=False, emb_dim=416).to(device)\n",
    "print(f'Created model with no attention and {sum(p.numel() for p in model_without_attention.parameters())} parameters')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To be fair in the comparison, we have given almost twice the embedding size to the model without attention, so that both have the same number of parameters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train(model, iterations=1000, batch_size=64, lr=3e-4):\n",
    "\tstart = time()\n",
    "\tcriterion = torch.nn.CrossEntropyLoss()\n",
    "\toptimizer = torch.optim.Adam(model.parameters(), lr=lr)\n",
    "\tlosses = []\n",
    "\tfor i in range(iterations):\n",
    "\t\tix = torch.randint(len(X), (batch_size,))\n",
    "\t\txb, yb = X[ix], Y[ix]\n",
    "\t\tloss = criterion(model(xb), yb)\n",
    "\t\toptimizer.zero_grad()\n",
    "\t\tloss.backward()\n",
    "\t\toptimizer.step()\n",
    "\t\tlosses.append(loss.item())\n",
    "\t\tif i % 100 == 0 and i > 0 or i == 10:\n",
    "\t\t\tremaining = (time() - start) * (iterations - i) / (i + 1)\n",
    "\t\t\tprint(f'Epoch {i:4} loss: {loss.item():.4f} remaining: {remaining//60:.0f}:{remaining%60:02.0f}')\n",
    "\treturn losses\n",
    "\n",
    "def plot_losses(losses):\n",
    "\tlosses_avg = torch.tensor(losses).view(-1, 10).mean(1)\n",
    "\tplt.figure(figsize=(10, 4))\n",
    "\tplt.plot(losses, c='c', label='loss')\n",
    "\tplt.plot(range(0, len(losses), 10), losses_avg, c='k', label='average loss')\n",
    "\tplt.xlabel('epoch')\n",
    "\tplt.ylabel('loss')\n",
    "\tplt.legend()\n",
    "\tplt.ylim(0, 3)\n",
    "\tplt.axvline(1000, c='gray', linestyle='--')\n",
    "\tplt.show()\n",
    "\n",
    "def confusion_matrix(model):\n",
    "\tix = torch.randint(len(X), (1000,))\n",
    "\tX_test, Y_test = X[ix], Y[ix]\n",
    "\n",
    "\tconfusion_matrix = torch.zeros(len(languages), len(languages), device=device)\n",
    "\toutput = model(X_test).argmax(1)\n",
    "\tfor true_label, predicted_label in zip(Y_test, output):\n",
    "\t\tconfusion_matrix[true_label, predicted_label] += 1\n",
    "\tconfusion_matrix /= confusion_matrix.sum(1, keepdim=True)\n",
    "\n",
    "\tplt.imshow(confusion_matrix.cpu().numpy())\n",
    "\tplt.xticks(range(len(languages)), languages, rotation=90)\n",
    "\tplt.yticks(range(len(languages)), languages)\n",
    "\tplt.xlabel('predicted')\n",
    "\tplt.ylabel('actual')\n",
    "\tplt.show()\n",
    "\n",
    "\taccuracy = confusion_matrix.diag().sum().item() / len(Y_test)\n",
    "\tprint(f'Accuracy: {100 * accuracy:.2f}%')\n",
    "\n",
    "def train_and_evaluate(model):\n",
    "\tprint('Training with default learning rate')\n",
    "\tlosses = train(model)\n",
    "\tprint('Training with lower learning rate')\n",
    "\tlosses.extend(train(model, lr=3e-5))\n",
    "\tplot_losses(losses)\n",
    "\tconfusion_matrix(model)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let's test both models!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training with default learning rate\n",
      "Epoch   10 loss: 2.0513 remaining: 0:45\n",
      "Epoch  100 loss: 1.5457 remaining: 0:14\n",
      "Epoch  200 loss: 1.5606 remaining: 0:12\n",
      "Epoch  300 loss: 1.1924 remaining: 0:10\n",
      "Epoch  400 loss: 1.0256 remaining: 0:08\n",
      "Epoch  500 loss: 0.9739 remaining: 0:06\n",
      "Epoch  600 loss: 1.0274 remaining: 0:05\n",
      "Epoch  700 loss: 1.1097 remaining: 0:04\n",
      "Epoch  800 loss: 1.0134 remaining: 0:02\n",
      "Epoch  900 loss: 1.1121 remaining: 0:01\n",
      "Training with lower learning rate\n",
      "Epoch   10 loss: 1.0136 remaining: 0:10\n",
      "Epoch  100 loss: 1.1116 remaining: 0:09\n",
      "Epoch  200 loss: 1.0247 remaining: 0:09\n",
      "Epoch  300 loss: 0.9383 remaining: 0:08\n",
      "Epoch  400 loss: 1.0439 remaining: 0:07\n",
      "Epoch  500 loss: 1.0306 remaining: 0:06\n",
      "Epoch  600 loss: 1.1298 remaining: 0:05\n",
      "Epoch  700 loss: 1.0109 remaining: 0:04\n",
      "Epoch  800 loss: 1.1478 remaining: 0:02\n",
      "Epoch  900 loss: 1.0497 remaining: 0:01\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 0.49%\n"
     ]
    }
   ],
   "source": [
    "train_and_evaluate(model_with_attention)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training with default learning rate\n",
      "Epoch   10 loss: 2.1677 remaining: 0:11\n",
      "Epoch  100 loss: 2.0910 remaining: 0:08\n",
      "Epoch  200 loss: 1.9519 remaining: 0:07\n",
      "Epoch  300 loss: 1.7211 remaining: 0:06\n",
      "Epoch  400 loss: 1.7507 remaining: 0:05\n",
      "Epoch  500 loss: 1.6197 remaining: 0:04\n",
      "Epoch  600 loss: 1.4526 remaining: 0:04\n",
      "Epoch  700 loss: 1.5885 remaining: 0:03\n",
      "Epoch  800 loss: 1.5220 remaining: 0:02\n",
      "Epoch  900 loss: 1.4550 remaining: 0:01\n",
      "Training with lower learning rate\n",
      "Epoch   10 loss: 1.3051 remaining: 0:08\n",
      "Epoch  100 loss: 1.1356 remaining: 0:07\n",
      "Epoch  200 loss: 1.2206 remaining: 0:07\n",
      "Epoch  300 loss: 1.3887 remaining: 0:06\n",
      "Epoch  400 loss: 1.2926 remaining: 0:05\n",
      "Epoch  500 loss: 1.5237 remaining: 0:04\n",
      "Epoch  600 loss: 1.2735 remaining: 0:03\n",
      "Epoch  700 loss: 1.5132 remaining: 0:02\n",
      "Epoch  800 loss: 1.2711 remaining: 0:02\n",
      "Epoch  900 loss: 1.4579 remaining: 0:01\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAbQAAAG0CAYAAABaNNJGAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAAAm3ElEQVR4nO3df1RVdb7/8dfh1xHlh6OgoKKokWWloo6/8geT42TNna5Ta1Z6nSjHwun6AyGzqMzUrnib/JHdKXVMxeraLceaVllfyxta/qA0RUvHH4hCSkOlgaQegnO+f3Q94wlQOCJ7n0/Px1pnLc/e+2xeuI68fO+z2dvh8Xg8AgAgwAVZHQAAgMZAoQEAjEChAQCMQKEBAIxAoQEAjEChAQCMQKEBAIxAoQEAjBBidYArze1268SJE4qMjJTD4bA6DgCgATwej06fPq127dopKOjiM5jxhXbixAklJCRYHQMAcBmKi4vVoUOHi25jfKFFRkZKktovekhB4U6L0zRMUuYhqyP4xRHe3OoIfiu/MdHqCH6JfH+f1RH84qmssjqCX4LbtbE6gt88zcOtjtAgVdUubTr4rPdn+cUYX2jnDzMGhTsVFN7M4jQNE+IIszqCXxxBgZlbkkJCA+s9cl6gvlc8AfoxQHBQYP3n+EKe4MDMXp+PjDgpBABgBAoNAGAECg0AYAQKDQBgBAoNAGAECg0AYAQKDQBgBAoNAGAECg0AYAQKDQBgBAoNAGAECg0AYAQKDQBgBAoNAGAECg0AYAQKDQBghIAptMTERC1atMjqGAAAmwqYQgMA4GJsU2gpKSmaNGmSJk2apOjoaMXExGjGjBnyeDxKSUnRsWPHlJGRIYfDUa9bcQMAflpCrA5woZycHI0fP14ff/yxduzYobS0NHXs2FHr1q1Tz549lZaWpvvuu++i+3C5XHK5XN7n5eXlVzo2AMAGbFVoCQkJWrhwoRwOh7p166a9e/dq4cKFuu+++xQcHKzIyEjFxcVddB/Z2dmaNWtWEyUGANiFbQ45StKAAQN8DicOHDhQhw4dUnV1db33kZWVpbKyMu+juLj4SkQFANiMrSa0xuB0OuV0Oq2OAQBoYraa0PLy8nyeb9++XUlJSQoODlZYWFiDJjUAwE+LrQqtqKhImZmZOnDggNasWaNnn31W6enpkn74PbTNmzfr+PHj+vrrry1OCgCwG1sdckxNTdXZs2fVr18/BQcHKz09XWlpaZKk2bNna8KECeratatcLpc8Ho/FaQEAdmKrQgsNDdWiRYv0/PPP11g3YMAA5efnW5AKABAIbHXIEQAAf1FoAAAj2OaQY25urtURAAABjAkNAGAECg0AYAQKDQBgBAoNAGAECg0AYAQKDQBgBAoNAGAECg0AYAQKDQBgBAoNAGAECg0AYAQKDQBgBNtcnPhK6zohXyGOUKtjNMjpd7tYHcEvUXdXWB3Bby1e32F1BL84kjpbHcEv3/aOsTqCX6LWbLc6gt+CW7eyOkLDuCvrvSkTGgDACBQaAMAIFBoAwAgUGgDACBQaAMAIFBoAwAgUGgDACBQaAMAIFBoAwAgUGgDACBQaAMAIFBoAwAgUGgDACBQaAMAIFBoAwAgUGgDACBQaAMAIFBoAwAi2K7SUlBRNnTrV6hgAgABju0IDAMAfFBoAwAiWFtp3332n1NRURUREKD4+XvPnz/dZ73K5NG3aNLVv314tWrRQ//79lZuba01YAICtWVpoDz74oDZt2qS//e1v2rBhg3Jzc/Xpp59610+aNEnbtm3TK6+8oj179uh3v/udRo4cqUOHDtW5T5fLpfLycp8HAMB8lhVaRUWFXnjhBT399NMaPny4brjhBuXk5KiqqkqSVFRUpJUrV+q1117TkCFD1LVrV02bNk2DBw/WypUr69xvdna2oqOjvY+EhISm+pYAABYKseoLFxQUqLKyUv379/cua9Wqlbp16yZJ2rt3r6qrq3X11Vf7vM7lcql169Z17jcrK0uZmZne5+Xl5ZQaAPwEWFZol1JRUaHg4GDt3LlTwcHBPusiIiLqfJ3T6ZTT6bzS8QAANmNZoXXt2lWhoaHKy8tTx44dJUmnTp3SwYMHNWzYMCUnJ6u6ulqlpaUaMmSIVTEBAAHCskKLiIjQ+PHj9eCDD6p169Zq06aNHn30UQUF/fCx3tVXX62xY8cqNTVV8+fPV3Jysr766itt3LhRPXr00K9//WurogMAbMjSQ45/+tOfVFFRod/85jeKjIzUAw88oLKyMu/6lStX6sknn9QDDzyg48ePKyYmRgMGDNC//Mu/WJgaAGBHDo/H47E6xJVUXl6u6OhopehfFeIItTpOg3z3bherI/gl6u4KqyP4rfqrb6yO4JfgpM5WR/DLqd4xVkfwS9Sa7VZH8Ftw61ZWR2iQKnelNp5cpbKyMkVFRV10W64UAgAwAoUGADAChQYAMAKFBgAwAoUGADAChQYAMAKFBgAwAoUGADAChQYAMAKFBgAwAoUGADAChQYAMAKFBgAwAoUGADAChQYAMIKlN/hsSg6nU44Aux9axL8etzqCX9YX5lkdwW+39hxhdQS/eIpPWB3BL1GHCq2O4Jeg5s2tjuA3z9lzVkdoEI+nst7bMqEBAIxAoQEAjEChAQCMQKEBAIxAoQEAjEChAQCMQKEBAIxAoQEAjEChAQCMQKEBAIxAoQEAjEChAQCMQKEBAIxAoQEAjEChAQCMQKEBAIxAoQEAjEChAQCMEFCFlpiYqEWLFlkdAwBgQwFVaAAA1IVCAwAYIcTqABdKSUnR9ddfL0l68cUXFRoaqvvvv1+zZ8+Ww+GwOB0AwM5sN6Hl5OQoJCREH3/8sZ555hktWLBAy5cvr/frXS6XysvLfR4AAPPZrtASEhK0cOFCdevWTWPHjtXkyZO1cOHCer8+Oztb0dHR3kdCQsIVTAsAsAvbFdqAAQN8Di8OHDhQhw4dUnV1db1en5WVpbKyMu+juLj4SkUFANiIrT5DawxOp1NOp9PqGACAJma7CS0vL8/n+fbt25WUlKTg4GCLEgEAAoHtCq2oqEiZmZk6cOCA1qxZo2effVbp6elWxwIA2JztDjmmpqbq7Nmz6tevn4KDg5Wenq60tDSrYwEAbM52hRYaGqpFixbp+eefr7Hu6NGjTR8IABAQbHfIEQAAf1BoAAAj2OqQY25urtURAAABigkNAGAECg0AYAQKDQBgBAoNAGAECg0AYAQKDQBgBAoNAGAECg0AYAQKDQBgBAoNAGAECg0AYAQKDQBgBAoNAGAEW11t/0oqvbuXgsOaWR2jQeJfPWR1BL/ces1QqyP4rfiPSVZH8EvCX/ZbHcEvjupqqyP4xZHYweoIfnOHh1odoUE81S5pV/22ZUIDABiBQgMAGIFCAwAYgUIDABiBQgMAGIFCAwAYgUIDABiBQgMAGIFCAwAYgUIDABiBQgMAGIFCAwAYgUIDABiBQgMAGIFCAwAYgUIDABiBQgMAGMHWhZaSkqKpU6daHQMAEABCrA5wMevWrVNo6A+3C09MTNTUqVMpOABArWxdaK1atbI6AgAgQATEIceUlBQdO3ZMGRkZcjgccjgcVkcDANiMrQvtvHXr1qlDhw6aPXu2SkpKVFJSUue2LpdL5eXlPg8AgPkCotBatWql4OBgRUZGKi4uTnFxcXVum52drejoaO8jISGhCZMCAKwSEIXWEFlZWSorK/M+iouLrY4EAGgCtj4pxB9Op1NOp9PqGACAJhYwE1pYWJiqq6utjgEAsKmAKbTExERt3rxZx48f19dff211HACAzdT7kOPtt99e752uW7fOrzAXM3v2bE2YMEFdu3aVy+WSx+Np9K8BAAhc9S606OjoK5mjVrm5ud4/DxgwQPn5+U2eAQAQGOpdaCtXrrySOQAAuCwB8xkaAAAX4/dp+2vXrtWrr76qoqIiVVZW+qz79NNPLzsYAAAN4deEtnjxYo0bN05t27bVrl271K9fP7Vu3VpHjhzRLbfc0tgZAQC4JL8K7bnnntOyZcv07LPPKiwsTNOnT9d7772nKVOmqKysrLEzAgBwSX4VWlFRkQYNGiRJCg8P1+nTpyVJd911l9asWdN46QAAqCe/Ci0uLk4nT56UJHXs2FHbt2+XJBUWFvL7YQAAS/hVaDfddJPefPNNSdK4ceOUkZGhESNG6M4779Rvf/vbRg0IAEB9+HWW47Jly+R2uyVJEydOVOvWrbV161bddtttmjBhQqMGBACgPvwqtKCgIAUF/XO4Gz16tEaPHt1ooQAAaCi/Cm3z5s0XXT906FC/wgAA4C+/Ci0lJaXGMofD4f0zt3kBADQ1v04KOXXqlM+jtLRU7777rn7+859rw4YNjZ0RAIBL8mtCq+3K+yNGjFBYWJgyMzO1c+fOyw4GAEBDNOrFidu2basDBw405i4BAKgXvya0PXv2+Dz3eDwqKSnRvHnz1KtXr8bIBQBAg/hVaL169ZLD4ahxVZABAwZoxYoVjRKssbV9ea9CHGFWx2iQ73tfbXUEv4ScOmt1BL8lLPvc6gh+OTrpOqsj+KXtJ5WX3siGmv/9H1ZH8FtwWYXVERrE43bVe1u/Cq2wsNDneVBQkGJjY9WsWTN/dgcAwGXz6zO0TZs2KS4uTp06dVKnTp2UkJCgZs2aqbKyUqtXr27sjAAAXJJfhTZu3LhabxNz+vRpjRs37rJDAQDQUH4Vmsfj8flF6vO++OKLWk/pBwDgSmvQZ2jJyclyOBxyOBwaPny4QkL++fLq6moVFhZq5MiRjR4SAIBLaVChjRo1SpK0e/du3XzzzYqIiPCuCwsLU2Jiou64445GDQgAQH00qNBmzpwpSUpMTNTo0aPldDqvSCgAABrKr8/Qunfvrt27d9dYnpeXpx07dlxuJgAAGsyvQps4caKKi4trLD9+/LgmTpx42aEAAGgovwpt37596t27d43lycnJ2rdv32WHAgCgofwqNKfTqX/8o+alX0pKSnzOfAQAoKn4VWi/+tWvlJWV5fPL1d9++60eeeQRjRgxotHCAQBQX36NU08//bSGDh2qTp06KTk5WdIPp/K3bdtWL774YqMGBACgPvwqtPbt22vPnj16+eWXlZ+fr/DwcI0bN05jxoxRaGhoY2cEAOCS/P7Aq0WLFho8eLA6duyoysofbgHxzjvvSJJuu+22xkkHAEA9+VVoR44c0W9/+1vt3bvXe1+0C6/tWF1d3WgBAQCoD79OCklPT1fnzp1VWlqq5s2b67PPPtOmTZvUt29f5ebmNnJEAAAuza8Jbdu2bfrf//1fxcTEKCgoSMHBwRo8eLCys7M1ZcoU7dq1q7FzAgBwUX5NaNXV1YqMjJQkxcTE6MSJE5KkTp066cCBA42XDgCAevJrQrv++uuVn5+vzp07q3///nrqqacUFhamZcuWqUuXLo2dEQCAS/JrQnvsscfkdrslSbNnz1ZhYaGGDBmi9evXa/HixfXej9vtVnZ2tjp37qzw8HD17NlTa9eulSTl5ubK4XBo48aN6tu3r5o3b65BgwYxAQIAauXXhHbzzTd7/3zVVVfp73//u06ePKmf/exntd7Jui7Z2dl66aWXtGTJEiUlJWnz5s36/e9/r9jYWO82jz76qObPn6/Y2Fj98Y9/1B/+8Adt2bLFn9gAAIM12oUXW7Vq1aDtXS6X5s6dq/fff18DBw6UJHXp0kUfffSRli5dqrS0NEnSf/zHf2jYsGGSpIcffli//vWvde7cOTVr1qzO/bpcLu/z8vJyf74dAECAsexKwocPH9aZM2dqXPuxsrLSezktSerRo4f3z/Hx8ZKk0tJSdezYsdb9Zmdna9asWVcgMQDAziwrtIqKCknS22+/rfbt2/usczqdKigokCSfS2mdP5x5/vO72mRlZSkzM9P7vLy8XAkJCY2WGwBgT5YVWvfu3eV0OlVUVOQ9pHih84XWUE6nU06n83LjAQACjGWFFhkZqWnTpikjI0Nut1uDBw9WWVmZtmzZoqioKHXq1MmqaACAAGTp3TjnzJmj2NhYZWdn68iRI2rZsqV69+6tRx555KKHFQEA+DFLC83hcCg9PV3p6em1rvd4PD7Pe/XqVWMZAACSn79YDQCA3VBoAAAjUGgAACNQaAAAI1BoAAAjUGgAACNQaAAAI1BoAAAjUGgAACNQaAAAI1BoAAAjUGgAACNQaAAAI1BoAAAjUGgAACNQaAAAI1h6g8+m5D7rktsRWHfBPnltM6sj+KVtbrnVEfzmPnvO6gh+SXz1H1ZH8Mv+qa2tjuCXq987YXUEv4W0jbU6QsO4639TZyY0AIARKDQAgBEoNACAESg0AIARKDQAgBEoNACAESg0AIARKDQAgBEoNACAESg0AIARKDQAgBEoNACAESg0AIARKDQAgBEoNACAESg0AIARKDQAgBEoNACAEQKu0BwOh9544w2rYwAAbCbgCg0AgNpQaAAAI4RYHeDHUlJS1KNHDzVr1kzLly9XWFiY/vjHP+qJJ56wOhoAwMZsOaHl5OSoRYsWysvL01NPPaXZs2frvffeq9drXS6XysvLfR4AAPPZstB69OihmTNnKikpSampqerbt682btxYr9dmZ2crOjra+0hISLjCaQEAdmDbQrtQfHy8SktL6/XarKwslZWVeR/FxcVXIiIAwGZs9xmaJIWGhvo8dzgccrvd9Xqt0+mU0+m8ErEAADZmywkNAICGotAAAEag0AAARrDdZ2i5ubk1ll14qSuPx9N0YQAAAYMJDQBgBAoNAGAECg0AYAQKDQBgBAoNAGAECg0AYAQKDQBgBAoNAGAECg0AYAQKDQBgBAoNAGAECg0AYAQKDQBgBAoNAGAECg0AYATb3Q/tSimYl6yg8GZWx2iQpKkfWx3BL54A+3u+0He39rI6gl8iPzpidQS/XJN53OoI/umeZHUCv30f5bQ6QoNUVZ2TvqzftkxoAAAjUGgAACNQaAAAI1BoAAAjUGgAACNQaAAAI1BoAAAjUGgAACNQaAAAI1BoAAAjUGgAACNQaAAAI1BoAAAjUGgAACNQaAAAI1BoAAAjUGgAACNQaAAAI1BoAAAjUGgAACNQaAAAI9ii0Nxut7Kzs9W5c2eFh4erZ8+eWrt2rSTp1KlTGjt2rGJjYxUeHq6kpCStXLnS4sQAALsJsTqAJGVnZ+ull17SkiVLlJSUpM2bN+v3v/+9YmNj9dprr2nfvn165513FBMTo8OHD+vs2bN17svlcsnlcnmfl5eXN8W3AACwmOWF5nK5NHfuXL3//vsaOHCgJKlLly766KOPtHTpUlVUVCg5OVl9+/aVJCUmJl50f9nZ2Zo1a9aVjg0AsBnLDzkePnxYZ86c0YgRIxQREeF9rF69WgUFBbr//vv1yiuvqFevXpo+fbq2bt160f1lZWWprKzM+yguLm6i7wQAYCXLJ7SKigpJ0ttvv6327dv7rHM6nUpISNCxY8e0fv16vffeexo+fLgmTpyop59+utb9OZ1OOZ3OK54bAGAvlhda9+7d5XQ6VVRUpGHDhtW6TWxsrO6++27dfffdGjJkiB588ME6Cw0A8NNkeaFFRkZq2rRpysjIkNvt1uDBg1VWVqYtW7YoKipKBQUF6tOnj6677jq5XC699dZbuvbaa62ODQCwGcsLTZLmzJmj2NhYZWdn68iRI2rZsqV69+6tRx55RMXFxcrKytLRo0cVHh6uIUOG6JVXXrE6MgDAZmxRaA6HQ+np6UpPT6+xbujQoXrssccsSAUACCSWn+UIAEBjoNAAAEag0AAARqDQAABGoNAAAEag0AAARqDQAABGoNAAAEag0AAARqDQAABGoNAAAEag0AAARqDQAABGoNAAAEag0AAARqDQAABGsMUNPptCt+f+oZAgp9UxGqZdnNUJ/FJ14kurI/gtcm+p1RH80yra6gR+cbirrY7gF8/ho1ZH8Fuz/9fS6ggN8v13ldIt9duWCQ0AYAQKDQBgBAoNAGAECg0AYAQKDQBgBAoNAGAECg0AYAQKDQBgBAoNAGAECg0AYAQKDQBgBAoNAGAECg0AYAQKDQBgBAoNAGAECg0AYAQKDQBgBNsWmsfjUVpamlq1aiWHw6Hdu3dbHQkAYGMhVgeoy7vvvqtVq1YpNzdXXbp0UUxMjNWRAAA2ZttCKygoUHx8vAYNGlTr+srKSoWFhTVxKgCAXdmy0O655x7l5ORIkhwOhzp16qTExERdf/31CgkJ0UsvvaQbbrhBH3zwgcVJAQB2YcvP0J555hnNnj1bHTp0UElJiT755BNJUk5OjsLCwrRlyxYtWbKk1te6XC6Vl5f7PAAA5rPlhBYdHa3IyEgFBwcrLi7OuzwpKUlPPfXURV+bnZ2tWbNmXemIAACbseWEVpc+ffpccpusrCyVlZV5H8XFxU2QDABgNVtOaHVp0aLFJbdxOp1yOp1NkAYAYCcBNaEBAFAXCg0AYAQKDQBgBNt+hjZ16lRNnTrV+zw3N9eyLAAA+2NCAwAYgUIDABiBQgMAGIFCAwAYgUIDABiBQgMAGIFCAwAYgUIDABiBQgMAGIFCAwAYgUIDABiBQgMAGIFCAwAYgUIDABiBQgMAGMG290NrLB6PR5JU5a60OIkf3FVWJ/BLled7qyP4zVPtsjqCn4KtDuCfQPx3KcnjCczckqTvAit71f/lPf+z/GIcnvpsFcC++OILJSQkWB0DAHAZiouL1aFDh4tuY3yhud1unThxQpGRkXI4HI267/LyciUkJKi4uFhRUVGNuu8ridxNK1BzS4GbndxN60rm9ng8On36tNq1a6egoIt/Smb8IcegoKBLtvrlioqKCqg333nkblqBmlsK3OzkblpXKnd0dHS9tuOkEACAESg0AIARKLTL4HQ6NXPmTDmdTqujNAi5m1ag5pYCNzu5m5Zdcht/UggA4KeBCQ0AYAQKDQBgBAoNAGAECg0AYAQKDQBgBAoNANAg33//vYYPH65Dhw5ZHcUHhfYTUlBQoMcee0xjxoxRaWmpJOmdd97R559/bnEy2E1lZaW++OILFRUV+TzQ+HJycvT22297n0+fPl0tW7bUoEGDdOzYMQuT1S00NFR79uyxOkYN/B5aAwUHB6ukpERt2rTxWf7NN9+oTZs2qq6utijZxW3atEm33HKLbrzxRm3evFn79+9Xly5dNG/ePO3YsUNr1661OqLX4sWL673tlClTrmCSyxOI75VDhw7pD3/4g7Zu3eqz3OPxyOFw2C7zm2++We9tb7vttiuYxH/dunXT888/r5tuuknbtm3TL3/5Sy1cuFBvvfWWQkJCtG7dOqsj1iojI0NOp1Pz5s2zOoqX8Rcnbmx19b/L5VJYWFgTp6m/hx9+WE8++aQyMzMVGRnpXX7TTTfpv/7rvyxMVtPChQvrtZ3D4bB1oQXie+Wee+5RSEiI3nrrLcXHxzf6HSoa26hRo+q1nR3L+Lzi4mJdddVVkqQ33nhDd9xxh9LS0nTjjTcqJSXF2nAXUVVVpRUrVuj9999Xnz591KJFC5/1CxYsaPJMFFo9nZ8aHA6Hli9froiICO+66upqbd68Wddcc41V8S5p7969+u///u8ay9u0aaOvv/7agkR1KywsrHX5+YKw+w/ZQH6v7N69Wzt37rRtvh9zu91WR7hsERER+uabb9SxY0dt2LBBmZmZkqRmzZrp7NmzFqfztWfPHl1//fUKCgrSZ599pt69e0uSDh486LOdVf9GKbR6Oj81eDweLVmyRMHB/7xDcFhYmBITE7VkyRKr4l1Sy5YtVVJSos6dO/ss37Vrl9q3b29Rqvp54YUXtHDhQu8H0ElJSZo6daruvfdei5PVLpDfK927d7fdf3AaYuPGjdq4caNKS0t9ys7hcOiFF16wMFndRowYoXvvvVfJyck6ePCgbr31VknS559/rk6dOlmczldycrL3MPqxY8f0ySefqHXr1lbH8qLQ6un81PCLX/xCr7/+ulq2bBkwE4MkjR49Wg899JBee+01ORwOud1ubdmyRdOmTVNqaqrV8er0+OOPa8GCBZo8ebIGDhwoSdq2bZsyMjJUVFSk2bNnW5ywptreK4HiP//zPzV9+nTNnTtXN9xwg0JDQ33W2/keXbNmzdLs2bPVt2/fgDhcet6f//xnzZgxQ8XFxVq3bp23IHbu3Kl/+7d/szidr5YtW6qwsFBt2rTR0aNHbTchc1KIHwJtYpB+OGtt4sSJWrVqlaqrqxUSEqKqqiqNHTtWq1at8pki7CQ2NlaLFy/WmDFjfJavWbNGkydPtt00kZmZqTlz5qhFixbKyMi46A9VKz5juJQL7wh8YXa7nhRyofj4eD311FO66667rI7SYJs3b9bSpUt15MgRrV27Vu3bt9fq1avVpUsXDR482Op4XmlpaVq9erXi4+NVVFSkDh061Pmz48iRI02cjgmtwWbOnKn58+cH1MQg/XCo6y9/+Ysef/xx7d27VxUVFUpOTlZSUpLV0S7q+++/V9++fWss79Onj6qqqixIdHG7du3S999/L+mHz6PqYtfp4YMPPrA6gt8qKys1aNAgq2M02F//+lfdddddGjt2rHbt2iWXyyVJKi8v19y5c7V+/XqLE/7TsmXLdPvtt+vw4cOaMmWK7rvvPp+TzKzGhNZAgTQxnP9wuT7sOC1I0uTJkxUaGloj37Rp03T27Fn9+c9/tiiZuT788EMtXbpUBQUF3mnhxRdfVOfOnW01LfzYQw89pIiICM2YMcPqKA2SnJysjIwMpaamKjIyUvn5+erSpYt27dqlW265RV9++aXVEWs1btw4LV682FaFxoTWQIE0Mezatcvn+aeffqqqqip169ZN0g9nJgUHB6tPnz5WxKu3F154QRs2bNCAAQMkSXl5eSoqKlJqaqpPadu1lANJXdNCWVmZ7aaFHzt37pyWLVum999/Xz169Kjx+Z9d3x8HDhzQ0KFDayyPjo7Wt99+2/SB6mnlypVWR6iBQmugu+66S88//3yNfxzLli3T2LFjLUpVuwsPHy1YsECRkZHKycnRz372M0nSqVOnNG7cOA0ZMsSqiJd04anBBQUFkqSYmBjFxMTos88+825n10N4gebJJ5/UkiVLlJqaqldeecW7/MYbb9STTz5pYbJL27Nnj3r16iVJPu8Nyd7vj7i4OB0+fFiJiYk+yz/66CN16dLFmlABikOODTR58mStXr1aCQkJtU4MF/6v0E7/I2zfvr02bNig6667zmf5Z599pl/96lc6ceKERclgJ82bN9e+ffuUmJjoc/jryJEj6t69u86dO2d1RONkZ2frpZde0ooVKzRixAitX79ex44dU0ZGhmbMmKHJkydbHTFgMKE1UKBODOXl5frqq69qLP/qq690+vRpCxLBjpgWmt7DDz8st9ut4cOH68yZMxo6dKicTqemTZtGmTUQE9pPRGpqqj788EPNnz9f/fr1k/TDZPnggw9qyJAhysnJsTgh7IBpwTqVlZU6fPiwKioq1L17d58rzKB+KLSfiDNnzmjatGlasWKF97TykJAQjR8/Xn/6059qXIcNP00ej0dz585Vdna2zpw5I0neaWHOnDkWpwMujkL7ifnuu++8h0q7du1KkaFWTAsIRBQaAMAI3OATAGAECg0AYAQKDQBgBAoNCDCJiYlatGiR97nD4dAbb7zR5DmeeOIJ75U5ADug0IAAV1JSoltuuaVe21JCMBlXCgEsUFlZqbCwsEbZV1xcXKPsBwh0TGhAI0hJSdGkSZM0adIkRUdHKyYmRjNmzPDe1TwxMVFz5sxRamqqoqKilJaWJumHS0oNGTJE4eHhSkhI0JQpU/Tdd99591taWqrf/OY3Cg8PV+fOnfXyyy/X+No/PuT4xRdfaMyYMWrVqpVatGihvn37Ki8vT6tWrdKsWbOUn58vh8Mhh8OhVatWSZK+/fZb3XvvvYqNjVVUVJRuuukm5efn+3ydefPmqW3btoqMjNT48eO5riNsh0IDGklOTo5CQkL08ccf65lnntGCBQu0fPly7/qnn35aPXv21K5duzRjxgwVFBRo5MiRuuOOO7Rnzx79z//8jz766CNNmjTJ+5p77rlHxcXF+uCDD7R27Vo999xzKi0trTNDRUWFhg0bpuPHj+vNN99Ufn6+pk+fLrfbrTvvvFMPPPCArrvuOpWUlKikpER33nmnJOl3v/udSktL9c4772jnzp3q3bu3hg8frpMnT0qSXn31VT3xxBOaO3euduzYofj4eD333HNX6G8S8JMHwGUbNmyY59prr/W43W7vsoceeshz7bXXejwej6dTp06eUaNG+bxm/PjxnrS0NJ9lH374oScoKMhz9uxZz4EDBzySPB9//LF3/f79+z2SPAsXLvQuk+R5/fXXPR6Px7N06VJPZGSk55tvvqk158yZMz09e/as8TWjoqI8586d81netWtXz9KlSz0ej8czcOBAz7//+7/7rO/fv3+NfQFWYkIDGsmAAQN87rIwcOBAHTp0SNXV1ZJU48aw+fn5WrVqlSIiIryPm2++WW63W4WFhdq/f79CQkJ8bsB6zTXXqGXLlnVm2L17t5KTk9WqVat6587Pz1dFRYVat27tk6WwsNB7mbT9+/erf//+Pq8bOHBgvb8G0BQ4KQRoIj++bmZFRYUmTJigKVOm1Ni2Y8eOOnjwYIO/Rnh4eINfU1FRofj4eOXm5tZYd7HyBOyGQgMaSV5ens/z7du3KykpScHBwbVu37t3b+3bt09XXXVVreuvueYaVVVVaefOnfr5z38uSTpw4IC+/fbbOjP06NFDy5cv18mTJ2ud0sLCwrwT44U5vvzyS4WEhNS4D9p51157rfLy8pSamurz/QF2wiFHoJEUFRUpMzNTBw4c0Jo1a/Tss88qPT29zu0feughbd26VZMmTdLu3bt16NAh/e1vf/OeFNKtWzeNHDlSEyZMUF5ennbu3Kl77733olPYmDFjFBcXp1GjRmnLli06cuSI/vrXv2rbtm2SfjjbsrCwULt379bXX38tl8ulX/7ylxo4cKBGjRqlDRs26OjRo9q6daseffRR7dixQ5KUnp6uFStWaOXKlTp48KBmzpypzz//vBH/9oDLR6EBjSQ1NVVnz55Vv379NHHiRKWnp3tPz69Njx49tGnTJh08eFBDhgxRcnKyHn/8cbVr1867zcqVK9WuXTsNGzZMt99+u9LS0tSmTZs69xkWFqYNGzaoTZs2uvXWW3XDDTdo3rx53inxjjvu0MiRI/WLX/xCsbGxWrNmjRwOh9avX6+hQ4dq3LhxuvrqqzV69GgdO3ZMbdu2lSTdeeedmjFjhqZPn64+ffro2LFjuv/++xvpbw5oHNw+BmgEKSkp6tWrl88lqQA0LSY0AIARKDQAgBE45AgAMAITGgDACBQaAMAIFBoAwAgUGgDACBQaAMAIFBoAwAgUGgDACBQaAMAIFBoAwAj/HwcDRtSR8n6GAAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 0.37%\n"
     ]
    }
   ],
   "source": [
    "train_and_evaluate(model_without_attention)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice how fast the learning has been in this case! In a couple minutes, we get a model that can identify the language of a conversation to some extent (50% zero-shot accuracy). With longer training times, larger models and more data, we can get very reliable models with this architecture."
   ]
  }
 ],
 "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.11.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}