{ "cells": [ { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "# Wavenet name generator" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "## Data preprocessing\n", "\n", "First, let's import our dependencies:" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/home/ritsuko/.local/lib/python3.10/site-packages/tqdm/auto.py:22: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", " from .autonotebook import tqdm as notebook_tqdm\n" ] } ], "source": [ "import torch\n", "import torch.nn as nn\n", "import torch.nn.functional as F\n", "import pandas as pd\n", "import numpy as np" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "Now we import our dataset:" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
namegendercount
0EmilyF26539
1HannahF21677
2AlexisF19234
3SarahF19112
4SamanthaF19040
\n", "
" ], "text/plain": [ " name gender count\n", "0 Emily F 26539\n", "1 Hannah F 21677\n", "2 Alexis F 19234\n", "3 Sarah F 19112\n", "4 Samantha F 19040" ] }, "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": [ "df = pd.read_csv(\"datasets/names/yob1999.csv\", header=None)\n", "# Cool idea: maybe weight this by frequency somehow?\n", "df.columns = [\"name\", \"gender\", \"count\"]\n", "df.head()" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "We reprise our data cleaning steps from earlier:" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
namegendercount
0emilyF26539
1hannahF21677
2alexisF19234
3sarahF19112
4samanthaF19040
............
16939zohalF5
16940zophiaF5
16941zuhaF5
16942zuhalF5
16943zuzuF5
\n", "

16944 rows × 3 columns

\n", "
" ], "text/plain": [ " name gender count\n", "0 emily F 26539\n", "1 hannah F 21677\n", "2 alexis F 19234\n", "3 sarah F 19112\n", "4 samantha F 19040\n", "... ... ... ...\n", "16939 zohal F 5\n", "16940 zophia F 5\n", "16941 zuha F 5\n", "16942 zuhal F 5\n", "16943 zuzu F 5\n", "\n", "[16944 rows x 3 columns]" ] }, "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Just for today, 2023-02-22\n", "df = df[df[\"gender\"] == \"F\"]\n", "df[\"name\"] = df[\"name\"].str.lower()\n", "df" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "Now we break up the names such that we get the preceding three chars (or \".\") in one col and the char itself in another:" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[('c', '.....'),\n", " ('a', '....c'),\n", " ('t', '...ca'),\n", " ('h', '..cat'),\n", " ('e', '.cath'),\n", " ('y', 'cathe'),\n", " ('.', 'athey')]" ] }, "execution_count": 5, "metadata": {}, "output_type": "execute_result" } ], "source": [ "test_name = \"cathey\"\n", "def split_name(name, window_size):\n", " pairs = []\n", " for idx, char in enumerate(name):\n", " triple = (name[max(0, idx-window_size):idx].rjust(window_size, '.'))\n", " pairs.append((char, triple))\n", "\n", " pairs.append(('.', name[max(0, len(name) - window_size):].rjust(window_size, '.')))\n", " return(pairs)\n", "\n", "split_name(test_name, 5)" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "We apply this to all names:" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "0 (e, ........)\n", "0 (m, .......e)\n", "0 (i, ......em)\n", "0 (l, .....emi)\n", "0 (y, ....emil)\n", " ... \n", "16943 (z, ........)\n", "16943 (u, .......z)\n", "16943 (z, ......zu)\n", "16943 (u, .....zuz)\n", "16943 (., ....zuzu)\n", "Name: name, Length: 124361, dtype: object" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ "pairs = df[\"name\"].apply(lambda n: split_name(n, 8)).explode()\n", "pairs" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "We convert characters to numbers:" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [], "source": [ "def char2idx(c):\n", " # Assumes valid input\n", " return(0 if c == \".\" else ord(c) - ord(\"a\") + 1)\n", "\n", "def idx2char(i):\n", " if i == 0:\n", " return \"\"\n", " elif i < 28:\n", " return(chr(i+ord(\"a\")-1))\n", " else:\n", " return(\"ERR\")\n", "\n", "labels = pairs.apply(lambda p: char2idx(p[0]))\n", "contexts = pairs.apply(lambda p: list(map(char2idx, p[1])))" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "Finally, we make this into tensors:" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [], "source": [ "labels = F.one_hot(torch.tensor(labels.tolist()), 27)\n", "# OK that we're not one-hot encoding this since we're using these as indices into an embedding matrix\n", "contexts = torch.tensor(contexts.tolist())" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "Finally, we put this into a *bona fide* PyTorch dataset:" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [], "source": [ "from torch.utils.data import TensorDataset, DataLoader\n", "\n", "dataset = TensorDataset(contexts, labels)\n", "\n", "train_size = int(0.8 * len(contexts))\n", "test_size = len(contexts) - train_size\n", "train_len = int(train_size / len(dataset) * len(dataset))\n", "test_len = len(dataset) - train_len\n", "train_dataset, test_dataset= torch.utils.data.random_split(dataset, [train_len,test_len])" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "## Training loop" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "### Primitives: Ghetto PyTorch" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "~~I'm just going to write out the entire MLP class at once. This is terrible, but my laziness and depression have forced my hand.~~ nvm we in our pytorch era fr fr, as the kids say. first we make our embedding layer:" ] }, { "cell_type": "code", "execution_count": 40, "metadata": {}, "outputs": [], "source": [ "class Embedding:\n", " def __init__(self, num_embeddings, embedding_dim):\n", " # Vocab size\n", " self.num_embeddings = num_embeddings\n", " # Dimensions\n", " self.embedding_dim = embedding_dim\n", " self.weight = torch.randn(num_embeddings, embedding_dim)\n", " \n", " def __call__(self, x):\n", " raw = self.weight[x]\n", " #return(raw.view(raw.shape[0], -1))\n", " self.out = raw\n", " return(self.out)\n", "\n", " def parameters(self):\n", " return([self.weight])" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "Then we make the \"ghetto linear layer\":" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [], "source": [ "class Linear:\n", " def __init__(self, in_features, out_features, bias=True):\n", " self.W = torch.empty(in_features, out_features)\n", " nn.init.kaiming_normal(self.W, nonlinearity=\"tanh\")\n", " self.hasBias = bias\n", " if bias:\n", " self.B = torch.randn(out_features) * 1e-4\n", " \n", " def __call__(self, input):\n", " # Assumes valid input lol\n", " self.out = input @ self.W\n", " return(self.out + self.B if self.hasBias else self.out)\n", "\n", " def parameters(self):\n", " # wtf does this do???\n", " return [self.W, self.B] if self.hasBias else [self.W]\n" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "### Batch normalization\n", "\n", "Intuitively, what we're trying to do is to manually \"normalize\" the whole batch activations to be like the normal distribution around 0.\n", "\n", "How we accomplish this:\n", "- Kill bias layer in middle\n", "- Keep running mean and stdev of batch, which we (somewhat arbitrarily) set to update by 1e-3 each cycle\n", "- Subtract mean and divide by the standard deviation\n", "- Add learned bias?" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [], "source": [ "class BatchNorm1d:\n", " def __init__(self, num_features, eps=1e-05,momentum=0.1):\n", " # Learned scaling factor\n", " self.Gamma = torch.randn(num_features) * 1e-1\n", " self.Beta = torch.randn(num_features) * 1e-4\n", " self.eps = eps\n", " self.mean = 0\n", " self.std = 0\n", " self.momentum = momentum\n", " self.training = True\n", "\n", " def __call__(self, x):\n", " if self.training:\n", " res = self.Gamma * ((x - x.mean(0, keepdim=True)) / (x.std(0, keepdim=True) + self.eps)) + self.Beta\n", " with torch.no_grad():\n", " # Update learned parameters\n", " self.mean = (1 - self.momentum) * self.mean + self.momentum * x.mean(0)\n", " self.std = (1 - self.momentum) * self.std + self.momentum * x.std(0)\n", " else:\n", " res = self.Gamma * ((x - self.mean) / (self.std + self.eps)) + self.Beta\n", "\n", " return(res)\n", " \n", " def parameters(self):\n", " return([self.Gamma, self.Beta])\n", " \n" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "Finally, we wrap `tanh` for convenience:" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [], "source": [ "class Tanh:\n", " def __call__(self, x):\n", " self.out = torch.tanh(x)\n", " return(self.out)\n", " def parameters(self):\n", " return([])" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "### Sequential\n", "\n", "For completeness, we also re-implement the PyTorch [Sequential](https://pytorch.org/docs/stable/generated/torch.nn.Sequential.html?highlight=sequential#torch.nn.Sequential) class, even though I don't really see why:" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [], "source": [ "class Sequential:\n", " # Not implementing OrderedDict support unless Karpathy tells me to\n", " def __init__(self, *args):\n", " self.layers = [arg for arg in args]\n", " \n", " def __call__(self, x):\n", " for layer in self.layers:\n", " x = layer(x)\n", "\n", " return(x)\n", "\n", " def parameters(self):\n", " return([p for l in self.layers for p in l.parameters()])\n", "\n", " def append(self, module):\n", " self.layers.append(module)\n", "\n" ] }, { "cell_type": "code", "execution_count": 31, "metadata": {}, "outputs": [], "source": [ "class FlattenConsecutive:\n", " def __init__(self, n):\n", " self.n = n\n", "\n", " def __call__(self, x):\n", " # Batch, groups, concat\n", " n = self.n\n", " B, T, C = x.shape\n", " # Ex. if n == 2, double amount of data in group, halve number of groups\n", " x = x.view(B, T//n, C*n)\n", " if x.shape[1] == 1:\n", " # Remove extraneous T dimension\n", " x = x.squeeze(1)\n", " \n", " self.out = x\n", " return self.out\n", " \n", " def parameters(self):\n", " # No params, this is just a utility function\n", " return []" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "Testing matrix multiplies to make sure my intuition is correct:" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "### Wavenet class" ] }, { "cell_type": "code", "execution_count": 39, "metadata": {}, "outputs": [], "source": [ "class MLP:\n", " def __init__(self, embedding_size, vocab_size, block_size, hidden_size):\n", " self.embedding_size = embedding_size\n", " self.vocab_size = vocab_size\n", " self.block_size = block_size\n", " self.hidden_size = hidden_size\n", "\n", " # Hidden layer\n", " self.layers = Sequential(\n", " Embedding(vocab_size, embedding_size),\n", " FlattenConsecutive(2), Linear(embedding_size * 2, hidden_size), BatchNorm1d(hidden_size), Tanh(),\n", " FlattenConsecutive(2), Linear(embedding_size * 2, hidden_size), BatchNorm1d(hidden_size), Tanh(),\n", " FlattenConsecutive(2), Linear(embedding_size * 2, hidden_size), BatchNorm1d(hidden_size), Tanh(),\n", " Linear(hidden_size, vocab_size)\n", " )\n", "\n", " # Make less confident in front of softmax. This is terrible but VGUI has forced my hand\n", " self.layers.layers[-1].W *= 1e-1\n", " for p in self.layers.parameters():\n", " p.requires_grad = True\n", "\n", " \n", " def infer(self, x):\n", " \"\"\"Returns logits for future use\"\"\"\n", " with torch.no_grad():\n", " for layer in self.layers.layers:\n", " if isinstance(layer, BatchNorm1d):\n", " layer.training = False\n", "\n", " return(self.layers(x))\n", "\n", " def forward(self, x):\n", " \"\"\"Takes batch of contexts; returns logits\"\"\"\n", " return(self.layers(x))\n", "\n", " def backward(self, x, y_true):\n", " y_pred = self.forward(x)\n", " loss = F.cross_entropy(y_pred, y_true)\n", "\n", " # Zero out gradients\n", " for p in self.layers.parameters():\n", " p.grad = None\n", "\n", " loss.backward()\n", " return loss\n", " \n", " def update_parameters(self, lr):\n", " # Subtract the gradients\n", " with torch.no_grad():\n", " # There HAS to be a better way to do this\n", " for p in self.layers.parameters():\n", " p.data -= lr * p.grad\n", "\n", " def fit_one_cycle(self, x, y_true, lr, show_loss=False):\n", " loss = self.backward(x, y_true)\n", " if show_loss:\n", " print(f\"Loss: {loss.item()}\")\n", " self.update_parameters(lr)\n", " return(loss.item())\n", " \n" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "Now it merely falls to us to write the driver code:" ] }, { "cell_type": "code", "execution_count": 41, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/tmp/ipykernel_47727/1279679824.py:4: UserWarning: nn.init.kaiming_normal is now deprecated in favor of nn.init.kaiming_normal_.\n", " nn.init.kaiming_normal(self.W, nonlinearity=\"tanh\")\n" ] }, { "ename": "AttributeError", "evalue": "'Embedding' object has no attribute 'out'", "output_type": "error", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mAttributeError\u001b[0m Traceback (most recent call last)", "Cell \u001b[0;32mIn [41], line 20\u001b[0m\n\u001b[1;32m 12\u001b[0m model \u001b[39m=\u001b[39m MLP(\n\u001b[1;32m 13\u001b[0m embedding_size\u001b[39m=\u001b[39mEMBEDDING_NDIM, \n\u001b[1;32m 14\u001b[0m hidden_size\u001b[39m=\u001b[39mHIDDEN_NDIM,\n\u001b[1;32m 15\u001b[0m vocab_size\u001b[39m=\u001b[39mVOCAB_SIZE,\n\u001b[1;32m 16\u001b[0m block_size\u001b[39m=\u001b[39mBLOCK_SIZE\n\u001b[1;32m 17\u001b[0m )\n\u001b[1;32m 19\u001b[0m \u001b[39mfor\u001b[39;00m layer \u001b[39min\u001b[39;00m model\u001b[39m.\u001b[39mlayers\u001b[39m.\u001b[39mlayers:\n\u001b[0;32m---> 20\u001b[0m \u001b[39mprint\u001b[39m(layer\u001b[39m.\u001b[39m\u001b[39m__class__\u001b[39m\u001b[39m.\u001b[39m\u001b[39m__name__\u001b[39m, \u001b[39m'\u001b[39m\u001b[39m:\u001b[39m\u001b[39m'\u001b[39m, \u001b[39mtuple\u001b[39m(layer\u001b[39m.\u001b[39;49mout\u001b[39m.\u001b[39mshape))\n\u001b[1;32m 21\u001b[0m \u001b[39m\"\"\"\u001b[39;00m\n\u001b[1;32m 22\u001b[0m \u001b[39mglobal_step = 0\u001b[39;00m\n\u001b[1;32m 23\u001b[0m \u001b[39mepoch = 0\u001b[39;00m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 39\u001b[0m \u001b[39m break\u001b[39;00m\n\u001b[1;32m 40\u001b[0m \u001b[39m \"\"\"\u001b[39;00m\n", "\u001b[0;31mAttributeError\u001b[0m: 'Embedding' object has no attribute 'out'" ] } ], "source": [ "VOCAB_SIZE = 27\n", "BLOCK_SIZE = 8\n", "BATCH_SIZE = 16\n", "EMBEDDING_NDIM = 10\n", "HIDDEN_NDIM = 68\n", "STEPS=10000\n", "\n", "# Simple exponential decay\n", "lrs = 10 ** np.linspace(0, -3, STEPS + 1)\n", "\n", "train_dataloader = DataLoader(train_dataset, batch_size=BATCH_SIZE)\n", "model = MLP(\n", " embedding_size=EMBEDDING_NDIM, \n", " hidden_size=HIDDEN_NDIM,\n", " vocab_size=VOCAB_SIZE,\n", " block_size=BLOCK_SIZE\n", ")\n", "\n", "for layer in model.layers.layers:\n", " print(layer.__class__.__name__, ':', tuple(layer.out.shape))\n", "\"\"\"\n", "global_step = 0\n", "epoch = 0\n", "lossi = []\n", "while global_step < STEPS:\n", " for step, (data, labels) in enumerate(train_dataloader):\n", " should_print = global_step % 500 == 0\n", " if (should_print):\n", " print(f\"Step {global_step}:\")\n", " loss = model.fit_one_cycle(data, labels.float(), lrs[step], should_print)\n", " if global_step % 10 == 0:\n", " lossi.append(loss)\n", "\n", " global_step += 1\n", " if global_step >= STEPS:\n", " break\n", " epoch += 1\n", " if global_step >= STEPS:\n", " break\n", " \"\"\"\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "What's the loss curve through training?" ] }, { "cell_type": "code", "execution_count": 63, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "import matplotlib.pyplot as plt\n", "losses = pd.DataFrame({\n", " \"step\": np.arange(0, STEPS, 10),\n", " \"loss\": lossi\n", "})\n", "losses[\"rolling_loss\"] = losses[\"loss\"].rolling(window=50).mean()\n", "plt.plot(losses[\"step\"], losses[\"rolling_loss\"])\n", "plt.xlabel(\"step\")\n", "plt.ylabel(\"Loss (ln)\")\n", "plt.title(\"Training loss for wavenet\")\n", "plt.show()" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "After some tinkering, we find that small batch sizes (8), linear decay LR from 0.5 to 1e-2, and higher steps decrease rate (severe overfitting begins...)\n", "Finally, we get the loss on the training set (we technically need a validation, but I can't be bothered):" ] }, { "cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "tensor(2.1259, grad_fn=)" ] }, "execution_count": 21, "metadata": {}, "output_type": "execute_result" } ], "source": [ "test_dataloader = DataLoader(test_dataset, batch_size=len(test_dataset))\n", "test_loss = 0\n", "for data, labels in test_dataloader:\n", " loss = model.backward(data, labels.float())\n", "\n", "loss" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "## Generation" ] }, { "cell_type": "code", "execution_count": 67, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "kodoly\n", "wastora\n", "alyania\n", "jalon\n", "telinza\n", "beolane\n", "katulive\n", "deadah\n", "meiete\n", "syely\n", "sarla\n", "zicfynza\n", "krertona\n", "kveenanna\n", "layzah\n", "marlyn\n", "aki\n", "dave\n", "mylyn\n", "alianea\n" ] } ], "source": [ "g = torch.Generator()\n", "\n", "for _ in range(20):\n", " out = []\n", " context = [0] * model.block_size\n", " while True:\n", " logits = model.infer(torch.tensor([context]))\n", " probs = F.softmax(logits, dim=1)\n", " # randomly sample pred from distribution\n", " ix = torch.multinomial(probs, num_samples=1, generator=g).item()\n", " # shift context\n", " context = context[1:] + [ix]\n", " out.append(ix)\n", " if ix == 0:\n", " break\n", "\n", " print(''.join(idx2char(i) for i in out))" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "## Testing and validation" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "### Finding the learning rate\n", "\n", "This hyperparameter is kind of important (citation needed). To start, we want to implement something like the \"learning rate finder\", where we exponentially increase lr until we hit a wall and then find it somewhere around there. Let's give it a try! Let's go from $10^{-3}$ to $10^1$ in increments of 2x???" ] }, { "cell_type": "code", "execution_count": 60, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Loss: 7.430624008178711\n", "Loss: 5.907592296600342\n", "Loss: 6.736423969268799\n", "Loss: 6.276147842407227\n", "Loss: 8.191972732543945\n", "Loss: 6.006835460662842\n", "Loss: 7.029684066772461\n", "Loss: 5.80147647857666\n", "Loss: 6.876686096191406\n", "Loss: 6.443017482757568\n", "Loss: 6.2708916664123535\n", "Loss: 5.996418476104736\n", "Loss: 6.9694013595581055\n", "Loss: 7.181060314178467\n", "Loss: 7.285386562347412\n", "Loss: 6.76036262512207\n", "Loss: 4.900427341461182\n", "Loss: 6.592562198638916\n", "Loss: 7.163669586181641\n", "Loss: 6.860597133636475\n", "Loss: 6.350022315979004\n", "Loss: 6.802441120147705\n", "Loss: 5.725580215454102\n", "Loss: 6.045586109161377\n", "Loss: 7.162632465362549\n", "Loss: 6.112359046936035\n", "Loss: 6.745479106903076\n", "Loss: 8.428348541259766\n", "Loss: 7.566260814666748\n", "Loss: 7.213047027587891\n", "Loss: 6.1751508712768555\n", "Loss: 6.329876899719238\n", "Loss: 5.869903087615967\n", "Loss: 6.829679489135742\n", "Loss: 7.537769317626953\n", "Loss: 6.489545822143555\n", "Loss: 6.2317705154418945\n", "Loss: 6.0110626220703125\n", "Loss: 7.265320301055908\n", "Loss: 8.121577262878418\n", "Loss: 6.227502822875977\n", "Loss: 6.25087833404541\n", "Loss: 6.188232421875\n", "Loss: 6.488334655761719\n", "Loss: 6.584030628204346\n", "Loss: 7.6949005126953125\n", "Loss: 5.654526710510254\n", "Loss: 7.727835655212402\n", "Loss: 7.618391036987305\n", "Loss: 6.659497261047363\n", "Loss: 6.021166801452637\n", "Loss: 5.73284912109375\n", "Loss: 7.275735855102539\n", "Loss: 7.702166557312012\n", "Loss: 6.327794075012207\n", "Loss: 7.663393020629883\n", "Loss: 7.484796524047852\n", "Loss: 5.963756084442139\n", "Loss: 6.558468818664551\n", "Loss: 6.1140923500061035\n", "Loss: 6.24030876159668\n", "Loss: 7.007579803466797\n", "Loss: 6.0864386558532715\n", "Loss: 5.9844818115234375\n", "Loss: 6.91998291015625\n", "Loss: 6.734277725219727\n", "Loss: 6.336721420288086\n", "Loss: 7.672022819519043\n", "Loss: 5.989048957824707\n", "Loss: 6.733485698699951\n", "Loss: 5.5550537109375\n", "Loss: 5.841381072998047\n", "Loss: 5.7277727127075195\n", "Loss: 6.139680862426758\n", "Loss: 6.417255401611328\n", "Loss: 5.787105560302734\n", "Loss: 4.683682441711426\n", "Loss: 5.241340637207031\n", "Loss: 6.151970863342285\n", "Loss: 5.528073310852051\n", "Loss: 5.105097770690918\n", "Loss: 5.662375450134277\n", "Loss: 5.931535243988037\n", "Loss: 4.8722124099731445\n", "Loss: 5.265300750732422\n", "Loss: 4.733351707458496\n", "Loss: 4.9881744384765625\n", "Loss: 5.1370649337768555\n", "Loss: 3.952605724334717\n", "Loss: 4.298478126525879\n", "Loss: 4.196227073669434\n", "Loss: 5.217850208282471\n", "Loss: 4.802611351013184\n", "Loss: 5.492189884185791\n", "Loss: 4.618756294250488\n", "Loss: 4.8330888748168945\n", "Loss: 4.640590190887451\n", "Loss: 5.387992858886719\n", "Loss: 5.0618767738342285\n", "Loss: 3.449434757232666\n", "Loss: 4.841926574707031\n", "Loss: 4.253867149353027\n", "Loss: 4.5569047927856445\n", "Loss: 5.104475021362305\n", "Loss: 4.032567501068115\n", "Loss: 3.5253655910491943\n", "Loss: 3.4031808376312256\n", "Loss: 4.417699813842773\n", "Loss: 4.6852946281433105\n", "Loss: 3.9664392471313477\n", "Loss: 3.41298770904541\n", "Loss: 3.531296968460083\n", "Loss: 4.684194564819336\n", "Loss: 3.7923243045806885\n", "Loss: 3.382225751876831\n", "Loss: 4.090125560760498\n", "Loss: 3.427050828933716\n", "Loss: 2.887465476989746\n", "Loss: 3.5737202167510986\n", "Loss: 3.6871047019958496\n", "Loss: 3.307684898376465\n", "Loss: 3.452899932861328\n", "Loss: 3.6090240478515625\n", "Loss: 3.590327739715576\n", "Loss: 3.6102278232574463\n", "Loss: 3.439237117767334\n", "Loss: 2.721630573272705\n", "Loss: 3.2753853797912598\n", "Loss: 3.287172317504883\n", "Loss: 2.9930880069732666\n", "Loss: 3.0358457565307617\n", "Loss: 2.8183953762054443\n", "Loss: 3.1593668460845947\n", "Loss: 2.7558887004852295\n", "Loss: 3.4922285079956055\n", "Loss: 2.4574546813964844\n", "Loss: 2.955148220062256\n", "Loss: 2.599187135696411\n", "Loss: 2.853722333908081\n", "Loss: 2.9035115242004395\n", "Loss: 2.849900722503662\n", "Loss: 2.9229700565338135\n", "Loss: 2.854335308074951\n", "Loss: 3.0771515369415283\n", "Loss: 2.834442138671875\n", "Loss: 2.8727121353149414\n", "Loss: 2.5702261924743652\n", "Loss: 3.5756044387817383\n", "Loss: 3.2493510246276855\n", "Loss: 3.4860177040100098\n", "Loss: 3.0239930152893066\n", "Loss: 3.4398820400238037\n", "Loss: 3.3091492652893066\n", "Loss: 3.1710703372955322\n", "Loss: 2.9252288341522217\n", "Loss: 3.1941142082214355\n", "Loss: 3.1485743522644043\n", "Loss: 3.181817054748535\n", "Loss: 3.405029773712158\n", "Loss: 3.1574606895446777\n", "Loss: 4.207228660583496\n", "Loss: 4.8890156745910645\n", "Loss: 3.880110263824463\n", "Loss: 5.588428020477295\n", "Loss: 5.6451287269592285\n", "Loss: 4.581236839294434\n", "Loss: 4.6465253829956055\n", "Loss: 4.523091793060303\n", "Loss: 4.723302364349365\n", "Loss: 4.5816216468811035\n", "Loss: 4.333004474639893\n", "Loss: 4.123793601989746\n", "Loss: 5.062790870666504\n", "Loss: 4.318625450134277\n", "Loss: 6.228353023529053\n", "Loss: 4.212017059326172\n", "Loss: 7.172618865966797\n", "Loss: 6.527228355407715\n", "Loss: 6.876657009124756\n", "Loss: 9.410812377929688\n", "Loss: 6.641336441040039\n", "Loss: 7.134503364562988\n", "Loss: 5.322292804718018\n", "Loss: 6.1632280349731445\n", "Loss: 6.492981910705566\n", "Loss: 12.327178955078125\n", "Loss: 10.03088092803955\n", "Loss: 12.911327362060547\n", "Loss: 11.744782447814941\n" ] } ], "source": [ "lr_model = MLP(EMBEDDING_NDIM, HIDDEN_NDIM)\n", "lr = 10e-4\n", "\n", "# WHY IS THIS LANGUAGE NOT TYPED AARGH\n", "losses = []\n", "i = 0\n", "\n", "while lr < 10:\n", " start, end = i * BATCH_SIZE, (i+1) * BATCH_SIZE\n", " loss = lr_model.backward(contexts[start:end], labels[start:end].float())\n", " lr_model.update_parameters(lr)\n", " losses.append({\"loss\" : loss.item(), \"lr\": lr})\n", " lr *= 1.05\n", " i+=1\n", "\n", "loss_df = pd.DataFrame.from_records(losses)\n", "loss_df[\"loss_smooth\"] = loss_df[\"loss\"].rolling(window=5).mean()" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "Now let's graph this:" ] }, { "cell_type": "code", "execution_count": 53, "metadata": {}, "outputs": [], "source": [ "import matplotlib.pyplot as plt" ] }, { "cell_type": "code", "execution_count": 61, "metadata": {}, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjMAAAG2CAYAAACKxwc0AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy88F64QAAAACXBIWXMAAA9hAAAPYQGoP6dpAABXbklEQVR4nO3dd3zTdf4H8FdGk+6U7g2lLXuPMgRFZAi4PTkniHqed56oePqTu3OdA9d5noqc58SBC8QtCMiQ2TJlthRKW7oHbdKVNMn390eSb1voSLq+3ySv5+ORx4Mm36RvCG3ffX/en/dHIQiCACIiIiI3pZQ6ACIiIqKuYDJDREREbo3JDBEREbk1JjNERETk1pjMEBERkVtjMkNERERujckMERERuTUmM0REROTWmMwQERGRW1NLHUBPs1qtKCwsRFBQEBQKhdThEBERkRMEQYDBYEBsbCyUyg5qL4KEtm7dKlxxxRVCTEyMAEBYu3Zti8fXrFkjzJw5UwgNDRUACAcOHHD5c+Tn5wsAeOONN9544403N7zl5+d3+LNe0spMbW0tRo4ciTvuuAPXXXddq49PmTIF8+fPxx/+8IdOfY6goCAAQH5+PoKDg7sULxEREfUOvV6PhIQE8ed4eyRNZubMmYM5c+a0+fhtt90GADhz5kynP4djaSk4OJjJDBERkZtxpkXE43pmjEYjjEaj+LFer5cwGiIiIuppHrebadmyZdDpdOItISFB6pCIiIioB3lcMrN06VJUV1eLt/z8fKlDIiIioh7kcctMWq0WWq1W6jCIiIiol3hcZYaIiIi8i6SVmZqaGmRnZ4sf5+Tk4ODBgwgNDUViYiIqKyuRl5eHwsJCAEBmZiYAIDo6GtHR0ZLETERERPIiaWVm7969GD16NEaPHg0AWLJkCUaPHo3HH38cAPDtt99i9OjRmDdvHgDgxhtvxOjRo/Hf//5XspiJiIhIXhSCIAhSB9GT9Ho9dDodqqurOWeGiIjITbjy85s9M0REROTWmMwQERGRW2MyQ0RERG6NyQwRERG5NSYzRERE1Cmf7MnFbe/uwRcZ0k7bZzJDREREnZJVbMCvJ8uRV1knaRxMZoiIiKhTaowWAECAVtrTkZjMEBERUafUGs0AgECtStI4mMwQERFRp9TYkxlWZoiIiMgt1YiVGSYzRERE5IZqmcwQERGRO6vlMhMRERG5M4OjMuPLZIaIiIjcjCAIXGYiIiIi99XQaIVVsP2Zy0xERETkdgzGRgCAQgH4+3DODBEREbmZWsf0X40aSqVC0liYzBAREZHLmnYySVuVAZjMEBERUScYGuSxLRtgMkNERESd4KjMBDGZISIiIndUa2JlhoiIiNyYXA6ZBJjMEBERUSfUNHCZiYiIiNyYXM5lApjMEBERUSfUOObMMJkhIiIid1RjnwAcyDkzRERE5I4cE4ClPmQSYDJDREREncDdTEREROTWHA3ArMwQERGRW3JUZgJ9mcwQERGRG+Iyk922bdtw5ZVXIjY2FgqFAl9//XWLxwVBwOOPP46YmBj4+flhxowZOHnypDTBEhERkYjLTHa1tbUYOXIkli9f3urjL774Il577TX897//xZ49exAQEIDZs2ejoaGhlyMlIiKi5uRUmZE0gjlz5mDOnDmtPiYIAl599VX84x//wNVXXw0A+PDDDxEVFYWvv/4aN954Y2+GSkRERHZGswWNFgEAKzPtysnJQXFxMWbMmCHep9PpMGHCBOzatavN5xmNRuj1+hY3IiIi6j6OGTMAEKDh0Lw2FRcXAwCioqJa3B8VFSU+1pply5ZBp9OJt4SEhB6Nk4iIyNs4+mV8fZRQq6RPJaSPoJstXboU1dXV4i0/P1/qkIiIiDyKocHR/OsjcSQ2sk1moqOjAQAlJSUt7i8pKREfa41Wq0VwcHCLGxEREXWfWpMjmZF+iQmQcTKTlJSE6OhobNq0SbxPr9djz549mDRpkoSREREReTc57WQCJN7NVFNTg+zsbPHjnJwcHDx4EKGhoUhMTMQDDzyAZ555BqmpqUhKSsJjjz2G2NhYXHPNNdIFTURE5OVqGuQzYwaQOJnZu3cvLr30UvHjJUuWAAAWLlyIDz74AI888ghqa2tx9913o6qqClOmTMG6devg6+srVchEREReT04D8wCJk5lp06ZBEIQ2H1coFPjnP/+Jf/7zn70YFREREbVHbstMsu2ZISIiInlyzJlhMkNERERuqcbYCAAIksGJ2QCTGSIiInJRjaMyo2EyQ0RERG6oVuyZ4ZwZIiIickOOBmAuMxEREZFb4m4mIiIicmu1TGaIiIjIncltaB6TGSIiInJJDZMZIiIicmdMZoiIiMhtWawCGhqtANgzQ0RERG6ovtEi/tlfwzkzRERE5GYamiUzWrU80gh5REFERERuod5kS2Z8fZRQKBQSR2PDZIaIiIic5qjM+PnIY4kJYDJDRERELqhnMkNERETurGmZickMERERuaEGs21bNpMZIiIickuOyoyfTLZlA0xmiIiIyAVsACYiIiK35mgA5jITERERuaWGxqY5M3Ihn0iIiIhI9rg1m4iIiNxaAxuAiYiIyJ2xMkNERERujQ3ARERE5NYaGjk0j4iIiNxY0zKTfFII+URCREREsscGYCIiInJr7JkhIiIit9bAZIaIiIjcWb29AZhbs11gMBjwwAMPoG/fvvDz88PkyZORkZEhdVhEREReSTxokj0zzrvrrruwYcMGfPTRRzh8+DBmzZqFGTNmoKCgQOrQiIiIvE69iUPzXFJfX481a9bgxRdfxMUXX4yUlBQ8+eSTSElJwYoVK1p9jtFohF6vb3EjIiKi7sEGYBeZzWZYLBb4+vq2uN/Pzw/bt29v9TnLli2DTqcTbwkJCb0RKhERkVfgqdkuCgoKwqRJk/D000+jsLAQFosFH3/8MXbt2oWioqJWn7N06VJUV1eLt/z8/F6OmoiIyDNZrQKMZjYAu+yjjz6CIAiIi4uDVqvFa6+9hptuuglKZeuha7VaBAcHt7gRERFR1zWYLeKf2QDsguTkZGzduhU1NTXIz89Heno6Ghsb0b9/f6lDIyIi8iqO5l8A8FUzmXFZQEAAYmJicO7cOaxfvx5XX3211CERERF5lQb7EpNGrYRSqZA4miZqqQPoyPr16yEIAgYOHIjs7Gw8/PDDGDRoEBYtWiR1aERERF5FjtuyATeozFRXV+Pee+/FoEGDsGDBAkyZMgXr16+Hj4+P1KERERF5FXFgnsySGdlXZubPn4/58+dLHQYREZHXq5fh9F/ADSozREREJA9yPGQSYDJDRERETnL0zMhpYB7AZIaIiIicVC/TnhkmM0REROQUuTYAM5khIiIip4jLTGwAJiIiInfUIMNzmQAmM0REROQkNgATERGRW2PPDBEREbk17mYiIiIityYOzWMDMBEREbmj+kZbA7CvmskMERERuSHx1GxWZoiIiMgdsQGYiIiI3Fo9D5okIiIidyZWZrjMRERERO5IrMyo5ZU+yCsaIiIikq0GNgATERGRO+PQPCIiInJrDY45M0xmiIiIyN0IgsDdTEREROS+jGar+Gf2zBAREZHbcUz/BbibiYiIiNyQY4lJo1JCrZJX+iCvaIiIiEiWxBOzfeSXOsgvIiIiIpIduTb/AkxmiIiIyAlyPcoAYDJDRERETqg32XYzyW1gHsBkhoiIiJzQwGUmIiIicmdyPcoAYDJDRERETqjnbiYiIiJyZ2wA7iSLxYLHHnsMSUlJ8PPzQ3JyMp5++mkIgiB1aERERF6lziTfnhm11AG054UXXsCKFSuwcuVKDB06FHv37sWiRYug0+mwePFiqcMjIiLyGhU1RgBAWIBG4kguJOtkZufOnbj66qsxb948AEC/fv3w6aefIj09XeLIiIiIvEuJ3pbMRAX7ShzJhWS9zDR58mRs2rQJWVlZAIBDhw5h+/btmDNnTpvPMRqN0Ov1LW5ERETUNSX6BgBApAyTGVlXZh599FHo9XoMGjQIKpUKFosFzz77LG655ZY2n7Ns2TI89dRTvRglERGR5ysz2CozkUFaiSO5kKwrM1988QU++eQTrFq1Cvv378fKlSvx8ssvY+XKlW0+Z+nSpaiurhZv+fn5vRgxERGRZ3JUZuS4zCTryszDDz+MRx99FDfeeCMAYPjw4cjNzcWyZcuwcOHCVp+j1Wqh1covayQiInJXNUYzau27mViZcVFdXR2UypYhqlQqWK1WiSIiIiLyPqX2qkygVo0ArfzqIPKLqJkrr7wSzz77LBITEzF06FAcOHAAr7zyCu644w6pQyMiIvIajp1MkcHyq8oAMk9mXn/9dTz22GP485//jNLSUsTGxuKPf/wjHn/8calDIyIi8hqlBvtOJhkuMQEyT2aCgoLw6quv4tVXX5U6FCIiIq9VKuMZM4DMe2aIiIhIenLeyQQwmSEiIqIOlMh4xgzAZIaIiIg6UCrj6b8AkxkiIiLqQKm9MhPFygwRERG5IzmfywQwmSEiIqJ21BjNqJPx9F+AyQwRERG1w1GVCZLp9F+AyQwRERG1wzFjJkKm038BJjNERETUDsf036ggefbLAExmiIiIqB1Nzb+szBAREZEbkvtRBgCTGSIiImqH3Kf/AkxmiIiIqB1ynzEDMJkhIiKidpTJfPovwGSGiIiI2lFRY0tmwgI1EkfSNiYzRERE1CpBEFBrn/4bqPWROJq2MZkhIiKiVhnNVlisAgAgQKuSOJq2MZkhIiKiVtUYzeKfAzTyPMoAYDJDREREbai1JzP+GhWUSoXE0bSNyQwRERG1ylGZkesBkw7yjo6IiIi6Tb3Jgmvf3IHCqnokhPpjUHQwHr9yCHR+rTf31jTYkpkgmSczrMwQdcKO7HJsP1kudRhERC45WliNE8UG6BvMOFqox5r9Z/HV/rNtXl9rco/KDJMZIhcZGhqx6IMM3PFBBqrqTFKHQ0TktIKqegDA8Dgdbp2YCABIz6ls8/oao21btpx3MgFMZohcdrK0BiazFSaLFQfyq6QOh4jIaY5kJjUqENeMigNgS2YEQWj1ekcDcKDMKzPyjo5kpbq+EccK9ThaWI0jBdWob7Tg6WuGITJIvud19ITskhrxzwdyz+HSgZESRkNE5LxCezITF+KH4fE6aNVKVNSacLq8FskRgRdcX8sGYPIUmzNL8dS3R3Gmou6Cx+obrVi5aDwUCvlu2etuJ0sN4p/351VJFwgRkYsKzjUlM1q1CqMSQrAnpxLpOZWtJjPuspuJy0zUoXd/zRETmYRQP1w+NBqLp6dAq1ZiW1YZPtqdK3GEvSurWWXmYH6VOB2TiEjuCqtsJ2DHhvgBACYkhQJou2+Gy0zkEQRBwNHCagDAl/dMwvh+oeJjoQEaPPndMTz7w3FMTg5HSuSFWb0nyi5tSmZqjGZkl9ZgYHSQhBEREXVMEASxZyaujy2ZGd9BMiM2AMt4+i/Aygx1oFjfgHN1jVApFRgep2vx2IJJ/TA1NRxGsxXP/3RCogh7V43RLH4zGBwTDAA4kHdOypCIiJyirzeLy0axOlsyMyaxD1RKBQqq6sXvbc019cxwNxO5saMFegBAamQgfH1a/mdWKhW4b3oqACCzRN/rsUnBUZWJCNJi+qAIAMB+JjNE5AYcyUpYgAZ+Gtv38wCtGsNibb+YZbRSnXGXZSYmM9Suo4W2JGWIvQpxPkepsri6AVY36B2xWgWcLqsRv0BddbLE1vybGhmI0Ql9ALAJmIjcgyOZcfTLOKTZl5r2tJLMsAG4m/Tr1w8KheKC27333it1aF7B0S8zJLb1ZCYqSAulAmi0CCivNfZmaC7JLjXg3lX7Me7ZjZj+r61Y9H5GJ1/HVplJjQzE6MQQ8b7q+sbuCpWIqEc035bdXFpSGABga2bpBRsaHBOAWZnpooyMDBQVFYm3DRs2AABuuOEGiSPzDseKbJWZobG6Vh9Xq5TinJkie5e8HL2wLhM//FaEylrbxN6M3ErUmywuv06WozITFYSwQC36hvkDsO1qIiKSs7YqM1NTw6Hz80FhdQO2ZZW1eKxWnADMZKZLIiIiEB0dLd6+//57JCcn45JLLpE6NI9XXdeIs/aZBG1VZgAgJsSezFRf2DwmB2aLFbtPVQAAXr9pNEIDNBCElruSnHWyWWUGsDXPAcC+M22PAycikoPzdzI5+Pqo8Lux8QCAT/a0HLVRwwbg7mcymfDxxx/jjjvuaHNIm9FohF6vb3GjzjlaZFtiiu/j1+aJqkBTV3yhTCszRwv1MBjNCPZVY+7wGAyMsm2jziwxdPDMlupMZjG5S7W/hmOr+u52zjYhIpKDpoF5F05tv3mC7ZymX06UttjVxAbgHvD111+jqqoKt99+e5vXLFu2DDqdTrwlJCT0XoAe5lihY4mp7aoMAMTo5F2Z2WmvykzoHwaVUiHOhMksdi3RdVRywgM1CA3QAAAmJdvWmg/mVaGh0fVlKyKi3tLUM+N/wWPJEYGY1D8MVgH4PD0PgG3DRJ2Jy0zd7t1338WcOXMQGxvb5jVLly5FdXW1eMvPz+/FCD1LUzLTer+MQ4x9/bWwWp6VmV2nbcnMZHviMUCszLi2zHTSfn3z4YD9wvwRHewLk8WKfbncok1E8mQ0W1BqsG3SiG2lMgMAt9hP0f4sIx+NFqvY/At4aGVm5cqV+OGHH8SPH3nkEYSEhGDy5MnIze2Z0fa5ubnYuHEj7rrrrnav02q1CA4ObnHrkXgqavHF3nzs9eBeiaNOVmZiHZWZVgYuSc1ktoqzExxVFEdlJqvYtWUmsfk3smnar0KhEF93l70CREQkN44NGr4+SrGyfL5ZQ6IRFqBBqcGIvWfOic2/KqUCWrW8ax+diu65556Dn5/tt/Fdu3Zh+fLlePHFFxEeHo4HH3ywWwN0eP/99xEZGYl58+b1yOu76rOMfDyy+jes2X9W6lB6REOjBdlltkpEe82/QLPKjAx7Zg6drUJ9owVhARoMsCchA6JslZVifQOq65zfUn3Cnvycf3TBpP72ZOY0kxkikqfCZjuZ2uo51aiV4mTzwqr6puZfjUr2hwl3KpnJz89HSkoKAFsfy/XXX4+7774by5Ytw6+//tqtAQKA1WrF+++/j4ULF0Ktlkepa4R9tP9vZ6sljqRnnD1XD4tVQJBWjejg1kuSDo7KTKmhAWaLtTfCc5qjWjIxOQxKpe2LMcjXR5yz4EoTcKY9mRl0fjJjr8wcyq/q9DA+IqKedLaNGTPniwzWAgBKDUYxmZH7EhPQyWQmMDAQFRW2HxI///wzZs6cCQDw9fVFfX33LzVs3LgReXl5uOOOO7r9tTtreLwtmcksNoiNn4fPVmPBe+nilNjuYjJbsf5oMepMvfeDstje/xKt8+0wIw8P1MJHpYBVAEoM8hqct/NUOYCm6omD2ATs5HtVXdeIYr3t32TAeclMfB8/xIX4wWwVsJd9M0QkQ20NzDufY25Yib6haSeTr4cmMzNnzsRdd92Fu+66C1lZWZg7dy4A4OjRo+jXr193xgcAmDVrFgRBwIABA7r9tTsrLsQPoQEamK2CuPywfHM2tmWV4fVfsrv1cz3x7RH88aN9+M/Gk936uu1x/OCO1rVflQFsZzRFBXdP38yvJ8tw7yf7xSrI+Qqr6mEyO1f9aWi0YH9uFYCm5l8HsQnYyR1NJ+zXxYX4Idi35TZ1hUKBif3ZN0NE8lXYxsC880XZKzNlzSozct/JBHQymVm+fDkmTZqEsrIyrFmzBmFhtm/k+/btw0033dStAcqVQtF0ivThs1WwWgWxZ2LziVKnf+B25FB+FT7LsO3I+uVEabe8pjOK7dusO1pichBnzXRhR1O9yYIHPz+IHw4X4Xf/3dniSPqCqnrc/eFeTH7+Fzz61W9Ovd6JYgNMFivCAjRICg9o8djAaFvfTFaxczuaHBWc85eYHBxLTVsyS7lFm4hkp8xeNY8M0rZ7naMyU2pocJsZMwDQqQhDQkLwxhtvXHD/U0891eWA3MnIeB22ZpXht7PVGJ2oF8/nMRjN2JNTgampEfhkTy7e+CUbHyxKu6BxtCNWq4DHvz0KwX5UxsnSGpToG8QqSE9ypTIDNJsC3IXKzCd7clFeYztuwNBgxq3v7sG84TEwNJixI7sc9fYk4duDhfjb3MEID2z/i9KxtXxIbPAFS2UDo2xNbieK9RAEocOltONFrTf/OkxNDYdGrcSJYgOufXMn3rh5NJIjAlu9loiotzm+t3b0fdPRM1OiN4rJTIBG/slMpyoz69atw/bt28WPly9fjlGjRuHmm2/GuXPe0zMwPD4EAHC4oPqC5YUNx0pQXd+I5388gaLqBvxwuMjl11+9/ywO5VchQKNCf3tlYUd2uUuvsWbfWfz5k30wNLh2EGLznhlnxNgrM0WdrMw0NFrw1rbTAIAnrxyCGYOjYDJbsfZAATYeL0F9owVp/UIxICoQZquAbw4Wdviax4raPiSzf0QAVEoF9A1mvLrxJO75aB++OVjQ5ms5lqPaSmaign3x9oJxCAvQ4HiRHle+vh3Zpd3bO0VE1FnlNbbKTEQHlZmoZpWZGjc5lwnoZDLz8MMPi8cEHD58GA899BDmzp2LnJwcLFmypFsDlLMR9ibgrBIDNp0oAdDUm7HhWAlW7jwDgz2zdfUHm9lixUvrMwEAD8wYgNnDogEA211MZl7dlIUfDxdj9T7XtpCLlRlnl5nslZnCTlZmPtmThzKDEXEhfrh5Ql/899YxeOl3I/B/lw/Cc9cOx0d3puHzP07EbRP7ArAlaR0RKzMxFyYzvj4q9LMfEvmfTSex7mgxHv7yt1bPaxIEAVn2gXmDW3kth0sGRODH+6dieJwOdSYLvjvkegLb2ud+4psjmPufXzH739tw9fId+P63QgiC0PGTiYhg+z7iSGbCO1pmsldmGhqtYrtBoMzPZQI6mczk5ORgyJAhAIA1a9bgiiuuwHPPPYfly5fjp59+6tYA5Swq2BeRQVpYBWD3aVt/x19nD4S/RoWi6ga8sbmpETjLxWmzO09VoMxgRGiABgsn98OUlHDb/dkVTv8ga2i0iGcJ/ehiZag3KzN1JjP+u/UUAODeS1OgUSuhVilxw7gE/GlaMm6ekIipqRFQKBS4cmQsNColjhXpxWSlNZZmjdltDf27cXwiwgM1mDYwAiPjdTBZrPjbV4dhtbb89z17zjZvwUeluKD35nxRwb7igW2HC7q+bT+nvBYrd+XiWJEemSUGHMqvwl9WHcAfPtwnvkdERO2prm9Eo8X2fS08sPWBeQ6+PioE23cvnS6vBeDBlRmNRoO6ujoAtm3Ts2bNAgCEhoZ63cGOjuoMAPTx98Go+BBcMiACgG1LteM/zpnyWpeagr87ZFtGmTs8Ghq1EmP79oFGrUSxvgGnymqdeo3cijqx3ybjzDmnf/iZzFZxfdXZykxXzmd6cV2mWJVxJAJtCfHXYMaQSABod2BhbkUt6kwW+PookRTeeu/KHy7uj73/mIkPFqVh+S1j4K9RIf1MJd7ZfhrfHCzAE98cwf68c+LOquSIQPioOv6ScWzb/+1sdZcrKI5enQFRgVh11wQsviwVPioFNh4vwV0fZnTptYnIOziqMsG+amjVHVdZIu3f90+XeXgyM2XKFCxZsgRPP/000tPTxam8WVlZiI9v/4eRpxkeFyL+eZJ9MNvMIVHifX+dNRBBWjXMVgFnKpxLQoxmC9YdLQYAXDnCdg6Vr48K4/v1AeB838zpspbVoJ+OOFedKbEvMWlUbY+9Pp9ju195jQlGs/O7efacrsAHO88AAJ67bjg0TozMvn6M7f/Y1wcK0HjekD5H8nCsyJZUD4oOhkrZ8eTK+D7++OusgbY4fjyB+z87iJW7crHg3XR8a08s29rJdL4hMbbPWV5j7HQPkcNx+99jTGIfTE4Jx5KZA/DdfVOgVABHCvSdXtYjIu/hOJOpoyUmB8f27EJxmclDk5k33ngDarUaq1evxooVKxAXFwcA+Omnn3D55Zd3a4By17wyMynZthR02aAohAdqMTAqCNeNiUeKfXz+SSeXmrZmlsHQYEZUsBbj+4WK919kX2pytm/GUSJ0JAg//OZaMhOl0zo9wrqPv494doezFaA6kxmPrLFts75xfIJY0erIJQMiEBqgQUWtCYfyqwDYkpjfv7ULM/+9DTVGc4udTM5aOLkf0pJs/94Do4IwKDoINUazmMwMjHbutXx9VOIcm65OiHbMt2meSA2KDsYw+1iAPTmca0NE7XNU2iM62Mnk4Nie7Sgsu0NlplMRJiYm4vvvv7/g/n//+99dDsjdDG+ezNgHp+n8fbDtkWlQKhTQqJVIjQzEgbwqnCw1AIjp8DW/sycdV4yIFUfwA8BFyeEAMrHrVAVKDQ3if7i2nLJXZuaPi8fHu/OwN9e21NRRH4yjmuDsEhNgm7uTGOqPk6U1OJhfhb5hLXtL9uWew79+zsSwOB3mDY9BbmUd3vjlJHIr6hCj88Xf5g12+nOpVUqMSgjBLydKcaxIj3H9QlFQVY899rk0H+/OFQ/JbK35ty0qpQIf3zkBNUYzQgM0qKoz4foVO8VlvUExzm+tHxmvw/EiPQ4XVOFye/N2ZziWmc5vPJ6QFIrfzlZjz+lKXDvau6qhROSachcrM44mYAePbQAGAIvFgjVr1uCZZ57BM888g7Vr18Ji8b5hYeGBWvx97mD8ddYAJEc0/QD316jh62P7D+A4ZdmZykydyYyNx2w7o64aGdvisWFxOgyMslULFn96oMNzkBzrnZOTwzGur22JyplG4BJxxkz7kyLPN8f+Q/tz+5A/hxPFeix6Px07T1Xgf9tO4+rlO7D40wPIKqlBkFaNV+aPumCqbkccSYqjAnOkoKlX651fT+NIQdvbstujUTctrYX4a/DBojREBGnhr1FhpH0rvjOa9810VnVdIwrsy0iDLkhmbInznhzPPbWdiLpHmWNbtouVGQd3qMx0KpnJzs7G4MGDsWDBAnz11Vf46quvcOutt2Lo0KE4depUd8coe3+4uD/+Mj21zSWZVMcykxPbs9/fcQb1jRYkhvq3WMICbJWD5beMQYBGhd2nK/GvDVltvo4gCGLPTP+IAMwdbqsIrbf34rSnqTLj3H98h/njE6BQ2HZi5dr7g86eq8PC99KhbzBjVEII5o2Iga+PEjo/Hzw4YwC2PzpdnJ7rCkeS4uiNOdJs51B5jQkVtSYoFM73ubQlIdQfG5dcgk0PXeJ0/xAAjLD3Uh0ucK0JuPm1x5sdoaDza5nsjU8KhUJh2+1UqueuJiJqm6My09GMGYeo8773e2wys3jxYiQnJyM/Px/79+/H/v37kZeXh6SkJCxevLi7Y3R7qfb+iZzy2gsaVptbtSdPnC1z19SkVpOjlMhAPH/9CADAii2nMOG5jZj5ylas2NIyiayoNUHfYIZCAfQLC8C0gbZ+lAN5Vag3tV9BK+5kZSa+jz+mpto+z+cZ+aisNWHBe+ko0RsxICoQKxelYfnNY3D4ydnY/9hM3D8j9YIf0s5ybLc+UWxAo8UqboNungAmhQfAvxsmV+r8fMSt584aEB0IjUqJqrpGcXt8R0xmK659cyemv7wFNUaz2Pzb2mwbnZ8PBtt7eFidIaL2iDNmOtiW7XB+ZcZjG4C3bt2KF198EaGhTc2pYWFheP7557F169ZuC85TxOp8EaBRodEiiBWL8313qBB///owAOCPl/QXh8O15sqRsbjnkmQAtpHTJ0tr8MK6E/j+t6apuI4lprgQP/j6qJAUHoDoYF+YLFbs6+Bk5+JO9Mw43DQ+AQDw5b6zWPRBBk6X1SIuxA8f3jEBOn9b4uKjUjq1w6g9CX38EahVw2S24lRZjViZ+ce8IeI2cVf6ZbqbVq0Se2ycXWp6f0cODuZX4XR5Lb7af7ZZMtN6dWlCf9vXH5uAiag9zh5l4HD++U0eW5nRarUwGC5cMqmpqYFG43wp3lsoFAqkRDX1zeRX1uHHw0XikoIgCHjmh2MQBOC2iX3x6OWDOtxF9OicQdi99DJ8f98ULLqoHwDg72uPiIlI0xJToBjD5BTbcs6OU+3vhnJ1YF5zlw2OQnigBmUGIw7lVyHE3wcr70jr1Gu1R6lUiD/kfzlRiopaE1RKBUbE67B07mD4a1S48ryeo97mOIj0t4KqDq8t0TfgtU1Np6J/sPOMuITW1tRhsW/mNCszRNS2MheXmS5oAPbUs5muuOIK3H333dizZw8EQYAgCNi9ezfuueceXHXVVd0do0dIjbQlFV8dKMAVr2/Hnz/Zjw32Rt/T5bUo0RuhVSvx93mDnd4OHa3zxbA4Hf42dzCGx+lQXd+Ih1cfsvXL2Ldl9282sXayfev4zlNt/yZvtQrNGoBdT0A0aqU4B8bPR4X3bx+PlMieOXDRUXn5cq9teF5qZCB8fVS4amQsjj41G7OHdn4XUXdwLHkdyK3q8NoXfjqBWpMFw+N0CNKqcbqsVmxqbiuZcWwjP1lagwp7GZmIqDlBEFBR61hmci6Z8deoEdSsGhPgqbuZXnvtNSQnJ2PSpEnw9fWFr68vJk+ejJSUFLz66qvdHKJncCQzjgMoAWDT8VIAwO7TtuRidGKIuAPKFT4qJf79+5HQqpX49WQ5PtqdK1Zmmu+wcpwbdfhsFfRtHDxZUWuC2SpAoej4qPi2/GlaMm5KS8TKO9IwOrFPp17DGUNjbclCjj1xc8xeAeB0QtiTJvYPg1IBpJ+pxM52ZgMdyDuHrw4UQKEAnrlmGG4YlyA+5q9RoW+of6vPCw3QYKC94vezPTEmImqu+VEGYU72zABN1Rmt/XgZuetUhCEhIfjmm2+QlZWF1atXY/Xq1cjKysLatWsREhLSzSF6BscQNaApwdiaVWaratmXCSb2d31Xj0NKZBAenTMIAPDcj8dxIK8KQNMyE2Cb0psUHgCrYFuaKDU04N8bssTeDKBpiSk8UOvU6P7WhPhrsOy64WLloKecv+16eJyujSul0TcsQOx9+sc3R9o8zuLj3XkAgGtHx2FkQghun9wPjlxsYHRQi1lD53Mc//Cvn7NcPhmdiDyfY4lJ5+fj1FEGDo4mYHdo/gVcGJrX0WnYmzdvFv/8yiuvdD4iDzWxfxguSgnDgKggPDRrIMY+vQHF+gZkldRgj70y4+iB6KyFk/ph0/FSbM8uR0OjreGrf0TL4XWTksOQU16L738rxAvrTiC7tAZvbTuFl343EleOjHX5tGwppUQGQq1UwGw/GHJYnHQNv21ZMmsgfjhcjNNltfjXz5nQqpX46UgxbkxLxJ1TklBvsmCd/ZiJWyYkAgASw/xx2aAobDxe0mET88LJ/bAqPQ855bV445dsLJ3r/PBBIvJ8ZS7uZHJwbM92h+ZfwIVk5sCBA05dJ4fyvhz5aVT45K6J4scT+4dha1YZPth5BqUGIzRqJUYnhnTpcyiVCrx0wwjM/vc26BvM8NeoLkhKLkoOx6o9efjmoG3nk1qpQEOjFfd9egA7T1WIg/i6u2G3J/j6qJASGYgTxQYoFW33lkhJ5+eDv88bhAc/P4S3tp0W739h3QlcMSIGe3IqUWuyICHUD2OaLck9edUQROu0+OPFye2+vkatxONXDMGiDzLw3o4czB+fgOSInulRIiL34+pOJgfHYZMel8w0r7xQ1108IAJbs8rwxV7btNxRCZ3rlzlfjM4PT18zDPd/dhCjEkIuSC4n9m9a+gkP1OKzuyfgi71n8b9tp/Fpep74mDtUZgDbUtOJYgOSIwK7ZaZMT7hmVBzWHijEtqwypCWFQl/fiBPFBry5ORt5lbbT568dFdfivYrv449nrhnu1OtfOigS0wdF4pcTpfjXz5l485axPfL3ICL34+pOJgdHz2SQpyUz1L0uGRCBpwFY7EskXemXOd/Vo+KQHBEonmTdXFigFvNGxOBgXhXeu308UiKD8Le5gzGxfyh+PlqCI4XVKDMYxaMJ5C6tXyi+2l8gzlyRI4VCgXcWjENVnQmRwb7YkV2OW97Zg0/T82Gxb8+/enRclz7Hn6cl45cTpdh7pv0ZQkTkXZoG5rmWzDiWuPuFt74BQW6YzEgkOSIAcSF+4tk7E7u5WXZYO82wy28eA0EQWlQCpg+KwvRBUd0aQ2+YPy4BYYFaWSczgG05yFG2nZwchrSkUKTbJ/eOjNd1eWnIMWW61GBEjdHsNk17RNSzXD3KwGFSchh+XDz1gr5LuZL/fisPpVAocIn9iAGNStmjW5jb+vyeQKlUYOaQKJcPqpSSQqHAgzMGiB9f08WqDGDrzXE0+J0pb33KNBF5n3IXD5l0UCgUGBIb3C3tD72ByYyELrcPdZuUHAY/jXv8h6HuMSk5DNeNjkNqZCCuGdX1ZAawnUUFQByYSEQk7mYK8uzp/KxFS+jiARH44o+T3KaMR93rld+P6tbXSwoPQMaZc8gpYzJDRDblhs7tZnI3TGYk1tOD5ch7JIXb+m5Ol9dIHAkRyYHV2nSUgas9M+6Gy0xEHsKxzJTDZSYiAlDV/CiDACYzROQGHMdk5JTViieyE5H3KrTvlg0P1ECj9uwf9579tyPyIolh/lAoAIPRLE79JCLvVWQ/ay9Gd+HMMU/DZIbIQ2jVKsT3sX3T4lITERVV2yozMW5wPE1XMZkh8iCOJuAcNgETeb3CKltlprVp8J5G9slMQUEBbr31VoSFhcHPzw/Dhw/H3r17pQ6LSJb6c9YMEdl5U2VG1luzz507h4suugiXXnopfvrpJ0RERODkyZPo06d3p+USuQtxcB5nzRB5vSJ7ZSbGCyozsk5mXnjhBSQkJOD9998X70tKSpIwIiJ5cwxgZM8MERXaKzOxXlCZkfUy07fffotx48bhhhtuQGRkJEaPHo2333673ecYjUbo9foWNyJv4ajM5FbU4s0t2Zj20mYs35wtPi4IAnIrasXT2onIM1mtAkr03lOZkXUyc/r0aaxYsQKpqalYv349/vSnP2Hx4sVYuXJlm89ZtmwZdDqdeEtISOjFiImkFavzg0atRKNFwIvrMnGmog4vrc/Eu9tzUGs04y+rDuCSl7bg9V9OSh0qEfWg8hojGi0ClAogysOn/wKAQpDxdC2NRoNx48Zh586d4n2LFy9GRkYGdu3a1epzjEYjjEaj+LFer0dCQgKqq6sRHBzc4zETSe3q5TtwKL8KCaF+mJAUhtX7zgIAEkL9kF9pKzsPjQ3GD4unShkmEfWgg/lVuGb5DkQH+2L33y6TOpxO0ev10Ol0Tv38lnXPTExMDIYMGdLivsGDB2PNmjVtPker1UKr9fwslKgtr904CseL9Jg+KAo+KgV0fj54d3sO8ivrER6oQXmNCceK9KiqMyHE37NP0iXyVkX26b8xIZ7fLwPIfJnpoosuQmZmZov7srKy0LdvX4kiIpK/vmEBuHxYDDRqJRQKBf4+dzD+PC0Z80bE4IfFU5EcEQBBANJzKqUOlYh6SKF9+m+sF0z/BWRemXnwwQcxefJkPPfcc5g/fz7S09Pxv//9D//73/+kDo3IbSiVCjxy+SDx44n9w3CqrBa7T1di1tBoCSMjop7iqMzEsjIjvfHjx2Pt2rX49NNPMWzYMDz99NN49dVXccstt0gdGpHbmtg/DACw+3SFxJEQUU/xpnOZAJlXZgDgiiuuwBVXXCF1GEQeY0L/UADA8WL2zRB5KnHGDCszROSJIoN82TdD5OHE6b9eUplhMkPkhZqWmpjMEHkas8WKUoNjYB4rM0Tkodg3Q+S5SgxGWAXAR6VAeIB3jCphMkPkhZr3zRwv4pEfRJ7EsZMpWucLpVIhcTS9g8kMkReKDPLF3OHREATg8W+OQMaDwInIRYVetpMJYDJD5LX+Pm8I/HxUyDhzDt8cLHTpufmVdag3WXooMiLqCnHGjBeclu3AZIbIS8WF+OEv01MAAM/+eByr953FR7tzcayw/WWnndnluOSlzVj61W+9ESYRuSi7tAYAkBjqL3EkvUf2c2aIqOfcNTUJX+7Nx5mKOvz1y0MAAJ2fD/b87TL4+qhafc7/fj0NqwBsOl4Kq1XwmjV5IndxxP4LydA4ncSR9B5WZoi8mFatwiu/H4WpqeG4eEAEgn3VqK5vxPaT5a1ef6a8FlsyywAABqMZJ+2/ARKRPDQ0WnCyxAAAGM5khoi8xZjEPvjozgn48I40XDcmHgDw05HiVq/9eHdui4/35Z7r8fiIyHmZxQaYrQLCAjSIYc8MEXmjOcNsB09uOFYMk9na4rF6kwVf7M0HAIyMt/3Gx2SGSF4OF1QDsC0xKRTeswTMZIaIROP6hSI8UAt9gxm7zhuo983BAugbzEgM9cf9M1IBAPvzmMwQyckRezIzPC5Y4kh6F5MZIhKplArMHhoFAFh3pKjFY5/bqzK3TkzE2ETb0L2c8lpU1Bh7N0giatORQkcy4z39MgCTGSI6z5xhMQCA9UdLYLbYlprKDEYczK8CAFw9Kg46fx+kRgYCAPbnVUkRJhGdx2i2ILPY1vw7NJbJDBF5sQn9Q9HH3weVtSbxVO0tmaUQBNtve1HBtqbCsX37AGDfDJFcZBXXoNEiIMTfB/F9vGf6L8BkhojO46NS4nJ7dWZVeh4A4JcTpQCA6YMixevG2JOZ/UxmiGSh+RKTNzX/AkxmiKgVt05MBACsO1KM/Mo6/GqfO9M8mXFUZg6drbpg5xMR9T5xJ5OXLTEBTGaIqBVDY3UY368PzFYBD31xCDVGM8IDtS2aCvuHByA0QAOj2YonvzsKi5WHVRJJqWknE5MZIiIAwMLJ/QAA6WdsfTPTB0W0OLpAoVBg6ZxBUCiAVXvycO8n+9HQyMMniaQgCEKz5l/v2pYNMJkhojbMHhqNqGCt+PH0QVEXXHPDuAQsv3kMNCol1h0txv2fHYAgsEJD1Nv09WYY7cu9MSHeM/nXgckMEbXKR6XELRP6AgA0KiWmpIa3et3c4TH4YNF4aFRKrD9agre2ne7NMIkIQKmhAYDtoFituvVDYj0ZkxkiatNtE/tiTGII/nBxEgK16javm5wSjieuGgIAeHHdCezMbv2gSiLqGWUG2/DKyCBtB1d6JiYzRNSmPgEafPXni/Dw7EEdXntzWiKuHxMPqwDc9+kBGBoaeyFCIgKAMvsk7ggmM0REnadQKPDstcOQFB6AiloTVu87K3VIRF6jVM9khoioW/j6qHDHlCQAwMqdZ2Dldm2iXuGozHCZiYioG1w3Og5BvmqcqajD1qwyqcMh8gqOnhlWZoiIukGAVo0bxycAAN7feUbaYIi8hGM3E5MZIqJusmBSPygUwLasMmSX1kgdDpHHa9rN5H0zZgAmM0TUAxJC/TFjsG3I3se7cyWOhsjzcZmJiKgH3JxmO6zyu0OFaLTwIEqinmIyW3GuzjYKISKQyQwRUbeZmhqO8EANKmpN2MZGYKIeU27fyeSjUiDE30fiaKTBZIaIeoRapcRVI+MAAF8dKJA4GiLPJS4xBWqhUCg6uNozyT6ZefLJJ6FQKFrcBg3qeBopEUnvujG2ZGbDsRJU13MiMFFPKPXyfhnADZIZABg6dCiKiorE2/bt26UOiYicMDQ2GKmRgTCZrfjpcJHU4RB5pKbmX+/cyQS4STKjVqsRHR0t3sLDWz+9FwCMRiP0en2LGxFJQ6FQ4Lox8QC6b6nJYhXwy4kS1Jss4n01RjNW7zuLOpO5Wz4HUU/65UQJNhwr6bbX8/adTICbJDMnT55EbGws+vfvj1tuuQV5eXltXrts2TLodDrxlpCQ0IuREtH5rhkdC4UCSM+pRIm+ocuvt2JLNu74YC8eWfObeN8/1h7GX788hIe+OARB4BEKJF9nymtx18q9uPujvcivrOuW1/T2gXmAGyQzEyZMwAcffIB169ZhxYoVyMnJwdSpU2EwGFq9funSpaiurhZv+fn5vRwxETUXo/PD6IQQAMDPXfxttN5kwXs7zgAAvv+tEJnFBpwqq8G3hwoBAD8dKcZ3v3E5i+Tr3e05sAqAIAA/dtPSa9PAPCYzsjVnzhzccMMNGDFiBGbPno0ff/wRVVVV+OKLL1q9XqvVIjg4uMWNiKQ1a2g0AODno8Vdep01+8+istYEwPbD4LVNJ7H8l2xYBSDYVw0AePybI+JvqkRSM5mt4vLnuVoTvtzX9At2tyUzNVxmkn0yc76QkBAMGDAA2dnZUodCRE6abU9mdp2qQHVd53Y1WawC3vn1NADgJvtAvh8OF+Hrg7ZenPcXpWFobDCq6hrx2NdHuiFqoq7RNzTiqje2Y+zTG/HDb0X4ZE8uGhqt6B8eAKUCOHS2uluWmkr1TGbcLpmpqanBqVOnEBMTI3UoROSkpPAApEYGwmwVsDmztFOvseFYCc5U1EHn54N/zBuMecNt3wOsAnDpwAiM7dsHL98wEgCw/miJWMEhkoIgCHj4y0M4UWxAfaMF967aj+WbTwEAFl+Wion9wwDYEvKufh5HZYbLTDL217/+FVu3bsWZM2ewc+dOXHvttVCpVLjpppukDo2IXOCozqzvxFJTQ6MFr/9yEgBw68REBGjVWHxZKhzzwe6fMQAAMDjGthUcsDUcE0nlrW2nsf5oCTQqJa4ZFQsAqG+0IEbni3kjYjDXnoz/0MUeL32DGSaz7biQcC89ygBwg2Tm7NmzuOmmmzBw4EDMnz8fYWFh2L17NyIiIqQOjYhc4EhmtmSWoaHR0sHVTSxWAYs/PYCjhXoE+aqxcHI/AMDA6CC8efMY/OfGURhlbzAGgAn9QwEAu09XdFvsRK44VqjHi+tOAAAev3IIXr1xNJ6/bjiSwgPw+BVD4KNS4vJh0VAqgMMF1cir6PxSU5m9PyzYVw1fH1W3xO+O1FIH0JHPPvtM6hCIqBsMiwtGrM4XhdUN+PVkOWYOierwOYIg4B9fH8HPx0qgUSvx9oJxiGw2GGzO8AuXmyckheHj3XnYw8oMSWTX6QpYBWBKSjhumWDr77oxLRE32nu9AFsVZVJyGHZkV+DHI0W455Jklz7Hl3vzsSWzDIlh/gCAyGDvHZgHuEFlhog8g0KhEHc1bXRyi/aWzDJ8mp4HhQJ47cZRYp9BexyVmRPFelTVsW+Gel9hVT0AYEhscLtnJc0aYvt6cPUgVkEQ8OyPx/HD4SKs2GLrw/HW07IdmMwQUa+5bHAkAOCXzFJYrR0Pt0s/Y6uu/G5MPC4f5lzTf2SQL/pHBEAQ2DdD0iiqtiUzsbr2qyVTU23T7PeeOefS9OoSvRFVdY1QKoDwQA0AIDkyoJPRegYmM0TUa9KSQhGgUaHMYMThguoOrz9WaDuOZGSznhhnOCo4XGoiKRRU2fpYYkL82r0uKTwAcSF+MFmsLv1fPVFs+7roHxGIHY9Ox2d3T8Q/5g3pfMAegMkMEfUarVqFiwfYmvc3He94qelYke2b9tBY14ZfTkiyLTXtyWETMPU+xzJTXAfJjEKhEKszv2aVO/36mcW2CfgDo4OgVaswsX+YVzf/AkxmiKiXXTbY1vi78Xj782ZKDQ0oMxihVACDol1LZhyVmaOFelTXd25IH1FnGM0W8XiB2A6SGQCYmmpL7rdnO98340hmBkUFdSJCz8Rkhoh61aUDI6BQ2Koujt6C1hwvsn3DTgoPgJ/Gtd86o4J9kRRu65sZ/8xG9F/6A+79ZL9TfTpEXVFcbVti8vVRoo+/T4fXX5QSBoUCyCqpEZ/bkRPNKjNkw2SGiHpVWKBWPHhyUzvVmaOFtp6aIbG6Tn0ex4Rgk8UKq2CbtLpi66lOvRaRswrsS0yxIX7t7mRyCPHXYER8CADg15MdV2fMFiuyy2oAuF6x9GRMZoio1zmWmtrrm3E0/w6J6dw37IdmDcCvj1yKXx+5FE9fPRQA8K+fM7nDiXpUkb35t6N+meamptj7Zk523DdzpqIWJrMV/hoV4vs4/zk8HZMZIup1s+wD87ZmlSG7tKbVaxzNv0NcbP51UCgUSAj1R0KoP26d2BfXjY6DVQDu+3Q/zvHcJuohjubfmA62ZTfnaALeeLwEu06137TuWGIaEBUEpbLjyo+3YDJDRL0uNSoIM4dEwSoAL60/Id5vMlshCALqTGbklNcC6HxlpjmFQoGnrxmG/uEBKNEbsXrf2S6/JlFrCqublpmcNbZvH6T1C0WdyYIF7+3BmvP+fxoaGsXt2GLzL/tlWmAyQ0SSeGT2QCgVthOu9+Wewxd78zHqnz9j0QcZOHy2GoJgOwU4optOAg7QqrFoShIA4NtDhRc8fii/Chc9/ws+S8/rls9H3skxY8aVZEatUuLDO9Mwb3gMGi0CHvryEH6yn6YtCALuXLkXl7/6K1bvO8vm3zYwmSEiSaRGBeGGsQkAgLtWZuCR1b+hzmTBlswy3P/ZQQCdX2Jqy9xh0VApFThcUI3TZU3LW4Ig4NkfjqOgqh6f7GEyQ53n7IyZ8/n6qPD6TaNx28S+AIBnfzwOo9mCn4+ViH1ej39zBPtyzwFgMnM+JjNEJJkHZqZCq1biXF0jFArghrHxUCkVKNbbfrvtjiWm5sICtZhib7ZsXp3ZdbpCPDrheJEe9SbnT/UmchAEQUxmXKnMOCiVCiydOwhRwVqcPVeP97afwUvrMwEA/hoV6kwWVNr7vbiTqSUmM0QkmRidH564ciiGxATj3YXj8NINI/HMNcPExwd3czIDAFeNjAVgS2YEwTZ35tWNJ8XHzVbBqaMWiM6nrzejzp4Iu9IA3Jy/Ro2HZg0EALy4/gSyS2vQx98Ha/98EYJ91QCAiCAtQgM03RO0h2AyQ0SSunlCIn68fyqmD7LtcLopLRFPXjkEs4ZEiQdTdqdZQ6OgVStxuqwWRwv12HWqAuk5ldColBidGAIAOJB3rts/L3k+x4yZsABNl44XuH5MPAZFB8Gea+PeS1MwMDoIL1w/AiqlQtzKTU3UUgdARHS+2y9Kwu0XJfXIawf5+uCywZH48XAxFr6XDkOD7bTi349PQHwfPxzIq8J+JjPUCV1ZYmpOpVTg7/MG47Z305EQ6odb7X00c4bHYGffPujjz6rM+ZjMEJHXuX5MPH48XIwKe/9BRJAWf740GfmVth9G+/OqIAiCUxNciRyatmV3bompuampEfj63osQHezbosoTFdz11/ZETGaIyOtcNjgKH96RBqsgoH94IGJDfKFWKRHip4FaqUCZwYjC6gaXd6SQdyvopsqMwyj7sR/UMSYzROSVLh4QccF9fhoVBscE43BBNfbnnmMyQy7pzFEG1D3YAExE1MwYsQm4StI4yP00HWXAZKa3MZkhImpmdGIfAGATMLns7Dn7wDweANnrmMwQETXj2J59tLAaDY0cnkfOaWi0iMMe+4b6SxyN92EyQ0TUTGKoP6KCtWi0CNh5qlzqcMhNOKoygVo1Qvx9JI7G+zCZISJqRqFQYM6wGADA94eKJI6G3EV+ZR0AICHUn1v6JcBkhojoPFeMsCUzPx8r4VITOSXPnswkhrJfRgpMZoiIzjMmsQ9idL6oMZqxJbNM6nDIDTQlM+yXkQKTGSKi8yiVCswbbl9q+q2wg6uJmMxIjckMEVErrrCfrr3peCnqTGaJoyG5a94zQ72PyQwRUStGxuuQEOqH+kYLPt6dC6tVkDokkilBEFiZkRiTGSKiVigUClw7Oh4A8NyPJzD71W3YcKxE4qhIjipqTagzWaBQcGCeVJjMEBG14S+XpuC+6SkI8lXjZGkN/vjRXuzLrZQ6LJIZR1UmJtgXWrWqg6upJ7hVMvP8889DoVDggQcekDoUIvICGrUSD80aiB2PTsfc4dGwCsCDnx9CrbH9HhpBELBy5xn8ZdV+1HRwLbk/9stIz22SmYyMDLz11lsYMWKE1KEQkZcJ9vXB89ePQFyIH/Iq6/DMD8favNZqFfDMD8fxxLdH8f1vRfj6QEEvRkpSyKtgv4zU3CKZqampwS233IK3334bffr0kTocIvJCwb4+eOkG2y9Tn6bn4+a3d+OVnzOxL/ccBMHWHFxeY8SSLw7i3e054vPWHSmWJF7qPWz+lZ5bJDP33nsv5s2bhxkzZnR4rdFohF6vb3EjIuoOk5PD8ZdLUwAAO09V4LVfsnH9ip2Y8cpW3PfpAUx+/hd8fbAQKqUCS2YOAADsOl2Bc7UmKcOmHiYmM2FMZqSiljqAjnz22WfYv38/MjIynLp+2bJleOqpp3o4KiLyVn+dPRBXjYpFek4l0nMqseFYCU6V1eJUWS0AYGRCCB6ZPRAXpYTjpyPFOF6kx4ZjJZg/PkHiyKmnsGdGerJOZvLz83H//fdjw4YN8PX1deo5S5cuxZIlS8SP9Xo9EhL4TYSIus+AqCAMiArCrRP7wtDQiO9/K8Kp0hrMGR6NMYl9xIMG5wyLxvEiPX46UsRkxkMZzRYU6RsAcJlJSrJOZvbt24fS0lKMGTNGvM9isWDbtm144403YDQaoVK13Aan1Wqh1Wp7O1Qi8lJBvj64KS2x1cfmDIvGKxuysD27HPqGRgT7+vRydNTTCs7VQxAAf40KYQEaqcPxWrJOZi677DIcPny4xX2LFi3CoEGD8H//938XJDJERHKSGhWE5IgAnCqrxS/HS3HN6DgAwJ7TFbjn430YEBWEa0fHYe6IGCY6burQ2SoAtqqMoyJHvU/WDcBBQUEYNmxYi1tAQADCwsIwbNgwqcMjIurQnGG2Ayu/Pti0RfvfG7Nwrq4Re3Iq8ehXhzHrlW0wmi1ShUhdsGpPHgDg8mHREkfi3WSdzBARubvrxsRBqQC2ZJbhSEE1jhfpsft0JVRKBe6/LBV+PioU6xuQXVojdajkouNFemScOQe1UtHmUiP1DlkvM7Vmy5YtUodAROS0/hGBuHJkLL45WIj/bDqJ8EBbX8XlQ6Px4MwB2HmqHBlnziG7tAZDY3USR0uu+Gh3LgBg9tBoRAU7t0mFegYrM0REPey+6SlQKIANx0qwZp9tuWnh5H4AgJTIQABgZcbN6BsaxenOt07sK3E0xGSGiKiHpUQG4YoRsQAAk8WKITHBGN/PNs08OYLJjDtau78AdSYLUiMDMbF/qNTheD0mM0REvWCxvToDALdP7ifufGFlxj39dKQIAHDzhETuYpIBt+uZISJyR6lRQfjbnMHIKjHg6tGxLe4HgJzyWjRarPBR8XdMd5BVYks+x/djVUYOmMwQEfWSP1zc/4L7YnW+8NeoUGeyILeiTqzUkHyV1xhRWWuCQtG0TEjS4q8AREQSUigU7JtxM1klBgBAQh9/+Gk4vFUOmMwQEUksVeybMUgcCTnDkXQOiGJVRi6YzBARSSyZTcBuxVGZSYkMkjgScmAyQ0QkMXFHUxmTGXfgaP5lZUY+mMwQEUms+fZsq1WQOBrqSNMyEyszcsFkhohIYn1D/eGjUqCh0YqCqnqpw6F2cCeTPHFrNhGRxNQqJZLCA5BVUoPsshokhPoDAA7kncNX+wvw4MwBCA3QXPC8LZmlyKusg6HBDI1KiQn9QzEwOgjrjhTj/R1n4KNSYOUdafDX8Ft9dzlpX2LiTiZ54f9wIiIZSIkMRFZJDTafKMW0ARE4kF+FW9/ZgzqTBb4+Svx93pAW1286XoI7V+694HXUSgXMzZaqvj9UhPnjE3o8fm9x0r7jLJXzgGSFy0xERDJwyYAIAMCHu3Kx6IMM3P5eOupMFgDA2gOFMFusLa7/cJftxObhcTrcMDYeMwZHIUirhtkqIDxQi6mp4QCAVel5vfi38HyOnUyp7JeRFVZmiIhkYP64BBjNVjzz/XFsySwDAIzt2wdnymtRXmPEryfLcemgSABAfmUdtp20XfP6TaPRLzwAAGC2WJFbWYe4ED/UGM2YtGwTDuZX4XiRHoNjgqX5i3mYk9zJJEuszBARyYBCocCCSf2w+k+TMCg6CJOTw/D+ovG4cqTtHKfV+8+K136WkQdBAKakhIuJDGDrvUmOCISvjwrhgVrMHBJlu57VmW5z0r6TKZUzZmSFyQwRkYyMiA/Bugcuxqo/TESwrw9+NzYeALDhWAmq6xrRaLHii722xObmCYntvtZNabbHvzpQgHr7khV1XvOdTDxDS16YzBARydjQ2GAMjAqCyWzFqvQ8fJqehzKDsUXlpS0XJYcjIdQPhgYzvjlY0EsRe669ZyoBAEnhAdzJJDNMZoiIZEyhUOC6MXEAgBfWncDj3xwFAMwfFw8fVfvfwpVKBW5O6wsA+Of3x3CkoLpng5WRWqMZlm4eQOjoZXI0a5N8MJkhIpK568fGI1bnCx+VAtHBvpjYPxSLLkpy6rl3TknC5OQw1JksuOODDBR6wVC+/Mo6jH92I656YztKDQ3d8pqCIIjJzLSBkd3ymtR9uJuJiEjmwgO12PHodAC2So0rNGolVtw6Fjf8dyeySmqw6P0MfP7HiQjxv3AIn6dYe6AAdSYLjhbq8bsVu/DRnWnoGxbQ8RPbcaLYgGJ9A3x9lJiQFNpNkVJ3YWWGiMgNKBQKlxMZB52fD95flIbIIC0ySwxY+F46DA2N3RyhfPzwWxEAwNdHibzKOlyzfAf+vvYw1h0pRuN583qc5ajKTOofBl8f9svIDZMZIiIvEBfih4/vmoA+/j44dLYad3yQgTqTWeqwul12aQ0ySwzwUSnw/X1TMDgmGOfqGvHJnjzc8/E+3LfqQKded0tmKQAuMckVkxkiIi8xICoIH905AUG+amScOYfXNmVLHVK3+/GwrSpzUUo4UiKD8PW9k/HOgnFYOKkv1EoF1h0tRoZ9V5Kz9A2N2Jd7DgBwKZMZWWIyQ0TkRYbF6fDyDSMBAB/vzkV1vWctNzmWmOYNjwEAaNUqzBgShaeuHoYbxtnOqHppfSYEwfmdTjtOlsNsFdA/PACJYf7dHzR1GZMZIiIvM3NwFAZEBaLGaMbHu3OlDqfbNF9imjUk+oLHF1+WAo1aifScSmzJKsN723Mw45WteH9HTpuvmVNei5d/zgQAXDKQW7LliskMEZGXUSoV+NO0ZADA+zty0NDo/tOB60xm/HfrKQC2JSadv88F18To/HCLfWrynR9k4J/fH0N2aQ2e+u4Y3rI/t7nNmaW46o3tOFVWi6hgLRZNdm47PPU+JjNERF7oihGxiAvxQ3mNCV/uO9vxE2Tsy735uPjFLVht/3s4joBozZ+npcDPRwWrAPTx98FV9rOvlv10Aq9vOgmT2QpBEPDmlmzc8UEGDA1mjO3bB9/9ZQqXmGRMIbiycOiG9Ho9dDodqqurERzMU2OJiBxW7jyDJ749ilidL9Y9eDGCfS+sZsjdgbxzuPbNnQCAxFB/LJk5ANeMjmv3OdtPluNwQTVuTkuEzt8Hr27MwqsbTwIAIoO0SIkMxM5TFQBs51s9ddVQaNT83b+3ufLzm0PziIi81PxxCXj719M4e64ej319BP+5cbTUIbnsne22fpe5w6PxnxtHd3jEAwBMSQ3HlNRw8eMHZgxAWIAGr/+SjVKDEaUGI3xUCjx51VDcMqFvj8VO3YfJDBGRl/LTqPCfG0dj/lu78M3BQlwyIAL9wgOwNbMMMTpfXDEyFoFa+f6YyK+sw0/2rdj3TU91KpFpy22T+uH34xPx4+EibMksxW2T+mJsX076dReyX2ZasWIFVqxYgTNnzgAAhg4discffxxz5sxx6vlcZiIiat9rm07ilQ1ZF9wfoFHhhnEJWDp3ELRq29TbEn0DymuMGBqr6+0wL/DM98fwzvYcTEkJx8d3TZA6HOpmrvz8lv0iYHx8PJ5//nns27cPe/fuxfTp03H11Vfj6NGjUodGROQR7r00BWn284YCNCrMHR6NpPAA1Jos+GDnGbzzq20pp9ZoxrXLd+DK17fjQN45KUOGoaERn2XkAwDunMpdRt5O9pWZ1oSGhuKll17CnXfe2eG1rMwQEXWs3mTB4YJqjIjXwddHBUEQ8NHuXDz+zVEEadXY+sileOfX03hzi20L8yUDIrDyjjRJYj1Xa8IT3x7Ft4cKkRIZiJ8fuBhKZefOrSL58tgGYIvFgi+//BK1tbWYNGlSq9cYjUYYjUbxY71e31vhERG5LT+NSqzOALaDLW+d0BefZ+TjaKEef/vqMH45USo+vjWrDPtyz2Fs3z69GufXBwrw5HdHUVVnm1x8/2WpTGRI/stMAHD48GEEBgZCq9Xinnvuwdq1azFkyJBWr122bBl0Op14S0hI6OVoiYg8g1KpwNI5gwEA644Ww2SxYmpqOG6wz3H5z6aTMDQ04v0dOfg8I6/H48mvrMOSLw6iqq4Rg6KD8PndE3GlfU4MeTe3WGYymUzIy8tDdXU1Vq9ejXfeeQdbt25tNaFprTKTkJDAZSYiok5a8F46tmWVQaVU4Kf7p8JXrcKl/9oCi1VAkFYNg9F2+vaquyZgckp4B6/WeS+vz8Qbm7MxISkUn9w1Aeou7F4i+fO4ZSaNRoOUlBQAwNixY5GRkYH//Oc/eOutty64VqvVQqvV9naIREQe6/ErBuMPH9bhd2PjMSAqCABw/Zg4fLH3LAxGM/w1KtSZLHj550ysSQ6DQuHask+jxYo3N59CxplKDI0Nxti+faBUKFBZZ0J0sC8uHhCBRosVn++1NfwunNyPiQy14BbJzPmsVmuL6gsREfWclMggbP7rtBb3/W3uYIQGaDEqQYdRCX0w7eXN2J9Xhc2ZpZg+KMrp1y7RN+C+VQeQfqYSALA9u/yCa/79+5HwVatQZjAiPFCLmUOcf33yDrJPZpYuXYo5c+YgMTERBoMBq1atwpYtW7B+/XqpQyMi8loh/ho8OmeQ+PHCSf3w1rbTeHl9FjQqFTYcK0b/iEAsnNyvzdc4mF+Fu1buRXmNEYFaNf40LRl5FXU4dLYKWvvxAYfOVuP/1hxGP/u5SPPHxXdpOB55JtknM6WlpViwYAGKioqg0+kwYsQIrF+/HjNnzpQ6NCIisrvnkmR8sicPx4r0uPXdPeL9Y/v2wbA424A9q1WAQmHbKbXxWAn+8ul+NDRaMSg6CG/eMgb9IwJbvKbVKuDuj/Zi4/FSZJXUALCdlUR0PrdoAO4KzpkhIuodK7acwgvrTqCPvw9CAzQ4VVaL2UOj8NZt45BXUYcb3tqJc7WNiNb54uy5OlgF27yaN28Zg4A2jk2oMZpx3Zs7kFVSg6mp4fjoTk769Rau/PxmMkNERN1CEATkVtQhro8fcitqMfPf2yAIwHd/mYJ/fH0Yh85Wt7j+9+MS8My1wzpcNiqsqsc7v+bg1omJF1RvyHMxmWmGyQwRkTT+smo/vv+tCMG+augbzND5+eDDO9JgslihUSkxIl7n8s4n8h4etzWbiIjcz33TU/H9b0XQN9jm0Lx8w0iMTAiRNijySGwJJyKiHjEwOgjzRsQAAG6f3I9bqqnHsDJDREQ95sXrR+D34xIwpQcnAxMxmSEioh4ToFXj4gERUodBHo7LTEREROTWmMwQERGRW2MyQ0RERG6NyQwRERG5NSYzRERE5NaYzBAREZFbYzJDREREbo3JDBEREbk1JjNERETk1pjMEBERkVtjMkNERERujckMERERuTUmM0REROTWPP7UbEEQAAB6vV7iSIiIiMhZjp/bjp/j7fH4ZMZgMAAAEhISJI6EiIiIXGUwGKDT6dq9RiE4k/K4MavVisLCQgQFBSEtLQ0ZGRktHh8/fvwF9+n1eiQkJCA/Px/BwcG9GW6rWotRitdz9XnOXN/RNW097uz9nv5eduU1XXleT76X7T3mbe9nV15P7u8nv9f23PO6+n7K9WtTEAQYDAbExsZCqWy/K8bjKzNKpRLx8fEAAJVKdcE/cmv3OQQHB8viC6y9GHvz9Vx9njPXd3RNW4+7er+nvpddeU1XnteT72V7j3nb+9mV15P7+8nvtT33vK6+n3L+2uyoIuPgVQ3A9957r1P3yU13x9jZ13P1ec5c39E1bT3u6v1y0RPx9cb72ZPvZXuPedv72ZXXk/v7Kff3EpDP+9nb32s94WvT45eZOkOv10On06G6uloWvy1Q5/G99Cx8Pz0L30/PIfV76VWVGWdptVo88cQT0Gq1UodCXcT30rPw/fQsfD89h9TvJSszRERE5NZYmSEiIiK3xmSGiIiI3BqTGSIiInJrTGaIiIjIrTGZISIiIrfGZKYLqqqqMG7cOIwaNQrDhg3D22+/LXVI1AX5+fmYNm0ahgwZghEjRuDLL7+UOiTqgmuvvRZ9+vTB7373O6lDoU74/vvvMXDgQKSmpuKdd96ROhzqop7+euTW7C6wWCwwGo3w9/dHbW0thg0bhr179yIsLEzq0KgTioqKUFJSglGjRqG4uBhjx45FVlYWAgICpA6NOmHLli0wGAxYuXIlVq9eLXU45AKz2YwhQ4Zg8+bN0Ol0GDt2LHbu3MnvrW6sp78eWZnpApVKBX9/fwCA0WiEIAhOHVVO8hQTE4NRo0YBAKKjoxEeHo7Kykppg6JOmzZtGoKCgqQOgzohPT0dQ4cORVxcHAIDAzFnzhz8/PPPUodFXdDTX48encxs27YNV155JWJjY6FQKPD1119fcM3y5cvRr18/+Pr6YsKECUhPT3fpc1RVVWHkyJGIj4/Hww8/jPDw8G6Kns7XG++nw759+2CxWJCQkNDFqKk1vfleUu/r6vtbWFiIuLg48eO4uDgUFBT0RujUCnf4evXoZKa2thYjR47E8uXLW338888/x5IlS/DEE09g//79GDlyJGbPno3S0lLxGkc/zPm3wsJCAEBISAgOHTqEnJwcrFq1CiUlJb3yd/NGvfF+AkBlZSUWLFiA//3vfz3+d/JWvfVekjS64/0l+XCL91PwEgCEtWvXtrgvLS1NuPfee8WPLRaLEBsbKyxbtqxTn+NPf/qT8OWXX3YlTHJST72fDQ0NwtSpU4UPP/ywu0KlDvTk1+bmzZuF66+/vjvCpE7qzPu7Y8cO4ZprrhEfv//++4VPPvmkV+Kl9nXl67Unvx49ujLTHpPJhH379mHGjBnifUqlEjNmzMCuXbuceo2SkhIYDAYAQHV1NbZt24aBAwf2SLzUvu54PwVBwO23347p06fjtttu66lQqQPd8V6SfDnz/qalpeHIkSMoKChATU0NfvrpJ8yePVuqkKkdcvl6VffaZ5KZ8vJyWCwWREVFtbg/KioKJ06ccOo1cnNzcffdd4uNv/fddx+GDx/eE+FSB7rj/dyxYwc+//xzjBgxQlwT/uijj/ie9rLueC8BYMaMGTh06BBqa2sRHx+PL7/8EpMmTerucMlFzry/arUa//rXv3DppZfCarXikUce4U4mmXL267Wnvx69NpnpDmlpaTh48KDUYVA3mTJlCqxWq9RhUDfZuHGj1CFQF1x11VW46qqrpA6DuklPfz167TJTeHg4VCrVBQ27JSUliI6Oligq6iy+n56D76Vn4/vrWeTyfnptMqPRaDB27Fhs2rRJvM9qtWLTpk0sRbshvp+eg++lZ+P761nk8n569DJTTU0NsrOzxY9zcnJw8OBBhIaGIjExEUuWLMHChQsxbtw4pKWl4dVXX0VtbS0WLVokYdTUFr6fnoPvpWfj++tZ3OL97JE9UjKxefNmAcAFt4ULF4rXvP7660JiYqKg0WiEtLQ0Yffu3dIFTO3i++k5+F56Nr6/nsUd3k+ezURERERuzWt7ZoiIiMgzMJkhIiIit8ZkhoiIiNwakxkiIiJya0xmiIiIyK0xmSEiIiK3xmSGiIiI3BqTGSIiInJrTGaIiIjIrTGZISK3Mm3aNDzwwANSh0FEMsJkhoiIiNwakxki8hgmk0nqEIhIAkxmiMht9evXD08//TQWLFiA4OBg3H333VKHREQSYDJDRG7t5ZdfxsiRI3HgwAE89thjUodDRBJQSx0AEVFXTJ8+HQ899JDUYRCRhFiZISK3Nm7cOKlDICKJMZkhIrcWEBAgdQhEJDEmM0REROTWmMwQERGRW2MyQ0RERG5NIQiCIHUQRERERJ3FygwRERG5NSYzRERE5NaYzBAREZFbYzJDREREbo3JDBEREbk1JjNERETk1pjMEBERkVtjMkNERERujckMERERuTUmM0REROTWmMwQERGRW/t/3m0oJUZgw0wAAAAASUVORK5CYII=", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "plt.plot(loss_df['lr'], loss_df['loss_smooth'])\n", "plt.xscale('log')\n", "plt.xlabel('lr')\n", "plt.ylabel('loss')\n", "plt.show()\n" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "Looks like our initial learning rate wasn't aggressive enough! torch.linspace, -3, 0 10** that. instead of what we did here" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "## Generation" ] }, { "cell_type": "markdown", "metadata": {}, "source": [] } ], "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.10.10" }, "orig_nbformat": 4, "vscode": { "interpreter": { "hash": "767d51c1340bd893661ea55ea3124f6de3c7a262a8b4abca0554b478b1e2ff90" } } }, "nbformat": 4, "nbformat_minor": 2 }