From d28f5887780823f5be8e868b331dbb9bdb1b2a33 Mon Sep 17 00:00:00 2001
From: wassname <wassname@users.noreply.github.com>
Date: Sat, 1 Feb 2020 13:08:13 +0800
Subject: [PATCH] fixes to improvements

---
 anp_1d_regression.ipynb | 1138 ++++++++++++++++++++++++++++++++++-----
 1 file changed, 1003 insertions(+), 135 deletions(-)

diff --git a/anp_1d_regression.ipynb b/anp_1d_regression.ipynb
index 8d17289..e00e3c4 100644
--- a/anp_1d_regression.ipynb
+++ b/anp_1d_regression.ipynb
@@ -2,11 +2,11 @@
  "cells": [
   {
    "cell_type": "code",
-   "execution_count": 199,
+   "execution_count": 34,
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2020-02-01T03:19:32.799666Z",
-     "start_time": "2020-02-01T03:19:32.787679Z"
+     "end_time": "2020-02-01T04:44:56.084034Z",
+     "start_time": "2020-02-01T04:44:56.070148Z"
     }
    },
    "outputs": [
@@ -32,11 +32,11 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 200,
+   "execution_count": 35,
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2020-02-01T03:19:32.814367Z",
-     "start_time": "2020-02-01T03:19:32.804007Z"
+     "end_time": "2020-02-01T04:44:56.098951Z",
+     "start_time": "2020-02-01T04:44:56.087571Z"
     }
    },
    "outputs": [],
@@ -75,11 +75,11 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 201,
+   "execution_count": 36,
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2020-02-01T03:19:32.863577Z",
-     "start_time": "2020-02-01T03:19:32.817900Z"
+     "end_time": "2020-02-01T04:44:56.155296Z",
+     "start_time": "2020-02-01T04:44:56.102292Z"
     }
    },
    "outputs": [],
@@ -265,11 +265,11 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 202,
+   "execution_count": 37,
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2020-02-01T03:19:32.895332Z",
-     "start_time": "2020-02-01T03:19:32.868161Z"
+     "end_time": "2020-02-01T04:44:56.184430Z",
+     "start_time": "2020-02-01T04:44:56.160175Z"
     }
    },
    "outputs": [],
@@ -278,12 +278,12 @@
     "class NPBlockRelu2d(nn.Module):\n",
     "    \"\"\"Block for Neural Processes.\"\"\"\n",
     "\n",
-    "    def __init__(self, in_channels, out_channels, dropout=0, norm=False, bias=False):\n",
+    "    def __init__(self, in_channels, out_channels, dropout=0, batchnorm=False, bias=False):\n",
     "        super().__init__()\n",
     "        self.linear = nn.Linear(in_channels, out_channels, bias=bias)\n",
     "        self.act = nn.ReLU()\n",
     "        self.dropout = nn.Dropout2d(dropout)\n",
-    "        self.norm = nn.BatchNorm2d(out_channels) if norm else False\n",
+    "        self.norm = nn.BatchNorm2d(out_channels) if batchnorm else False\n",
     "\n",
     "    def forward(self, x):\n",
     "        # x.shape is (Batch, Sequence, Channels)\n",
@@ -312,16 +312,16 @@
     "        tensor of shape [B,n,d_out] where d_out=output_size\n",
     "    \"\"\"\n",
     "\n",
-    "    def __init__(self, input_size, output_size, num_layers=2, dropout=0, norm=False):\n",
+    "    def __init__(self, input_size, output_size, num_layers=2, dropout=0, batchnorm=False):\n",
     "        super().__init__()\n",
     "        self.input_size = input_size\n",
     "        self.output_size = output_size\n",
     "        self.num_layers = num_layers\n",
     "        \n",
     "        \n",
-    "        self.initial = NPBlockRelu2d(input_size, output_size, dropout=dropout, norm=norm)\n",
+    "        self.initial = NPBlockRelu2d(input_size, output_size, dropout=dropout, batchnorm=batchnorm)\n",
     "        self.encoder = nn.Sequential(* [\n",
-    "            NPBlockRelu2d(output_size, output_size, dropout=dropout, norm=norm) for _ in range(num_layers - 2)\n",
+    "            NPBlockRelu2d(output_size, output_size, dropout=dropout, batchnorm=batchnorm) for _ in range(num_layers - 2)\n",
     "        ])\n",
     "        self.final = nn.Linear(output_size, output_size)\n",
     "\n",
@@ -345,11 +345,11 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 203,
+   "execution_count": 38,
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2020-02-01T03:19:32.954104Z",
-     "start_time": "2020-02-01T03:19:32.902132Z"
+     "end_time": "2020-02-01T04:44:56.244731Z",
+     "start_time": "2020-02-01T04:44:56.190841Z"
     }
    },
    "outputs": [],
@@ -367,13 +367,13 @@
     "\n",
     "\n",
     "class Attention(nn.Module):\n",
-    "    def __init__(self, hidden_dim, attention_type, attention_layers=2, n_heads=8, x_dim=1, rep='mlp', dropout=0):\n",
+    "    def __init__(self, hidden_dim, attention_type, attention_layers=2, n_heads=8, x_dim=1, rep='mlp', dropout=0, batchnorm=False):\n",
     "        super().__init__()\n",
     "        self._rep = rep\n",
     "        \n",
     "        if self._rep == 'mlp':\n",
-    "            self.batch_mlp_k = BatchMLP(x_dim, hidden_dim, attention_layers, dropout=dropout)\n",
-    "            self.batch_mlp_q = BatchMLP(x_dim, hidden_dim, attention_layers, dropout=dropout)\n",
+    "            self.batch_mlp_k = BatchMLP(x_dim, hidden_dim, attention_layers, dropout=dropout, batchnorm=batchnorm)\n",
+    "            self.batch_mlp_q = BatchMLP(x_dim, hidden_dim, attention_layers, dropout=dropout, batchnorm=batchnorm)\n",
     "\n",
     "        if attention_type == \"uniform\":\n",
     "            self._attention_func = self._uniform_attention\n",
@@ -391,10 +391,11 @@
     "            self._W = AttnLinear(n_heads * hidden_dim, hidden_dim)\n",
     "            self._attention_func = self._multihead_attention\n",
     "            self.n_heads = n_heads\n",
-    "        elif attention_type ==\"ptmultihead\":\n",
-    "            self._attention_func = torch.nn.MultiheadAttention(\n",
+    "        elif attention_type == \"ptmultihead\":\n",
+    "            self._W = torch.nn.MultiheadAttention(\n",
     "                hidden_dim, n_heads, bias=False, dropout=dropout\n",
     "            )\n",
+    "            self._attention_func = self._pytorch_multihead_attention\n",
     "        else:\n",
     "            raise NotImplementedError\n",
     "\n",
@@ -446,40 +447,51 @@
     "        q = q.permute(1, 0, 2)\n",
     "        k = k.permute(1, 0, 2)\n",
     "        v = v.permute(1, 0, 2)\n",
-    "        o = self._attention_func(q, k, v)[0]\n",
+    "        o = self._W(q, k, v)[0]\n",
     "        return o.permute(1, 0, 2)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 204,
+   "execution_count": 39,
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2020-02-01T03:19:32.981923Z",
-     "start_time": "2020-02-01T03:19:32.957280Z"
+     "end_time": "2020-02-01T04:44:56.271718Z",
+     "start_time": "2020-02-01T04:44:56.247784Z"
     }
    },
    "outputs": [],
    "source": [
     "class LatentEncoder(nn.Module):\n",
-    "    def __init__(self,\n",
-    "                 input_dim,\n",
-    "                 hidden_dim=32,\n",
-    "                 latent_dim=32,\n",
-    "                 self_attention_type=\"dot\",\n",
-    "                 n_encoder_layers=3,\n",
-    "                 min_std=0.01,\n",
-    "                 use_lvar=False,\n",
-    "                 use_self_attn=False,      \n",
-    "                 attention_layers=2,\n",
-    "                ):\n",
+    "    def __init__(\n",
+    "            self,\n",
+    "            input_dim,\n",
+    "            hidden_dim=32,\n",
+    "            latent_dim=32,\n",
+    "            self_attention_type=\"dot\",\n",
+    "            n_encoder_layers=3,\n",
+    "            min_std=0.01,\n",
+    "            batchnorm=False,\n",
+    "            dropout=0,\n",
+    "            attention_dropout=0,\n",
+    "            use_lvar=False,\n",
+    "            use_self_attn=False,\n",
+    "            attention_layers=2, ):\n",
     "        super().__init__()\n",
     "        self._input_layer = nn.Linear(input_dim, hidden_dim)\n",
     "        self._encoder = nn.ModuleList([\n",
-    "            nn.Linear(hidden_dim, hidden_dim) for _ in range(n_encoder_layers)\n",
+    "            NPBlockRelu2d(\n",
+    "                hidden_dim, hidden_dim, batchnorm=batchnorm, dropout=dropout)\n",
+    "            for _ in range(n_encoder_layers)\n",
     "        ])\n",
     "        if use_self_attn:\n",
-    "            self._self_attention = Attention(hidden_dim, self_attention_type, attention_layers, rep='identity')\n",
+    "            self._self_attention = Attention(\n",
+    "                hidden_dim,\n",
+    "                self_attention_type,\n",
+    "                attention_layers,\n",
+    "                rep='identity',\n",
+    "                dropout=attention_dropout,                \n",
+    "            )\n",
     "        self._penultimate_layer = nn.Linear(hidden_dim, hidden_dim)\n",
     "        self._mean = nn.Linear(hidden_dim, latent_dim)\n",
     "        self._log_var = nn.Linear(hidden_dim, latent_dim)\n",
@@ -512,21 +524,22 @@
     "        # Clip it in the log domain, so it can only approach self.min_std, this helps avoid mode collapase\n",
     "        # 2 ways, a better but untested way using the more stable log domain, and the way from the deepmind repo\n",
     "        if self._use_lvar:\n",
-    "            log_var = log_var + math.log(self._min_std)\n",
+    "            log_var = torch.clamp(F.logsigmoid(log_var), np.log(self._min_std))\n",
     "            sigma = torch.exp(0.5 * log_var)\n",
     "        else:\n",
-    "            sigma = self._min_std + (1 - self._min_std) * torch.sigmoid(log_var * 0.5)\n",
+    "            sigma = self._min_std + (1 - self._min_std) * torch.sigmoid(log_var\n",
+    "                                                                        * 0.5)\n",
     "        dist = torch.distributions.Normal(mean, sigma)\n",
     "        return dist, log_var"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 205,
+   "execution_count": 41,
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2020-02-01T03:19:32.998565Z",
-     "start_time": "2020-02-01T03:19:32.984808Z"
+     "end_time": "2020-02-01T04:44:56.306635Z",
+     "start_time": "2020-02-01T04:44:56.292227Z"
     }
    },
    "outputs": [],
@@ -541,12 +554,17 @@
     "            self_attention_type=\"dot\",\n",
     "            cross_attention_type=\"dot\",\n",
     "            use_self_attn=False,\n",
-    "            attention_layers=2, ):\n",
+    "            attention_layers=2,\n",
+    "            batchnorm=False,\n",
+    "            dropout=0,\n",
+    "            attention_dropout=0,\n",
+    "    ):\n",
     "        super().__init__()\n",
     "        self._use_self_attn = use_self_attn\n",
     "        self._input_layer = nn.Linear(input_dim, hidden_dim)\n",
     "        self._d_encoder = nn.ModuleList([\n",
-    "            nn.Linear(hidden_dim, hidden_dim)\n",
+    "            NPBlockRelu2d(\n",
+    "                hidden_dim, hidden_dim, batchnorm=batchnorm, dropout=attention_dropout)\n",
     "            for _ in range(n_d_encoder_layers)\n",
     "        ])\n",
     "        if use_self_attn:\n",
@@ -554,7 +572,9 @@
     "                hidden_dim,\n",
     "                self_attention_type,\n",
     "                attention_layers,\n",
-    "                rep='identity')\n",
+    "                rep='identity',\n",
+    "                dropout=attention_dropout\n",
+    "            )\n",
     "        self._cross_attention = Attention(\n",
     "            hidden_dim,\n",
     "            cross_attention_type,\n",
@@ -581,11 +601,11 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 206,
+   "execution_count": 42,
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2020-02-01T03:19:33.019374Z",
-     "start_time": "2020-02-01T03:19:33.002371Z"
+     "end_time": "2020-02-01T04:44:56.337107Z",
+     "start_time": "2020-02-01T04:44:56.308937Z"
     }
    },
    "outputs": [],
@@ -599,7 +619,10 @@
     "                 n_decoder_layers=3,\n",
     "                 use_deterministic_path=True,\n",
     "                 min_std=0.01,\n",
-    "                 use_lvar=False):\n",
+    "                 use_lvar=False,\n",
+    "                 batchnorm=False,\n",
+    "                 dropout=0,\n",
+    "                ):\n",
     "        super(Decoder, self).__init__()\n",
     "        self._target_transform = nn.Linear(x_dim, hidden_dim)\n",
     "        if use_deterministic_path:\n",
@@ -607,7 +630,8 @@
     "        else:\n",
     "            hidden_dim_2 = hidden_dim + latent_dim\n",
     "        self._decoder = nn.ModuleList([\n",
-    "            nn.Linear(hidden_dim_2, hidden_dim_2)\n",
+    "            NPBlockRelu2d(\n",
+    "                hidden_dim_2, hidden_dim_2, batchnorm=batchnorm, dropout=dropout)\n",
     "            for _ in range(n_decoder_layers)\n",
     "        ])\n",
     "        self._mean = nn.Linear(hidden_dim_2, y_dim)\n",
@@ -633,9 +657,9 @@
     "        mean = self._mean(representation)\n",
     "        log_sigma = self._std(representation)\n",
     "\n",
-    "        # Bound the variance\n",
+    "        # Bound or clamp the variance\n",
     "        if self._use_lvar:\n",
-    "            log_sigma = log_sigma + math.log(self._min_std)\n",
+    "            log_sigma = torch.clamp(log_sigma, math.log(self._min_std))\n",
     "            sigma = torch.exp(log_sigma)\n",
     "        else:\n",
     "            sigma = self._min_std + (1 - self._min_std) * F.softplus(log_sigma)\n",
@@ -644,6 +668,37 @@
     "        return dist, log_sigma"
    ]
   },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2020-02-01T04:18:32.397629Z",
+     "start_time": "2020-02-01T04:18:32.390652Z"
+    }
+   },
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2020-02-01T04:08:07.311127Z",
+     "start_time": "2020-02-01T04:08:07.302500Z"
+    }
+   },
+   "outputs": [],
+   "source": []
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -653,11 +708,11 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 207,
+   "execution_count": 43,
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2020-02-01T03:19:33.033796Z",
-     "start_time": "2020-02-01T03:19:33.021744Z"
+     "end_time": "2020-02-01T04:44:56.352616Z",
+     "start_time": "2020-02-01T04:44:56.340428Z"
     }
    },
    "outputs": [],
@@ -688,11 +743,11 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 208,
+   "execution_count": 44,
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2020-02-01T03:19:33.064975Z",
-     "start_time": "2020-02-01T03:19:33.036431Z"
+     "end_time": "2020-02-01T04:44:56.401418Z",
+     "start_time": "2020-02-01T04:44:56.356207Z"
     }
    },
    "outputs": [],
@@ -711,6 +766,10 @@
     "                 n_decoder_layers=3,\n",
     "                 use_deterministic_path=True,\n",
     "                 min_std=0.01,\n",
+    "                 dropout=0,\n",
+    "                 use_self_attn=False,\n",
+    "                 attention_dropout=0,\n",
+    "                 batchnorm=False,\n",
     "                 use_lvar=False,\n",
     "                 attention_layers=2,\n",
     "                ):\n",
@@ -723,7 +782,14 @@
     "            latent_dim=latent_dim,\n",
     "            self_attention_type=latent_enc_self_attn_type,\n",
     "            n_encoder_layers=n_latent_encoder_layers,\n",
-    "            attention_layers=attention_layers)\n",
+    "            attention_layers=attention_layers,\n",
+    "            dropout=dropout,\n",
+    "            use_self_attn=use_self_attn,\n",
+    "            attention_dropout=attention_dropout,\n",
+    "            batchnorm=batchnorm,\n",
+    "            min_std=min_std,\n",
+    "            use_lvar=use_lvar,\n",
+    "        )\n",
     "\n",
     "        self._deterministic_encoder = DeterministicEncoder(\n",
     "            input_dim=x_dim + y_dim,\n",
@@ -732,13 +798,20 @@
     "            self_attention_type=det_enc_self_attn_type,\n",
     "            cross_attention_type=det_enc_cross_attn_type,\n",
     "            n_d_encoder_layers=n_det_encoder_layers,\n",
-    "            attention_layers=attention_layers)\n",
+    "            attention_layers=attention_layers,\n",
+    "            use_self_attn=use_self_attn,\n",
+    "            dropout=dropout,\n",
+    "            batchnorm=batchnorm,\n",
+    "            attention_dropout=attention_dropout,\n",
+    "        )\n",
     "\n",
     "        self._decoder = Decoder(\n",
     "            x_dim,\n",
     "            y_dim,\n",
     "            hidden_dim=hidden_dim,\n",
     "            latent_dim=latent_dim,\n",
+    "            dropout=dropout,\n",
+    "            batchnorm=batchnorm,\n",
     "            min_std=min_std,\n",
     "            use_lvar=use_lvar,\n",
     "            n_decoder_layers=n_decoder_layers,\n",
@@ -801,11 +874,29 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 209,
+   "execution_count": 45,
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2020-02-01T03:19:33.080375Z",
-     "start_time": "2020-02-01T03:19:33.067520Z"
+     "end_time": "2020-02-01T04:44:56.415822Z",
+     "start_time": "2020-02-01T04:44:56.404603Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "def set_seed(n=42):\n",
+    "    np.random.seed(n)\n",
+    "    torch.manual_seed(n)\n",
+    "    torch.backends.cudnn.deterministic = True\n",
+    "    torch.backends.cudnn.benchmark = False"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 46,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2020-02-01T04:44:56.434892Z",
+     "start_time": "2020-02-01T04:44:56.418611Z"
     }
    },
    "outputs": [],
@@ -849,11 +940,11 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 210,
+   "execution_count": 47,
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2020-02-01T03:19:33.099668Z",
-     "start_time": "2020-02-01T03:19:33.083014Z"
+     "end_time": "2020-02-01T04:44:56.457667Z",
+     "start_time": "2020-02-01T04:44:56.437848Z"
     }
    },
    "outputs": [],
@@ -881,7 +972,7 @@
     "        \n",
     "        if plot:\n",
     "            fig = plt.figure()\n",
-    "            plt.title(f\"Iter {n_iter}\")            \n",
+    "            plt.title(f\"Iter {global_step}\")            \n",
     "            plot_functions(target_x.detach().cpu().numpy(),\n",
     "                           target_y.detach().cpu().numpy(),\n",
     "                           context_x.detach().cpu().numpy(),\n",
@@ -904,22 +995,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 211,
+   "execution_count": 48,
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2020-02-01T03:19:33.119679Z",
-     "start_time": "2020-02-01T03:19:33.101969Z"
+     "end_time": "2020-02-01T04:44:56.472422Z",
+     "start_time": "2020-02-01T04:44:56.460171Z"
     }
    },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "runs/Feb01_11-19-33_mjcdesktop-anp_1d_reg\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "\n",
     "MAX_CONTEXT_POINTS = 50 \n",
@@ -930,14 +1013,19 @@
     "\n",
     "dataset_test = GPCurvesReader(\n",
     "    batch_size=1, max_num_context=MAX_CONTEXT_POINTS, testing=True, random_kernel_parameters=random_kernel_parameters)\n",
-    "\n",
-    "writer = SummaryWriter(comment='-anp_1d_reg')\n",
-    "print(writer.logdir)"
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Replicate ANP paper"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 212,
+   "execution_count": null,
    "metadata": {
     "ExecuteTime": {
      "end_time": "2020-02-01T03:19:33.175871Z",
@@ -946,39 +1034,33 @@
    },
    "outputs": [],
    "source": [
-    "hparams = dict(x_dim=1, y_dim=1, hidden_dim=128, latent_dim=128, latent_enc_self_attn_type=\"multihead\", det_enc_self_attn_type=\"multihead\",\n",
-    "                   det_enc_cross_attn_type=\"multihead\")\n",
-    "model = LatentModel(**hparams).cuda()\n",
-    "\n",
-    "optim = torch.optim.Adam(model.parameters(), lr=1e-4)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "ExecuteTime": {
-     "end_time": "2020-02-01T01:23:02.658135Z",
-     "start_time": "2020-02-01T01:23:02.653762Z"
-    }
-   },
-   "source": [
-    "# Train"
+    "epochs = 100000\n",
+    "PLOT_AFTER = 10000\n",
+    "PRINT_AFTER = 1000"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 49,
    "metadata": {
     "ExecuteTime": {
-     "start_time": "2020-02-01T03:19:32.800Z"
+     "end_time": "2020-02-01T05:07:39.487430Z",
+     "start_time": "2020-02-01T04:44:56.475211Z"
     },
     "scrolled": true
    },
    "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "runs/Feb01_12-44-56_mjcdesktop-anp_1d_reg\n"
+     ]
+    },
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "6c16408b24384de3bb64ec531aabba61",
+       "model_id": "2138f524a03f4f109cc7b6dead2fb25d",
        "version_major": 2,
        "version_minor": 0
       },
@@ -993,12 +1075,633 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "train: 0 loss= 0.9087 val_loss= 2.267\n"
+      "train: 0 loss= 1.123 val_loss= 1.562\n"
      ]
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "train: 100 loss= 0.4587 val_loss= 0.6413\n",
+      "train: 200 loss= 0.2329 val_loss= 0.6051\n",
+      "train: 300 loss= 0.3573 val_loss= 1.295\n",
+      "train: 400 loss= 0.426 val_loss= 0.5766\n",
+      "train: 500 loss=-0.08328 val_loss= 0.5137\n",
+      "train: 600 loss= 0.1441 val_loss= 1.05\n",
+      "train: 700 loss=-0.09933 val_loss= 1.253\n",
+      "train: 800 loss=-0.2678 val_loss= 0.8743\n",
+      "train: 900 loss= 0.04808 val_loss=-0.0923\n",
+      "train: 1000 loss= 0.3288 val_loss= 0.3959\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXsAAAENCAYAAADuRcXXAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+17YcXAAAgAElEQVR4nOzdeZyN1R/A8c+522x3xj4I2ZKSUNZKllKWSkgho1JR2bJFi4qU+pUQkkISsmRJm6XFUFlCScg2SpbsjNnuzF3O749nhjFmuTNzn7ue9+s1L+Pe53nOGZ753vOc5XuElBJFURQluBl8XQFFURRFfyrYK4qihAAV7BVFUUKACvaKoighQAV7RVGUEKCCvaIoSghQwV5RFCUEqGCvBA0hxD9CiDaZ3z8mhPjZw9evKIT4UghxTAghhRDVcrwfJoT4WAhxQQhxXAgxNMf7dwoh9gghUoUQa4UQVd09V1GKSwV7RcmFEMKUy8suYBXwQB6njQZqAVWB1sAIIUS7zOuVBZYBLwOlga3AInfOVRRPUMFeCTpCiOuB6cAtQohkIcT5zNfDhBDjhRD/CiFOCCGmCyEiMt9rJYQ4IoQYKYQ4DszOeV0p5Qkp5TRgSx5FPwqMlVKek1L+BcwAHst8rwuwS0r5uZTShhbc6wshrnPjXEUpNhXslaCTGSyfBjZKKa1SypKZb70FXAs0AK4BKgGvZDu1AlqruyrQtzBlCiFKARWBP7K9/AdwQ+b3N2R/T0qZAiQAN7hxrqIUmwr2SkgQQgi0AD5ESnlWSpkEjAO6ZzvMBbwqpUyXUqYVsghr5p+J2V5LBKKzvZ/I5bLeL+hcRSm23PolFSUYlQMigW1a3AdAAMZsx5zK7GIpiuTMP2MAW7bvk7K9H5PjnKz3CzpXUYpNteyVYJUznetpIA24QUpZMvOrhJTSms857hcm5TngP6B+tpfrA7syv9+V/T0hRBRQE60fv6BzFaXYVLBXgtUJoLIQwgIgpXShDXpOFELEAgghKgkh2hbmokKIcCAs869hmX/P8ikwSghRKnPgtQ/wSeZ7y4G6QogHMs95BdghpdzjxrmKUmwq2CvB6ke0lvFxIcTpzNdGAgeATUKIC8D3QO1CXjeNS90uezL/nuVVtEHXQ8A64B0p5SoAKeUptCmbbwDngKZcPl6Q57mK4glCr81LhBBdgR5AIyAW+BdtnvG4zMExRVEUxUv0DPab0AL8CuAIcBPa3OI9wK2Zj9WKoiiKF+gZ7MtlPrpmf+0RYA5wp5TyR10KVhRFUa6gW599zkCfKWvlYSW9ylUURVGu5O0B2paZf/7l5XIVRVFCmm7dOFcUJEQl4HfgDynlXXkc05fMZeoRERENq1SpUqSyXC4XBoOaaKQnPe8ap9PJhcQLuFxOypQtq2NJl9jSbBw+/C8mk4nqNWrke6x0uRDFuL9EwYcoIa44MWzfvn2npZTlcr7ulWAvhLAC8cBVQBMp5ZGCzmnUqJHcunVrkcqLj4+nVatWRTpXyV+KQ3I63TsNBG9yOp083bMrTW69nceeGYjZbM7z2L2b11O7aYtilVc2TBBlUmFfyV1xYpgQYpuUslHO13VPl5CZVfAroAbQ0p1Ar/inDJfkTBAGegCj0ciMhcu9Vt6ZdInZABaDCviKd+ja1yGEMANL0Obad5BS/qlneYp+XFJy2iZ17b4BWPzpx0wa9xp2u13nknxLAqdsEqeXulEVRbeWvRDCAMwH7gDulVJu0qssRX9nMyR2neOS0+nkzVHPc+7sGeo2uIk2He7Tt8BcHD38L6u+XM7V1apz1z0ddS3LIeF0uiQ2DLIlZ1MUXejZjfM+8CDa8vAUIUSzbO8dUd05gSPFIUlx6F+Oy+XijfemsfOP37mz/b36F5iL6RPeZu6MD7iqchXdgz2AzQnn7VDKontRSojTM9i3z/zzpcyv7MagraZV/JzDJTnrpX56s9lMh85d6dC5q1fKy82YdydTtUZNGjRqgpTSKy3uC3aJxYAasFV0pVuwl1JW0+vaivecSZeEUl4Lg8HAkwOHeL1cNWCr6E1NRlfydMEusXkp0mdkZPDua6/wy9ofvFNgAZIuXKBprSrs/2u3V8rLGrB1qQFbRScq2Cu5srsk5zO8F3h2bNvClLff4NXhz3qtzPz89MMaTvx3jB9WfeO1MrMGbBVFD2pbQiVXZ9L1n2aZXemy5egzaChlY8t7sdT8tevYmWo1r/FqmWlOSMyQlLCo7hzFs1TLXrlCkl2S7uWO+hq1ruWlce/w1ODh3i04DzfUv4myseUZ/lRvqkebqFuxJKMG9+fQwQTdyz5vl9icqoWveJYK9splHF7uvgHwVn4md61ds5J2zRqwcM4skpOSkFKSnJTEwjmzaNesAVs2b9a9DqfTJQ6Xf/27KIFNBXvlMucyvDv7xul00vWuFmxcH+/FUvN26GAC/eIeIi01FUeOVbwOu5201FTGvjZa9xa+U2Z2pfnZB6ESuFSwVy5KdUhSnd4tM2HvHrZt2sCwvo/5RWCbMXlCgakaHHY7M6dO0r0uNpe24EpRPEEFewXQulLOebn7BrSB2bETpvL0kBF+kTLgi0Xzr2jR5+R0Olm+cJ5X6nPBLklT/feKB6jZOAoAF+za1D9vKxsbS6++z3i/4DykJCe7d1ySe8d5wul0ScVwMKkFV0oxqJa9gsMluaB3lrMAEWW1undctHvHeYIrc/69P3RzKYFLBXuFRDs+SYngcrlYMHsGWzb87DeBrFO3npjy2bgEtNz3nbvHealGmnTVf68Ukwr2IS7DJUn2Rf8NcOzIYV4Y+DT9enXzi/56gD6Dhua7SxVoffZL58/x2rz7LKr/XikOFexDnLcHZQ8dTGDU4P7UrViS22+oiclkpmTp0l4NmvmpWqMm0+YtJiIyMt8WfmpKysV592vXrPRa/dT8e6WoVLAPYWlOic2LUy1zW6zkcNj5+8B+rwfN/LS+uz2rNm2nR+8+RObTh581775f3ENe+7BySTil+u+VIlDBPoR5s1XvzmIlbwbNglStUZOxE6bQpXtcgX34di/Nu8+SofrvlSJQwT5EJdsldi+OyrqzWMnbQdMd7sy7d9jtXpt3n+WCXZLqo7EWJTCpYB+CpJQkenmqpb8GzYL447z7LGcyVP+94j4V7ENQssP7C6j8OWjmxx/n3WdxZebPURR3qGAfYlw+aNWDfwfN/Lgz795kNnt93n0WmwuvZylVApNKlxBikuxaRkVv69StJwvnzMq3K6coQTMtFY4dgf+OwoXzkJYGqSlgMEB4BISHQ+myUKkKVKgEFkvh6t1n0FCWfvZpvvU2m808OWBw4S7sQYl2SbgRwo3+sVZB8U8q2IcQl5Rc8NGgnieC5snjsOkn2LVDsPsP+GsnnD7pfoATQnJ1dbjxJmjQWNLyTrjmOshvPVfWvPt+cQ9ht9svq7/JbMZsNjNt3mKq1qjpdj30cDpdclUEGPxkcZrif1SwDyFJdq2f1xeygubTPbqSnm677L28gqbTCb/+Aqu/EvyyFvbvuTKQmc2SipWhYiUoWQoioyAiEqQLbDat5X/6FBw7DMePwaGDgkMH4eulgteBylUlHR+Eh3pJquURr7Pm3c+cOonlC+eRkpREVHQ0nbvH8eSAwT4P9HAp/325cBXsldwJf12c0ahRI7l169YinRsfH0+rVq08W6EA55KSo2nSZ8E+yzfLl/DGC8M5dfIEDruDqGjrFUFzx2+w+FPBqhVw+tSl4BURKWl8K9zUGOrUk9S5ESpdrXXZuMNuh/17YMc22PyzYN13cPbMpeu3aCN59gVJw6b5X2fv5vXUbtqi0D+7N5S2CKLNKuAHuuLEMCHENillo5yvq5Z9iEh2+K5Vn909nbtyT+euV7xuS4NFc2DeTMGfv18KVlVrSDp0htZ3Sxo0Lnyfe3ZmM9S5Ufvq/pjE5YItGySfzxN8swzWfy9Y/72g1d2S0e/k3dI/mJDAd+t+5sabG9KyTduiV0gH5zIkYUawqHTISg5qNk4IkNJ/UxinpsCMyXB7XcHI/gb+/F1QopTk8f6Sr39xEf+HZOQYSZPbihfoc2MwQNPmMH66ZMNfkv7DJVFWSfwaQdumgvfHg8Nx5Xnbt//O+Nde5ptln3u2Qh4ggdM2ictPn9gV31HBPgQkO3wzAyenI/8eYu+unaQkJ2O3wycfQPM6gjdeNHDqhKBOPcm7H7nYvE/yyv8kdevnP3jqSaXKwHOjJev/lHTpIUm3Cd4ZbSDuPsGpE5cfe9NNN/PYMwNp3+kB71SukOyZ+e8VJTvVjRMCkvykVT9n+lRmTJ7AQ4+M4/dfn7844NqgsWTQSEnrtt4L7nkpUw4mzJB07iEZ2kew6SfBvc3hwwWSBpm9oNVr1KBdj8d8Ws+CpDm1+fclLao7R9Goln2QS3VI/CTWExZWCmt0bRZ/eg379wiuri75cIGL5T9K7mjn+0Cf3e13wDe/SBrfIjnxn+DhewQb1/u6VoWTqPLnKNmoYB/k/KVVv3YNfD7vJZKT9hAR2ZURY1ys2SJpe59/BfnsYivAZ99KOneXpKYIHusiiP9Oe8/pdLIh/kfeHv1SgQnefOlMusTuDyPzis+pbpwglu6U2Hyx32A2djuMe0kwe5oW0Rs2k7z7Yd4zXfyN2QzvfiQJj4AFswV9u8GY10tRtb6d5wc+xb9/H6RSlavp+cRTvq5qrlzAKZukglpwFfJUsA9iST5+hD95Agb0Evy64SgGw3zi+rTk1bebYDT6tFqFZjDAuMkSsxk+/Ugw+pW6XNNAMG7yB+z6Yzs3N73F11XMV9aAbaxacBXSVDdOkHK4JCm5TBv0lu1b4b7mgl83CEqW2k6z27fy+dw7efKhe31XqWIQAkaPlzzYS5JuM/J4V0FERBueGjyc6+vW83X1CpQ1YKuELtWyD1JJPgz0a1fDM3ECW5qgya2SqXM78O/BEqz7rjYduly5oCpQGAzw1lTJqaMnif+xPHEdYeYiyW2tfV0z9yTaJRYDRJpUCz8UqWAfhFxSkuyjgdmln8GIZwROp+DBXvJi90ds+dtodMttPqmTJxmNMOL5PZSpGMvS+YLHuuwjru9PPPxYM2pdX8fX1SvQ6XRJBYNaYRuKVDdOEEp2aANz3jbrfRjW14DTKeg3XPL2NInLlc6+3buwpaX5oEb6MBol73wg6dVHYrdPYfb7ffh42le+rpZbJHDSJnGqFbYhRwX7IOOr1AiffghjR2q30yv/czFitEQIOLD3L+5uUo/7bm/i9TrpyWCA1yZImre+A3iIZQvq8Mc2X9fKPU6pzdDx1ySIij5UsA8yvkiNsPATeGWYdiu9PsnF4/3h0MEERg3uT9c2twNw8MA+Rg3uz6GDCd6tnI6EgDlfdKLjgwtJt93Po50Fe3f5ulbuSXdpe9gqoUMF+yDii1b9isXwwkCt//fl/7mIexLWrllJu2YNWDhnFmmpqQA4HQ4WzplFu2YNWLtmpVfrqCejUZuH36aD5PxZQe8HBCf+83Wt3JPiwG8T5Cmep4J9EEl1encj8Q3rYPhTAikFI8a4eCKzRd8v7iHSUlOv2JXKYbeTlppKv7iHgqqFbzZDv+G/UaPWEo4d0QJ+cpKva+WecxmSNH/IkqfoTgX7IJLoxcfyA3vh6Z4Cu13wxABJv2Ha6zMmTyAjIyPfc+12OzOnTvJCLb1jz84/6XJHI86ceoqqNVLZvUPQ/xGRa3pkf3TaplIqhAIV7INEihcTnp05Bb0fEFw4L2h7n+TFNy4VvGT+HJwFRDmH3c7yhfP0rqbX1L6hLre1upMuD8cx5ZNUSpeRrPtO8PIQQSCMgWalVFA58IObmmcfBKSUXlsdabfD0w8LDv8jqN9QMmmWvJj+4NDBBLenWKYkJetYS+8SQjDvq9WIzNwzMxZLHr5Hy6VTo5akzyAfV9ANdgmn0iWxYVz8OZTgolr2QSDZ4b2++vFjBFs2CipcJZmxWBIReem9GZMnuH2dqGirDrXznewBsmFTmDhD+w95c5Rg/Q++qlXh2JxwLv8eOCWAqWAf4FxSkuil/pvvvoEPJwmMRsnUOZLY8pe//8Wi+W5fq3P3OA/XzvcSz51j4/p4bGlpdOgMA0dIXC7BwMcE/wTIeHSSQ5KicuAHJRXsA5y35tUfPgTDntJaryNfkzTKJdFjSrL7XTNPDhjsqar5jW7t76BHhzvZ/ecfAAwZpU3JTDwn6NMtcGbonEmXZKgB26Cjgn0A81ar3uGAgY9pA7JtOuTdBx1lda9rJiIikqo1AiShfSHUb9iIBo2bXuzSMRhg4kzJNbUl+/cIhvYRuHy8v4A71KblwUkF+wB2wQ7eaIDNmAzbtwgqVpKMny7z3FmqU7eemMzmfK9lMpno2usxz1fSD7w+aRpfrN3ATY2bXnwtOgY+WiiJLiFZ87XgvTcDY/DTLuGsWmEbVFSwD1BOKb2y5eCBPTDxdS1AvfW+pGTpvI/tM2go5gKCvdliCcouHCDPn71GLZjyicRgkLz3pmDtGi9XrIhSHPgse6rieSrYB6gLdv0zWzqdMPwZQUaGoNujkpZt8j++ao2aTJu3mIjIyCta+CazmYjISKbNWxyUXTjZJZ47x/mzZy97rdVdMHSUFjiHPCk4etgXNSu8sxmq/z5YqGAfgLzVqp819VL3zUvj3Cuv9d3tWbVpOz1698EaE4MQBqwxMfTo3YdVm7bT+u72Otfatya+MYb6Vcoyb+b0K97rNxxa3a3l0On/iKCAhcZ+QfXfBw+1qCoAXbBrv4R6OnwI3h2rdd+MmyKJKZH/8YcOJjBj8gS+WDSf5KQkjEYjXXr0YsCIF4O+JZ9dlWrVCI+IICXlyplJBoM2//7e5tqH6LiXYPQ7/h9E1R62wUG17AOMt1r1r40UpNsEHR+UtL47/2OzZ7lMTtLmFzqdTpYvmh90WS4L0vHBHuw6nsjIMeNyfb9UGZj6qcRslnzygeCbZV6uYBGpPWwDnwr2ASbJC636tavhu68FUdaCu29CMctlfiwWC8as/BF5uKkxjHpT+3cd0U9wcL83alZ8iXZJqlpwFbBUsA8gLilJ0vmXzWaD0c9pj+uDX5SUr5j/8TMmT8CeI8jnFGxZLgtit9vZ/PN6vl66OM9jHnkK7n1AkpKs9d/bbF6sYDGcTpekq5TIAUkF+wCS4tB/Xv2M9+DQQUGt6ySPPVPw8V8smn9Fiz6nYMtyWRCnw0G3dq0Z/EQvHHlkABUC3poqqVZT8tefgnEvBkZ/uERLmKZSIgceNUAbILyxC9V/R+H98VrQeW2CpIAp84D7KRKCKctlQcIjImjT4V6s0TGkJCdTomTJXI+zRsPUOZLOreHTjwS3tpS0u9/LlS0Cp9Q2LS8fDiaDf3xI2V2SDBfYXVr9JBKX1D6cBGAQYEBgEGAUXPzz4ntCa/nqmfHTJS/VScLF710SpNSmUrskROkUlVWwDxDe2IXqnTECW5qgQyfJLS3cOyfKar04KJvvcUGW5bIgMxevcOu4ug3ghdclr40UjOgvuKGBpEpVnSvnAY7MgB/ro4DvlJJUB9icEpvL3Sdedw6SmUGfi38KtC8yv8/1qtmCuEQL3jm/d1eYUZ9/T9WNEyD0btXv3A7LPhOYzZKRr7lfllspEszmoMxy6Sm9+0GbDpIL5wXPPi4ooFfMb9gzA77Di106qQ7JSZuLI6mSsxmSVKfnuzZdaE8HdgkZLm1zdptLSwGdlsuXzam9n+7i4tOFQ2rXcBUy0OtJBfsAYHNqj6h6kRJef0FrTTz6NFSt4f65bqVIMJuDNkVCfmxpaZw8cbzA44SAdz6QVKwk+W2zYMLr/tE14g67hOM2fVfZujKnGx9NdXEqXZLm1K2ooKaCfQDQu1X//bew6SdBydKSgSMKX1az21vl+noopUjIad33q7munJXhT/V26/hSZeC9j7X8OR+8GzgbnoDWgj2e5vk8+C4pScyQHE3TWvFq1mfxqGDv5+wufVsyDoe2mxLAs89LSpRy/9ysxVQ//fhdru+3uPPukEiRkJtKla/GZDLhcrr/n9fkNhjykhbRhj4pOHlCr9p5nkSblnkmvfipFRwuybkMydFUyXm79Epm11CgBmj9XJLO/bfLFsDB/YJqNSU9n3T/vOyLqfKycf1aD9QwMNW4tjZ7TqdgMhXuV6zfcNi4XrJhnWDok/DpCokhgJpkyQ6tcVLCDFZT4Wa3pDtl5k5ZOlYwhAXQbRR6XFLfLeIyMriYX33wixKLxf1z1WKq/BkMhkIHegCjESbNkpQpK/l5rWD6RB0qpzNnZi78o2mS8wVkzUx3al01x9JcHLepQK8nFez9WJLOaYwXzYGj/2oLqO7rWrhz1WIq90gp2bd7F7IQXRuxFWD8R9rx774m2LZZr9rpyym1FAv/pUkOp7j4L83FCZv29V+ai39TtAB/3i6xB8AOXoFOBXs/JXVOjWBLg6lva636IS9JCkjncgW1mMo99zZvzN1N6rFv965Cndf6bnhyoMTpFAzqLUg8r1MFvcSFNi3RljlVMcPlP1MSQ4UK9n4qReeNxOd/DCf+E9SpV7RVm+7uNxtqi6lyuvb6OsRWqMjx/44W+twRYyQ33iQ5+q/gxYEClVJeKQ4V7P2UntMtU1Pgg8y0CENHFW0AUC2mcs/rk6axef9hWrZpW+hzLRZtO8Moq+Sb5YIFs3WooBIyVLD3Q6kOiZ5T6+d8CKdPCeo3ktxZxFmRajGVe6Ks1mLlW6lWE954T7sZxowQ7NvtqZopoUYFez+k5+YkSRfgw0la8Bn+iqSocUjtN1s4UkpcrqKNQnbqBl3jJOk2wYBHBWl5z3ZVlDypYO9nMlxaYie9fPw+nD8raHKrpHnr4l0r1PebdderwwZRr3IZNq4r+rqDMeMlNWpJ9v0lGPt84KRTUK506GACowb3p075GKpZjRe/6pSPYdTg/hxM0GejHxXs/Yyei6jOn4WZU7RAMawYrfosTqeT71d+zTNDR7Dz2Dn+TrKz89g5xk6Yolr02bhcLpISEzm4f1+RrxFlhSlzJBaL5LOPBd8u92AFFY/KCuZ1K5akerSJuhVLMmpwfw4dTLi46vyz2TNITUm57LzUlBQWzJ5Bk5vqs3mz5+fbisLM//WmRo0aya1btxbp3Pj4eFq1auXZCnmBU2pLxPX6H5nwumDyW4LmrSXzvip+KT+v/Z64+9pS/Zpa/Pj7X7rmAvcnezevp3ZTN3NAA4f/+RuT2UzFSpWLXfYnH8Do5wxEl5B8uyEw0iGHkrVrVtIv7iHsdvtl61BMZjNGoxEpJRnp6QVeJzw8nJ07d1KzZuEbTUKIbVLKRjlfVy17P6Ln/rLJSfDJdO37Qc97phSj0UTHB7vzSN/+Xgv0BgEWA0QYwWoSxJgFJbJ9xZgFVpMgwqgd5w83eJVq1T0S6EHLStrmHklSYmClQw4FBe3HnG6zuRXoQVt9PnGiZ5dPq9w4fkJKSbKOi6jmz4IL57W++ia3eeaat7RoxS0tWnnmYrkQQJgRwgyCMCOYRWE2yrh0nCNzF6N0F6Q5A3u1phDwzjRJ+1vITIcMI8f459N5qHEnhYi7nE4nc+fOZerUqR65HvhHw0dB24lKr0VUNhvMmKwFv37P+XdgMAqINgnKhwuqRArKhxsoaRFEGEWRd0QyGQSRJkEpi+CqCANXRWhPASYv9jqt+XoF3dvfyScfFP+XN2c65NVfeaCCSrG5k0KkMJLdXKXuLhXs/YSei6g+nwunTwpuqC9p2cYz1zx25DA7//jdIy0ZgbbvZvlwQeVIA6XDBOFGoVvXkNkgKGkRVIo0UC5MEOaF34ILiefZ9FO8xzKBNm3OxR3FhvUVHNjrkcsqxeBuChF3Wd1cpe4u1Y3jB/TcicpuvzSvvv/w4s/AyfLKsIF8/81X9H12GC++8XaRrmHIbMVHm8Hoo8HdSJPW6k91aDnU9epJa9GmLTMWLadBo6Yeu2bfZ2HHb5Jvlgn6docV6yTRMR67vJIPlwsOHYT9eyBhHyTsEwhhRcqC92N2h9FoolevXh65VhYV7P2Anq36r5bAkUOCGrUkbTt65poul4sbGzRk3+5d9Bk0rNDnG4BosyDGDAY/mcETaRKEGyHRrs//R2z5Ctx1j4f+AzIJAW9PkxzYA3t3C4b1hemfBVb++0AgJRzcr+3T/Ofvgj9/h907IOlCzns3DpgJFP9p12w2MWTIkGJfJzsV7H1Mz52oXC6YlpkD55lhhc9smReDwcCzL7zMoOdHFbqrJcoEJc1F73/Xk0EISlm0mT6n0gNjh6QoK3y4QHJfC1jztWDaeMmAEb6uVWBzuWDvbtj8E2z+WfDrL3Dm9JX3a/mKkuvqQs1roea1EikfY/TwmTjyyclvCQvDIAxk2DNy3cXMaDQSFhbGK6+8UqRpl/lRwd7HLug4dW7NV3Bgr6BSFUmnbp6/fmECvVFAmTBtoNXfhRsFFcPhZLpnZ+7s3bWTZQvmUq3mNfTo3cdj161WE96bJXniQXh3rOCGBpLWd3vs8iEhJRl++gG+XylYu+rK4F6uvKRBY6hbX3LjTVD3Jogtr7136sQJypUvz7OPT8JoMmIwGnDYHbhcl4K5yWzGbDYzbd5ialxzLTOnTmLpZ5+Smq2fP8pqpcvDjzBy2BBOHTvi8Z9RBXsfsrv0m24pJbyf2arv+6ykgJxlbktOSmLLhp+ofcONXFW5ilvnRBihbJjwmy4bd5gMggrhcNImSfdQwD986G8+nDSeps1bejTYA9zRTtttbOIbBp59HJZ9L7nmOo8WEXRsNvjhW1i+ULD+e8jIuHR/VqwkadocmjbX/qx+DbmOd01793+8/eqLjH7nPWxpaaTbbCxatZavl33O8oXzSElKJiraSufucTw5YPDFleVjJ0xh7IQpudYrNlyoYB9sEnXsq//pR61/sWw5SbdHPXfdXX/8Tu8H7qN+w8asWLepwONLWbSFToHIIASx4XDK5pl8RTc3uYWBI16i8W3Ni3+xXAwcCbv+kKz5WvBoZ1j2o6R8RV2KCmgJ+2DOdMHyRZCUqN2bQkgaNpPc0U7Spj1cWyf34J7TH1t/BaB56zt57JkBnDl1ijLlytG0edjZHhQAACAASURBVIs8g7mvqGDvI3aXvvttvv+Odqc+PkASHuG56xoMBm5teQd16tXP/zigbHhgdNvkxyAE5cLhhK34M6ZKly3LsFde80zFcmEwaPPvH74Xfv9VC/iLV0tiSuhWZMCQEjbEw4wpgvg1l+7Jug0knXto23JmdcsUxocLlnJg7x6uqa09RpUpV84zFdaBCvY+cjZDv1b9tk3awFJ0CUnck569duNbm/PZN9/le4xRaI+iFj8chC0KgxCUC4PjNqnr7mGeEBEJsxZLut4Fe3YKHu8Kn34hiYzydc18Q0r4eS1MGifYtkm7H8PCJV26wyNPS66vW/wysgK9v1OTtHwgzSmx6TQDB2DSm9pN/WhfvN6qMwmoEESBPovJIIgNFxT3p5JSsv6HNTz7eBzOXGZjeELpsvDpCslVlSVbNwr6dBPYbLoU5dd27YBu7QS9OhrYtklQsrRk2MsuNu6RvDm1eIH+3ddeYe6MD7ClpXmuwjpTwd7LpJScS9evebh1I/z0g8AaLXligGfLkVJy5tSpPN83CW0VrD9Oq/QEi0FQ2lK8n81ut/PCwKdZsXgBG9b96KGaXany1TDvK0nZWMkv8YJ+cYKMDN2K8yvJSfDqMMF9zQW//iIoVVoyYoyLn3dJBo7UPgyLI+nCBaa8/QavjRiC0RQ4nSOBU9MgkeRA1y0HJ76R2VffT8uh4kmnThynyTWVqVHrWn78/a/L3jMGeaDPYjULivMjWiwWhr/yGufOnKVGrdqeq1guatSC+V9JureHH1cJBj8Okz+RBFB8KrRNP8HwpwVHDgmMRknvfpLBL0pKlPTM9dPT02nbpB5NbmtB41tuK3BrTn8SxP/t/sfhkpzXsa9+88/wS7zWV+/pVj1o+XCs0dGUKRt72euhEuizmIQ2nbSoi+G8uQl77Ru0Lp2H74FvvxCEPwPjPwy+VbYZGfD2q4JZU0FKLQ/U+A890yef3aoVyzh25DDhEREMf3WsZy+uMxXsvehMhn4bk0gJ48dowfaJ/pISpTxfRoNGTfjz2DkuJCZefE0A5cIE5hAJ9FnKhQlOemhKpt5uvAk+WSbpdT8sWyCIiITXJ3kuT5KvnT0NT/fUumyMRkn/4ZIBIyUWi+fLuqfLgxzcv48uPeICbrOeIPt8919Jdn0HZb9eCls2CsqUlTze3/PXT7pwAbvdjhCCEiUvPROXDROEBfj0yqIQQlAuXGAp4m/QgT1/MXfGBxz+52/PViwPDZvBzMWSsHDJ/FmCl4cIirj/uV/Z/xd0aq0F+tgKks+/kwx92fOB/tyZM3y9dDFSSoa89GpAbrupgr0X2F1aRkW9pKXCm6O0gPvcaH3mVU94/VWuL2fls48/uvhaKYuWMTJUaVMyBUX5rJv6zjheHjKA+O9Web5iebi1pZYozRImmTdTMKxvYO90Ff8ddLlT8O/fgroNJF+ul9zcRJ+ytm3ewIBHe/Dc04/rU4AXqGCvM5eUnErXr/sGYPpEwbEjWj/lg57NinpR4rmzOBwOypWvAGgJzQJ1ZawnZU3JLOwvUuu27bn/oR5Uv6aWLvXKs9y74ZOlksgoyfKFgn69Am9appTaXryPPyBIuiBof79k8WpJhav0K/P8ubMYjUa6PfqEfoXoTG04rrPT6S5dV8oeOgh3NxGk2wSfr3HR+Fb9ykpLTcVgNGKNCKNCeGDluvGk3O6vVIf2oR4oft8Cj3URJJ4T3NpSMmORJMqze2Xowm6HMc8J5s3U7r2BIyRDRukz4Cyl5Ojhf6lU5WqcTifJFy5QsnRpzxeUQ2y4YPNP64ocw9SG4z5wwa5vSgQpYdRgLdB37i51DfQAEZGRhIeFBVxSM2/I2vYwUNzUGBat1Obhb1gn6Hmf4EzeSyj8QuI5eKyzFugtYZJJs1wMe0W/mUUH9++jeZ0a3N+yGSaTySuBXk8q2Oska+cjPX2xCH76UVsZOOpN/cpKT0+/+H0pS/CtjvWUGLPAWogxjKQLF/h9y2b+2rlDx1rl7bq6sOQ7SaWrJdu3CB5oI/gnwSdVKdDfB6DzHYJf4rXkfgu+1Sdtd5ZXhg7kiQe1zWYqX11Vv4JyEJlfelDBXgc2p+S0zo/0Z0/D2JHabTHqTUkZHfMvtWtan3tua8S540eJVv30+Sptwe09bb/7ZgWdW9/KtPFv6VupfFSrCct+kNSpJ/knQdDlDsFvv/qsOrnaEK/NuDm4X3BdXckX6yQNPbe74xVSkpNZPHc2/yQc4KddCbw59aOCTyoEAVgM2rhXCbOgbJigQrigcqTg6igD4TrNbtM12AshqgghlgghEoUQF4QQy4QQV+tZpq/ZnJKTNn0HZAHeeElw9ozW3/rAw/qVc/rkSY7+e4jD/xzkuioV9CsoSAih/fK68/tarWYt6ja4mSrVqutfsXyUr6hlx2x5l+TsGUGPDoJVX/q0Shd99jE80kkbW2jTQbLkO0llnSNIZFQUS3/4mTHjJ1OlarXLphoXlgEIN2pPfWXDBFdFCKpECipGGCgbZqCkRRBl0qYv670Ps26LqoQQkcCPQDrwKCCB14G1Qoh6UsoUvcr2lRSH/i160Fo6S+dr/ZZvvKfv4piysbHsOHqWM//sJ9wSOEvDfclkuJQlMz83N2nG1z9v8VKt8meN1ubhvzwEFn4ieKYnvPI/Se9+vqmP0wmvvyCYPU27uZ8aLBkxxnNba+ZHCMEN9RpwQ70GhT7XKLTgHmbQ9jT2p8WGeq6g7QPUAGpLKQ8ACCF2APuBp4AJOpbtdeczpK6bkWSxpcGLz2o30LPPS6pfo3uRlIyKoHajwt/4oSzMKCht0TeVtaeZzfDmFEnlqyXjXzMwZoTg4H7JK297bqczdySeh8FPCNauFpjNkjcmSx7SaUqxJ4QZIMIoiDDh1+NZenbjdAQ2ZQV6ACnl38AvwP06lutVTik5aXN5JdADTPmf4J8EQe06kj7P6lvWisUL2LZ5IyVMQbDU0geizYIoN5pTDocDR367VHuREDBgBEyc6cJikcydIejV0XszdfbshPtbaoG+VGnJvK+8G+hXrVjGgEd7sHb1t/keZzFokxUqRQgqRBgoEQATF/QM9jcAO3N5fRdQR8dyvSbVIfkvTRY5IVZh7dkJH07StlAbN0Wf3B9ZnE4no4b054E7m/PfkcP6FRTkSlsE+Y1pD+rdk9plIlm1Ypn3KuWGzt1h4SpJbAXJpp8EHVsK/timX3lSwuK52oybfxIEdepJVqzT9n/1lnubN+bpng/y9dLF7N2964r3BWA1CSpGaH3uMebASv6nZzdOaeBcLq+fBXJN0yWE6Av0BShfvjzx8fFFKjg5ObnI57rLIcHlxSd0pxOGDLoZhyOG+zoexcp+9m7Wr7yUlBRatmzJyePHOXToEIcOHdKvsABT2PtLAvY8Ho7KlYzBYDCwZ9smalX2rwHwKGDSexbGvFqXvXti6Nwauj98iIfjDmE2e+7mT0w0896Ea/nlZ21KWZu7jjNw8D7STrrYe9JjxeTr7Nmz7Nz+GwAVK15F9Yqx7N28HtCCvEFQpLQYRaVHDNNtBa0QIgOYIKV8PsfrrwPPSynz/aDxxxW0Tim5YNeSmnm7J3bW+zB2pIGKlSRrtkiiY/Qvs4xFYFVTLa9QlPsr2S45k0v/vc1m4/jRI1Sr6YXBlyKy2eDd1wQzp2jpg2tdJxn1lqRlm+Jd1+nUZtu8O1Zw/qy24c6YdyVderi32bcn7Nu9i6UL5tJ30DDS023s+uN3rql9PdWvqYUBbRZNtBmvLyIsTgzLawWtni37c+Tegs+rxe+3HC5JksM3QR7g8D+X0he/Psk7gd5iQAV6D7KaBekuSHZcfgeFh4f7daAHCA+Hl8ZJ7roHRvSD/XsEj3YStGgj6TdM62opTCx0OODb5fD+O4K9u7UTb20p+d80SRXvrV8CYN7M6Xz60TTS09IYPf49rqpcBYBok6CEBd2nQ3qTnsF+F1q/fU51gN06lusRUmp98ckO7/XJ514PeHGQIC1VcF9XyZ3t9S9z3ferOZGwh2GDn8UQbLtc+FApC6S78u7SycjIwKLnQEwxNbkNVv8qmT1NMvVtwfrvta+6DSQdH5S0vQ+q1sj93IwM2Lkd4lcLvlgM//6tBdFKV0tGjZO0u997rfnsWrdtj8Ph4IGejwBaI6dMmP8PthaFnsH+S2C8EKKGlPIggBCiGnAb8Hw+5/mMU2o559OckjQH+MMclKWfXUqJ8Orb3nmu+HbpIhbNnUMJaxR9+/b1SpmhQEuJDP+lXf6EuO771Qzr25umzVvw/qcLfVY/d4SFwdND4ME4ydwZkk8/FOzcrn2Newmuqiy5ri7EVtCCd0oyHD4Eu3dAuu1SAK1aQ/LUYEmXh7UnB19p3bYDrdt2QAAlLSKoM7nqGexnAAOAFUKIUWjjVGOBw8CHOpbrNodLku6CDJe28jXDH6J7NqdOwNjntZvv5bckOXYD1E3rFreTfPY0zZo1806BIcRs0ObfZ++/L1O2HKdPniAlOcmHNSucMuVg8Ivw9BDJ999KVn8liF8Dx44Ijh3J/Zya10qa3Q5tO0pua4VXFki5w2wIjd3WdAv2UsoUIcQdwERgLtqg9g/AYCllsl7l5sYlJfbMx2e7hAyX9nenH693kRJGP6ctE7/9Tm3QSi+HDiYwY/IEvlg0n5TkZKxWK3FxcURFRelXaAizmgU216WMqNffWJ+lP/zMzU0C78M1PALufQDufUDidMLBfZKE/XDmlHYPR0TCVZXhuhugVBlf1/ZyDa4ux8ChzzH6xZEhkcVV1z1opZT/Ag/oWUZOLilxSjhpc+GU3p8i6SlLP4NvlgkiIiXjJuuXEmHtmpX0i3sIu92OI3PboqSkJGbOnMmcOXNYsmQJ7dt7YaAgxJS2CGxO7V41Go00bHqLr6tUbEYj1Lpe+/J38d+t4vzZs4x/4zWG9HuKUqV02LTZzwTd6JtEa7GnObXumUAM9Af2wstDtOj+2gT9ZigcOphAv7iHSEtNvRjos9jtdlJTU+natSsJCX6a9zaAGTITpuVkS0sj8fx5H9QoNKxd/S3nzpzhgXvaMX36dJYtWxYSgR6CMNgHOpsNBjyqzb7p1E3Stad+Zc2YPAF7AZuQ2u12Jk6cqF8lQli48fIBwdnTplCvUmlmTVH/3nrYvvVXHu/akU8mvYXVbOCpp56iXbt2vq6W16hg72feeEGwZ6egWk3J65P0zWj5xaL5V7Toc7Lb7cydO1e/SoS4kmZtuh/AVVWqYLfbOXH8mG8rFUSklGRkZABw5uQJypcvT2oADYR7kq599krhrFoBc2domf6mzpFYo/UtLyXZvXHyZDePUwpPy3+vTcds2aYt2w+fLlb+dOVyP6/9ntdGDGXizDn06NKRbh3a4HL52bQ7L1Etez9xYA8Mf1prxr/wuqSuFzIKR1nd22Ha6uZxStGYDYKSFkF4RIQK9B7mcDj4+8A+tsavIcIoiIqKIjpa51aUn1LB3g8knoc+3QXJSYJ7Ontvw4hO3XpiKiBRudlsplcvP04mHiRizNpmF1my7/sbyA4dTGDU4P7UrViS6tEm6lYsyajB/Tl00DuD/g0aNiG2fHmGDBzglfL8mQr2PuZwwKDegr8PCK6/UfLOdH376bPrM2goZjeC/ZAhQ7xToRBXxiI4eugf7m/ZjM6tb/V1dYoke3CvFm2iZb1rmT/rQ5KTkpBSkpyUxMI5s2jXrAFr16zUrQ7Hjx0FoFKZEuzft4+YGC8klPJzKtj7kJQwarBg3XeC0mUkHy2URHpxHVPVGjVZvPhzIiIirsiBYzabiYyMZMmSJdSsWdN7lQphJoOg9tUV2bn9N/bt3onNZvN1lQpl7ZqVtGvWgIVzZpGclKTd4GiDpNk57HbSUlPpF/eQLi38Ca+/yq3XVWP10gWUi7IQGRnp8TICkQr2PiIlvDlKsPATQXiEZMZi72f8s5oE7du15c8//+SZZ54hJkbLrR4TE0Pfvn3ZsWOHWlDlZWWsEaz+eRPbD58m3JdJYwppw7q1PPlQp1zXbOTFbrczc+okj9flvq7dAGjfuoXHrx3IVLD3AYdDy2T50XsCk0mbedOwqffrseKzOYwcOZKaNWsydepUEhMTcTqdJCYmMnXqVNWi95HWTRtSIiZwBhHXrllJr45tcRZya0WH3c7yhfOKXX7i+fP06NCGjevjAbj2uuv5dO5cqlSpUuxrBxMV7L3szCno1VGwYLYgLFzrumnTwfv1sJoEX325ggkTJrB27VrvV0DJk0EIyuSyutYfZa3CdjqLlgc8Janoc97/PrCf0ydPMnPyBDauX4s1c5ZNkzq16Pnww0W+brBSwd6Ltm6Eji0FG9cLysZK5n8lucNHC/hizNCxY0ceeeQRKleu7JtKKLk6ffo0Q/o/w6BHuvm6KgVyZxV2fixhYQUek5GRwZefL2T1V1+QkZGBlJLTJ0/y0rP9aFSjIidP/EeNWrUpWao0pS2CMG/uHxhA1KIqL0hNgXfGCD75QNvWrUFjyfT5kgpX+aY+USZtbnfv3r3p3bu3byqh5MlqtTJ79mzsdjtvJZ4nsoT/zr13ZxV2ftrd3+Xi9wf27uH4sSM0b63tdyilxG63E79mJcP6Pobdbuezb77n87mzWb5wPlFWK1FWK4Oef5lKVa4mygTRQZyPvrhUy15HUsJXS6BNQ8HsaQKDAQY8J1m0yneBHqCEWQTNPO5gFB4ezhtvvEGnTp1oel01n8xPd5e7q7BzEx4RwYDnXiQjI4OffvyOtk3qEXdfWw7s3YOUksFP9OKmq8tR6eqqfPXTFu6+935uadGKiplbBw4ZNYY/j53jqspVMAstk6iSNxXsdSAl/PQjdL1LMPAxA8eOCOrUk3wRLxn+qsSNJ1fdRBrh+NEjXHvttfz555++q4iSp5UrV/Lqq6/y9ddfk+TF+emFJaW8YlqlO0xmMxGRkXww/3O2bvyZa0tHsOarFTw15Dk6Ptida2pfR+K5c5w9fYqU5GSurlaD6+reyEcLlyGE4OkhI/jtnxM8OWAwBoNByyAaLkIiJ31xqG4cD8rIgNVfwuwPBL9t1m68MmUlz42WPNjLP3bmKWERTJo+nX///ZcJEyYwe/ZsX1dJySYhIYGuXbuSmpp6xXuOzD0H+sU9xKpN26law7ezpc6cOlXIMwTWmGg6d4/jyQGDqVqjJv17aeMSFSpVpv/w5y9+eNjtdv47epTpny0hOseCqJgSJS77e2lLcO4Z62kq2BeTlPDHNvh6qWDFYjh1QrvpSpWW9HlW8khfdE9o5q4II1gMgtGjR5OamsqIESN8XSUlh3fffdettNMzp05i7IQpXqqVJvH8ebq2uZ12HTsz9OUxWGNimPX5CgY82oO0XD6cshiNRuZ+uZpbW7a+4r1xk6dzX9du3H1fJ0BLDAdQrnx5vt+2s8A6RRq1nb+UgomiPIZ5Q6NGjeTWrVsLfZ5TSn5Yu47aTfVbUJGaApt/hvU/CH5YCf/+felmu/Z6Sa8+ks49/CfIZ6kYoVpAnhAfH0+rVq10uXZMTAxJbkxHtMbEsPPYOV3qkJftW3+lUyttR62/kxwXA3Nuu52B1l1jNpuZNm8xre/2/OI8o4CrIoKz+6Y495gQYpuUslHO11XL3g0n/tNa7zu2CX77VZtCmZFx6QaLrSC5p4u2D+fNTfBabpvCiDDC6eP/ERsbi8mk/tv9lbvppFOSvJ92ukGjJmzef5gl8+aQnJR0sXul9d3tWbVpOzOnTmL5wnmkJCUTFW29rLtGD2XDgjPQ60X91qN1xSRdgP+OwN8J8E8C/JMgOLgf/j5wqWsmixCSejdLWtwJLdpIGjbzj/74vLhcLpLPHKd3r57s2rWLb775hqZNfbBkVymQ1Wp1q2UfFe39tNM7//id6+vWo/9zL1zxXtUaNRk7YYrXupa0LKEq0BdG0Ab7jAxIPKd9nc/+dRZOHhec+A+OH4OTx7WWe2pK3jdOdIzkxpugXkOof7OkaXMoXdaLP0wx/JNwgE6tmlGqZEnGjBnDE088wfXXB8CO0CEqLi6OmTNn5ttvbzab6dw9zou1gkVzZvHioGcY9spY+g0b6dWyc7IYtB2+lMIJqmB/9CjccgucOnU7NlvhZpWGR0gqVoKqNaBaTahxjaTaNVC9JlS6GgwBOkm1ctVqOB0OXC4X0dHRjBw5UqV79WPDhg1jzpw5BQb7IYO9k3Z6959/UKZsOSpfXQ2n08naVd+6lRpbLwagXJi4OF6guC+ogr3VCocPC8CI0SgpWQpKlIKSpaFESS7+PbaCpHxFqFARyleE2IoQHVO4vvZDBxOYMXkCyxbMJTUl5eLrkVFRdOnRiz6Dhl7WVyml9PoNKqWkbeMbqVy5Mr/++itWq5VOnTp5tQ5K4dSsWZMlS5bQtWtX7Hb7ZUHfaDQSFhbGkiVLaHBdTU7aJDadd9jr060zZ06dZO6KVSxeHY/D4fBZoAcoEyYwqUkGRRJUwT4mBhL+lvzx58/c1Po23QZKs2YfpKen48qRACo1JYX5sz5k6WefMm3eYlrceTcfThrPqhXLWL52A0Yvde4fPvQPFouFhP37KFmyJFFRXkyUrxRL+/bt2bFjBxMnTmTu3LkkJSURHh5O7969GTp06MVspGXDtb1rnTpOqKt5bW0sFgs33tzI5ymXo02CSJMK9EUVVMFeCKhaFQ4cdOoW6LOy/OU3r1hKqW3O0PMhJsycwwcT/kdSYiK//vITt7Ro5VYZMyZP4ItF80lJTibKaqVTt55XPC3kxWaz0eWO2yhbrhxbtmzB6XSqx94Ak5V2eurUqXkeYxSC2HA4nibRK96Pn/4xJUqVJsyXy76BMAOUsvi0CgEvQHuifacwWf7sdjsb1q1l3R/7WLjyxzwD/d8H9tO9w53UKV+CalZjsbdyO3XiOO06diYqIoKGDRuqmTdBIiEhgX79+l22yczgAf25cOSgR8ux2Wy89+ZYfv3lJ2IrVPR5oDcKKBeu+umLSwX7QipMlj+HQ9ucoXTZsjS7vSUAcz/6gB2/XVostnbNSto2qc+m9fGkplyaO13Yrdx++3UTiefPM/b5Ybw1aiRrvvqCd8e/o35BgsTKlSupXbs2H3zwwcV8OUlJScycOZOmN9dn64+rPFbWe2++xsQ3RrNlw88eu2ZRCbQBWaO6j4tNBftCKmyWv+yLX1YsXsDLQwcwsn9fnE4n/yQcoE+3zmRkuJ+B0m63M2PKxIsfBu+Pf4trS0fQ5Y7bePbxnvyxbQvfLF9C/C8badFCbcsWDLLy5eS2QYjdbic1NZVHuj/ImX8908Lv0j2OW1q0pkq16h65XnGUDVP56T0lqIK9lJKEhAQ2bdhQrOukpaay6svlOHLZZi3KWrjFLNkXv9x97/3Ub9iYx57ujxCC6RPfLnQucIfdzuJPP+a266szsn8f3hn9EhkZGQDEr1nFkBdf5a4O93JdDS9vaKvoxt18OR+/P4moYozCnTtzhuSkJGpdX4cF335Pxwe7F/1iHlDCrAZkPSmogr3L5eKm+vV59eWXOHfmjFvnHDqYwKjB/alTPoZqViPVrEauj43m6Ye70q1tK3bv+IP9f+3m/XfexGaz0albT7e7Rkw5Fr9EREbyRfxGuj36BAaDgS8/X1SknzMjPZ1jRw5Tplws0+d/zguv/4+tB//jn2Qnt7a6gxVfflmk6yr+ad68eW4F+7lz51LGIggv4oSv6RPfpn7lMsx6/72iXcCDokxQUuWn96igmo1jNBppc9ddHD12jBH9n+TMqVN8suybK1KiZsmaQpmRnp7rI/K2zRu557aG3HhTQ3b8tpXk5CT6DBrK0s8+zXc2Thaz2cyTAwZf9lr2D4q01JScp7jFZDaz5Lv1lCkXS5Wq1S57L9IkiFCPvUHF3Xw5ycnJCCEoFwan0iW2Qm4Lm5aaisvlov7NV+TQ8qowg9qIRA9B1bIHWLZ8OS+9/Crfff0lv23eyM7ft+V6XPYplPltliylZPeO7dS7uTF9BmpTH6fNW0xEZCSGPJbVGo1GIiIjmTZvcb5TJQvbJZR17QcefoQGjZpcEegFUEr9kgQdq5v3SdZxBiGIDRNEutnCX7ZgLr0fuJdbW93B+j/30+iW24pa1WIzGyBWbUSii6AL9gBRUVF8s2EbC779gVtb3ZHrMTMmTyDdZnPvgkJQv1FjSpfVEuJkZfnr+eTTROb4RYyyWnn4iadYtWl7gWldO3XriamQqxEtYWF55iYpaRGY1erCoBMXF1fgqlWz2UyvXr0u/l0IQblwAzFu5HrfuD6etatXcvzoUZ8OypoExKpMlroJqXz22VMW1K1YkmQ3sgtm0SN/+KGDCbRr1sCtLqGCcoOHGaBCRFB+dvsdPfPZ5yYhIYF69erluntVlsjISHbs2HFxdW12F+yScxl5/54f+fcQ27dspn7Dxj4L9iYB5cNVKoQseuSzD/roIKXk4P59NLmmMh1bNOXYkcNMfuv1QgV60Cd/ePYuoZwt/KwPJSEE1pgYevTuk+fTgkFoU9SU4JSVLycyMvKKFr7JZCIyMpIlS5bkGuhBSwdcLkyQ1x1S+eqq3PvAQz4L9BaDCvTeENTB/ptln1M92sS7r73MuTOnOfR3Atu3bOaDCf/Ls789L3rlD8/qEurRuw/WmBiEMGCNiSGuzzOs27GPv5Mc7Dx2jrETpuTZ/1/Gon5Rgl1Wvpy+ffteXEFrNptxOByMGzeO9u3z7jJMSEhg+KD+1K1YkurRJq6PjeGJB+9n95872Lg+npMnjnvxJ7lchFEFem8Jqtk4OZUuWw4AYTAwa8mXpKWmcmf7e6kwZhSlypRhx2/b3JrnnnMKpacVZ+OHGDUXOWTkzJczfvx4Xn75Ze666y7++usvSpUqRYUKFS47Z+XKlVdk0ExLTeGHlV/zw8qvAahR61p+/P0v7/4wgNUkKG1BKZTCewAACDRJREFUrfL2kqAO9re0aMXna9ZRuWo1KlaqfPH1T79YyYG9e+jX6yG3gn1uUyj9QbjaxCGkDRo0iIYNG2I0GunatSsPPPAAJ0+eZN68eSQnJxMZGUl6enquiwOzCCF4wsv3dtassWi1UbhXBXWwB2h8a/MrXqtSrTpVqlVn2rzF+c6zN2TmDy9oCqUvmASUVcmhQprFYqF169YMHz6cnTt3smfPHoQQF1vwKSkFr+Mwmkzs2bVT76peZDFoOenVxvfeF9R99gXJ6i9/+ImnrpjzHmm10tPNKZTeZhDaXGSVHEoBaNKkCUajEYfD4XZG1iwOu50vFs7Lc/DWU7Ja8xXCVaD3laBv2RfE2xslF5cBbS6ymk+vZImPjy/WE15KcjJXRQjO2yUpeff4FFmkUQv0ahDWt0I+2AcSA1peb5UFUMlu3rx5+fbLF8RqtWIyCMqGCWLMkgseCvphBm2hX7i6X/2CCvYBwpC5ulAFeiUnd3Pn5CbnyltLZtAvZZEk2yHFKbEXYp9bg4BIo8BqQt2rfkYF+wBgzFxdqLpulNxYrVaSCrlIMIvZbGbIkCFXvG4UghIWKIHA7tKSqmW4tBXqLsnFbRCNAkxCYDZog68qwPuvoAv2Aq11EWG8/LWcZM7vM2/gi1/y0p+FaNh4XJhBWx2r+juVvMTFxTFz5sxCDc6aM9Nv5Lfy9uKxBi2Ya9R9GKiCLtgbhNASKoV7dqKRS2qbOme1alwy2xfglFqrx+ECh9T+XhwCbcFUCbNadKLkb9iwYcyZMyffYG80GomIiCA1NRWr1UqvXr0YMmRIgYFeCR5BF+z1kpWJL/+n1EtvSilxSO3R1+4Cu0vr+7QX8CFgEBBlFMSYUa15xS1ZuXNyrpSFy1vw+aVUUIJfSM+z15MQWh97lElQ0qKlm70q0kCVSEH5cEEZi6CURVDCrH2VyZyDXDlCUFp12yiFlFvunJiYGPr27cuOHTtUoFdUy97bDCJz27gibh2nKHnJmTtHUbJTLXtFUZQQoIK9oihKCFDBXlEUJQSoYK8oihICVLBXFEUJASrYK4qihAAV7BVFUUKACvaKoighQAV7RVGUEKCCvaIoSghQwV5RFCUEqGCvKIoSAlSwVxRFCQEq2CuKooQAFewVRVFCgAr2iqIoIUAFe0VRlBCggr2iKEoIUMFeURQlBKhgryiKEgJUsFcURQkBKtgriqKEABXsFUVRQoAK9oqiKCFABXtFUZQQoIK9oihKCFDBXlEUJQSoYK8oihICVLBXFEUJASrYK4qihAAV7BVFUUKACvaKoighQAV7RVGUEKCCvaIoSghQwV5RFCUEqGCvKIoSAlSwVxRFCQEq2CuKooQAFewVRVFCgAr2iqIoIUAFe0VRlBCggr2iKEoIUMFeURQlBKhgryiKEgJUsFcURQkBKtgriqKEABXsFUVRQoAuwV4Ica0Q4j0hxA4hRLIQ4j8hxJdCiPp6lKcoiqLkT6+W/d1Aa2AOcB/QDygHbBJCNNSpTEVRFCUPJp2uuxB4X0ops14QQvwI/AM8CzyiU7mKoihKLnQJ9lLK07m8liiE2AdU0qNMRVEUJW9eG6AVQpQG6gJ/eatMRVEURaNXN05upgACmJTXAUKIvkDfzL8mCyH2FrGsssAVTxeK4iHq/lL0Vpx7rGpuL4ps3ep5EkK0Ab5zo5B1UspWuZz/AjAOeEJK+bEb1ykWIcRWKWUjvctRQpO6vxS96XGPuduy3wBc78ZxqTlfEEI8jRboR3kj0CuKoihXcivYSylTgT2FvbgQohcwDXhXSvlGYc9XFEVRPEO3AVohRGdgNjBTSjlcr3Ly8JGXy1NCi7q/FL15/B5zq8++0BcVogWwBtgFDARc2d5Ol1L+7vFCFUVRlDzpNRvnDiAMuBn4Jcd7h4BqOpWrKIqi5EKXlr2iKIriX4I666VKyKZ4ihCiyv/bu3fQKKIwiuP/I1gYDT7QSpCYRoggChaiQgpNqxZWFoKdRUCrgCC4vrCLpbWFXSJoLFUsF3yAaARRMJHtfISIEgTxs5gNyrCLa3bYce+cHywLd5i5X3V29u6dbyVNSVqU9EXSbUnbyq7L0iDpuKRpSfOSliS9lnRN0mBhc6R8Zy9pnOwhrZvAM2ADMAHsBg5GxNMSy7M+IWkAeA58B84DAVwBBoBdEfGtxPIsAZLqwHvgDtAA9gA1sl2Q+yPiZ/uzO5wj8bDfDHzKNWRbT9aQbSYi3JDN/krSGWAS2BERb5tj24E3wERETJZZn/U/SVsi4kNu7CTZjeqhiHjY7RxJL+NExMfIfZpFxCLghmz2L44A9eWgB4iId2SbD46WVpUlIx/0TY+b74VkVdJh34obstkK7ARethifBUZ6XItVx2jzvZCsqlzY00FDNrOcTcBCi/HPwMYe12IVIGkrcAm4HxFPirhmX4W9pMOSooPXozbnnwNOAON/fiU3M/tfSFpH9kPtD+BUUdftZYvjIrghm5VhgdZ38O3u+M1WRNIaYAYYBkYjolHUtfsq7N2QzUoyS7ZunzcCvOpxLZYoSauBKWAvMBYRL4q8fl8t46xEyQ3ZLA13gX2ShpcHJA0BB5rHzLoiaRVwi6zVzLGIqBc+R+L77N2QzbomaS3ZQ1VL/H6o6jIwSPZQ1dcSy7MESLoBnAauAvdyhxtFLOekHvY14EKbw/MRMdS7aqyfNVsjXAfGyHZzPQDORsRcmXVZGiTN0ebvBIGLEVHreo6Uw97MzDLJr9mbmZnD3sysEhz2ZmYV4LA3M6sAh72ZWQU47M3MKsBhb2ZWAQ57M7MK+AUGFeurd0jjQwAAAABJRU5ErkJggg==\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "train: 1100 loss= 0.1042 val_loss= 0.8696\n",
+      "train: 1200 loss=-0.07648 val_loss= 0.7987\n",
+      "train: 1300 loss=-0.1327 val_loss= 0.5146\n",
+      "train: 1400 loss= 0.01851 val_loss= 1.122\n",
+      "train: 1500 loss=-0.1384 val_loss= 0.267\n",
+      "train: 1600 loss= 1.163 val_loss= 0.8228\n",
+      "train: 1700 loss= 0.002209 val_loss=-0.6582\n",
+      "train: 1800 loss= 0.02812 val_loss=-0.5332\n",
+      "train: 1900 loss= 0.03089 val_loss= 1.108\n",
+      "train: 2000 loss= 0.0444 val_loss= 0.268\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "train: 2100 loss= 0.3157 val_loss= 0.2536\n",
+      "train: 2200 loss=-0.1212 val_loss= 1.005\n",
+      "train: 2300 loss=-0.1426 val_loss=-0.4149\n",
+      "train: 2400 loss= 0.4952 val_loss= 2.515\n",
+      "train: 2500 loss=-0.02337 val_loss= 0.6737\n",
+      "train: 2600 loss=-0.1221 val_loss= 1.173\n",
+      "train: 2700 loss=-0.2397 val_loss= 0.08649\n",
+      "train: 2800 loss=-0.262 val_loss= 2.026\n",
+      "train: 2900 loss= 0.3973 val_loss= 1.033\n",
+      "train: 3000 loss= 0.473 val_loss= 0.3988\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "train: 3100 loss= 0.1286 val_loss= 0.7313\n",
+      "train: 3200 loss= 0.1505 val_loss=-0.4278\n",
+      "train: 3300 loss= 0.1239 val_loss= 0.07454\n",
+      "train: 3400 loss=-0.3603 val_loss=-0.6223\n",
+      "train: 3500 loss= 0.1256 val_loss= 0.1965\n",
+      "train: 3600 loss= 0.1861 val_loss= 0.3888\n",
+      "train: 3700 loss=-0.02808 val_loss=-1.615\n",
+      "train: 3800 loss= 0.002729 val_loss= 0.4251\n",
+      "train: 3900 loss= 0.09646 val_loss=-1.225\n",
+      "train: 4000 loss= 0.08507 val_loss= 0.1615\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "train: 4100 loss= 0.3127 val_loss= 0.002504\n",
+      "train: 4200 loss= 0.183 val_loss= 1.372\n",
+      "train: 4300 loss= 0.4749 val_loss=-0.8027\n",
+      "train: 4400 loss= 0.02496 val_loss= 0.5185\n",
+      "train: 4500 loss=-0.05285 val_loss= 1.298\n",
+      "train: 4600 loss=-0.059 val_loss=-0.7782\n",
+      "train: 4700 loss=-0.3106 val_loss=-0.7015\n",
+      "train: 4800 loss=-0.01025 val_loss= 0.03005\n",
+      "train: 4900 loss=-0.01599 val_loss= 1.313\n",
+      "train: 5000 loss=-0.03248 val_loss= 0.1122\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "train: 5100 loss=-0.1601 val_loss=-0.7915\n",
+      "train: 5200 loss=-0.2264 val_loss= 0.02281\n",
+      "train: 5300 loss= 0.585 val_loss= 0.4562\n",
+      "train: 5400 loss= 0.00639 val_loss= 1.94\n",
+      "train: 5500 loss=-0.2998 val_loss=-0.02642\n",
+      "train: 5600 loss=-0.2697 val_loss= 0.4015\n",
+      "train: 5700 loss=-0.151 val_loss= 2.61\n",
+      "train: 5800 loss=-0.04946 val_loss= 0.03269\n",
+      "train: 5900 loss=-0.1889 val_loss=-0.07903\n",
+      "train: 6000 loss=-0.718 val_loss=-1.348\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "train: 6100 loss=-0.07253 val_loss=-0.06845\n",
+      "train: 6200 loss=-0.2002 val_loss= 0.758\n",
+      "train: 6300 loss=-0.2808 val_loss= 0.2902\n",
+      "train: 6400 loss= 0.1788 val_loss= 0.4741\n",
+      "train: 6500 loss=-0.1916 val_loss=-0.497\n",
+      "train: 6600 loss=-0.4884 val_loss= 0.1198\n",
+      "train: 6700 loss= 0.3179 val_loss=-1.102\n",
+      "train: 6800 loss=-0.2717 val_loss= 0.1815\n",
+      "train: 6900 loss= 0.1442 val_loss= 0.06652\n",
+      "train: 7000 loss=-0.2529 val_loss= 0.2183\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "train: 7100 loss=-0.5139 val_loss=-1.043\n",
+      "train: 7200 loss= 0.1175 val_loss= 0.2555\n",
+      "train: 7300 loss=-0.01821 val_loss=-0.5002\n",
+      "train: 7400 loss=-0.1937 val_loss= 0.7815\n",
+      "train: 7500 loss=-0.2515 val_loss= 1.878\n",
+      "train: 7600 loss=-0.4304 val_loss= 0.2497\n",
+      "train: 7700 loss=-0.4573 val_loss=-0.5104\n",
+      "train: 7800 loss=-0.1097 val_loss=-1.595\n",
+      "train: 7900 loss=-0.169 val_loss=-0.5469\n",
+      "train: 8000 loss=-0.4157 val_loss=-0.652\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "train: 8100 loss= 0.02136 val_loss=-0.3302\n",
+      "train: 8200 loss=-0.242 val_loss= 4.426\n",
+      "train: 8300 loss=-0.2305 val_loss=-0.1257\n",
+      "train: 8400 loss=-0.4046 val_loss= 0.007771\n",
+      "train: 8500 loss=-0.3791 val_loss=-0.5331\n",
+      "train: 8600 loss=-0.3371 val_loss= 0.4644\n",
+      "train: 8700 loss=-0.06009 val_loss= 1.061\n",
+      "train: 8800 loss=-0.01898 val_loss= 0.01321\n",
+      "train: 8900 loss=-0.7999 val_loss=-1.097\n",
+      "train: 9000 loss= 0.2256 val_loss=-0.1066\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "train: 9100 loss=-0.01695 val_loss=-0.6275\n",
+      "train: 9200 loss= 0.1429 val_loss= 0.3768\n",
+      "train: 9300 loss= 0.108 val_loss=-0.2208\n",
+      "train: 9400 loss=-0.4627 val_loss= 0.3817\n",
+      "train: 9500 loss=-0.5703 val_loss=-0.3627\n",
+      "train: 9600 loss=-0.2133 val_loss=-0.5779\n",
+      "train: 9700 loss=-0.5141 val_loss=-0.7667\n",
+      "train: 9800 loss=-0.605 val_loss=-0.194\n",
+      "train: 9900 loss= 0.4604 val_loss= 0.5109\n",
+      "train: 10000 loss= 0.08941 val_loss=-0.4082\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXsAAAENCAYAAADuRcXXAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+17YcXAAAgAElEQVR4nO3deZyNdf/H8df3LLOcWTBRJJEtSnYtJEoLle0mEu1xi+6I6s5P211a7goVbUKJZEtElrK3cEcpOxlLWbOO2efMOZ/fH9cMsy/MmRlzfZ6Px/WYca51zDXvc53vakQEpZRSZZujpC9AKaVU4GnYK6WUDWjYK6WUDWjYK6WUDWjYK6WUDWjYK6WUDWjYK6WUDWjYq/OWMWaPMebmtO8fMMb8UMTHr2KM+doYc8AYI8aYGlnWBxtjJhpjThljDhljhmRZ384Ys80Yk2CMWW6MqV4U+yp1NjTslQKMMa4cXvYDi4Buuez2IlAHqA7cCDxtjGmfdryKwGzgOSAKWAdML6J9lSo8EdFFl/NyAfYANwP1gSTAB8QBJ9PWBwNvAX8Ch4EPgdC0dW2BfcC/gUPA5DzO4wIEqJHl9QPArRn+/TIwLe37fsBPGdaFAYlAvXPdVxddzmbRJ3t13hORrUB/YLWIhItI+bRVrwN1gcZAbaAq8HyGXStjPTlXxwrYAjPGVACqAL9nePl34Mq076/MuE5E4oFo4Mpz2bcw16hURhr2qkwyxhisAH9CRI6LSCzwKnB3hs38wAsikiwiiYU8RXja15gMr8UAERnWx5BZ+vpz2Veps5JTOaVSZUElwAP8YuU+AAZwZtjmiIgkneXx49K+RmIVIaV/H5thfWSWfdLXn8u+Sp0VfbJXZUXW4VuPYpVzXyki5dOWciISnsc+BT+ZyAngINAow8uNgM1p32/OuM4YEwbUAjafy75ne71KadirsuIwcIkxJghARPzAx8BoY8yFAMaYqsaY2wpzUGNMCFZFL0Bw2r/TfQY8a4ypYIypB/QFPk1b9xXQwBjTLW2f54ENIrKtCPZVqtA07FVZsQzryfeQMeZo2mv/BnYCa4wxp4AlwOWFPG4iZ4pdtqX9O90LWBWne4GVwJsisghARI5gNdl8BTgBXEPm+oJz2VepQjMigZm8xBjTHegFNAcuxGr+Nht4Na2yTCmlVDEJZNivwQr4uVjtmZtgdSTZBrRM+5itlFKqGAQy7CulfRzN+Np9wCSgnYgsC8iJlVJKZROwMvusQZ9mbdrXqoE6r1JKqeyKu4K2TdrXrcV8XqWUsrWAFeNkO5ExVYH1wO8icksu2/Qjrdt6aGhos2rVqp3Vufx+Pw6HNjRSgaH3lwq0c7nHduzYcVREKmV9vVjC3hgTDqwALgauFpF9+e3TvHlzWbdu3Vmdb8WKFbRt2/as9lUqP3p/qUA7l3vMGPOLiDTP+nrAh0swxoQC84CaQJuCBL1SSqmiFdCwN8a4gVlYbe1vEZGNgTyfUkqpnAUs7I0xDuBz4CbgThFZE6hzKaWUylsgn+zfA+7C6vIdb4y5NsO6fVqco5RSxSeQTQo6pH0dDqzOsjwSwPMqpZTKImBP9iJSI1DHVkopVTjaWFgppWxAw14ppWxAw14ppWxAw14ppWxAw14ppWxAw14ppWxAw14ppWxAw14ppWxAw14ppWxAw14ppWxAw14ppWxAw14ppWxAw14ppWxAw14ppWxAw14ppWxAw14ppWxAw14ppWxAw14ppWxAw14ppWxAw14ppWxAw14ppWxAw14ppWxAw14ppWxAw14ppWxAw14ppWxAw14ppWxAw14ppWxAw14ppWxAw14ppWxAw14ppWxAw14ppWxAw14ppWxAw14ppWxAw14ppWxAw14ppWxAw14ppWxAw14ppWxAw14ppWxAw14ppWxAw14ppWxAw14ppWxAw14ppWxAw14ppWxAw14ppWxAw14ppWxAw14ppWxAw14ppWxAw14ppWxAw14ppWxAw14ppWxAw14ppWxAw14ppWxAw14ppWxAw14ppWxAw14ppWxAw14ppWxAw14ppWxAw14ppWxAw14ppWxAw14ppWxAw14ppWxAw14ppWxAw14ppWxAw14ppWxAw14ppWxAw14ppWxAw14ppWxAw14ppWxAw14ppWxAw14ppWxAw14pVSZFR0czYMAAIiMjcTgcREZGMmDAAKKjo0v60kqEhr1S6ryyceNG/v3vf3PkyJFct1m4cCENGzZk/PjxxMbGIiLExsYyfvx4GjZsyMKFC4vxiksHV0lfgFJKFcThw4f5448/GDZsGD/88AOTJk3i3nvvJTg4mBEjRgDwzjvvsGPHDj799FMSEhKyHcPr9eL1eunevTsbNmygVq1axf1jlBh9sldKlVrff/89S5cuxefzMXjwYFq3bs3ll1/OTTfdxFNPPcWYMWN45ZVXADh69CjDhg3jyy+/xOv15nlcr9fL6NGji+NHKDX0yV4pVSpFR0fTrl073G43c+fOZe7cubz99tsMGjTo9Da333477733Hn6/H4CBAwfy9ttvk5qamuexvV4vkydPZuzYsQH9GUoTfbJXSpVKYWFhhIeH07RpU2688UZ27dqVKegB6tevz9ixY3E4HFSsWJE333wTn89XoOPHxcUF4rJLLX2yV0qVKuPHj6d9+/ZccsklHD9+HL/fj8PhoHLlyjlu7xfB64dUgVQ/hIWHExcbm+95PJ6wor70Uk3DXilVKjz99NP4fD5GjRpFhQoV2LNnz+lmk+lEhBQ/JPkg2W9975PMx+nSszfTJk0gNZ9y+8SkRNZG76N61YsJcRpCnBDkMIH40QrE6xfiUsHjDMzxNeyVUiXu2LFjzJw5kz179tC6dWsuu+wyIiMjASvgE32Q4LO++iXvY/V9fAhfTv0sz7B3Op34UlP57pt59H74nySmvWM4jRDmMkS4wFUMwe9P+9nivEKSVe1AiDMw5y1zZfaHDx9m2LBhLFiwoKQvRSmVj7/++ot27doxY8YMmjdvTs+ePVm1ahWffvopXr9wPFnYlygcSRbiU/MPeoDqNWvx/pQZhHo8uNzuTOtcbjehHg/DXnmDLxYspUvP3nw7fy7LFn0DWJ8STnmF/YnC0WQ/3oKc8Cwk+YRjycL+BOFo8pmgD6Qy92TvdDpZs2YNffr0Ye/evURERJT0JSmlcvHbb7+xbNkyoqKieOaZZ7j88stJ8gkxXiGpYPWsObrx1g4sWvMb48e8zVfTphAfF4cnLJz2nftwX7/B1KxTi1APLPlmNv1730XDps25qf0dmY4RnwrxqUK4CyoEgcOc2xN3kk9ISLU+oWQteioOZS7sK1SoQMuWLXnrrbeIiIhgxowZPPHEE3z33XdcccUVJX15SqkMOnbsyODBg+nQoQMNmzTlRIqQmHR2SZiSAls3wvqfYesmwx/bavPHtrHExb4HQHwcfPm5tQA4HMJFVW4nPKIVTucdTBnv56omDq5qAhmqCYhLtd54ygdBmKvgge8Xa79EHySWUMBnVObC3ul08sorr3DdddexcOFCevbsSbNmzUhMTERESEhIICzMXrXwSpVmo0aNIjYVDiYKhcnDpERY/T38tMLw68+wcT2kJGcP46AgITgUgoPBGEj1gtdrhf/B/R7gB9avXcL6tXWAZ6hStR/de8P9/YWKF1rHSBU4miycSBFCnYZQJwQ5wGnAGEOq3wpzrx+S/VblsbcYimYKo8yFfUa33XYb7733HrVr16ZZs2a88sorzJkzh+uvv564uDjGjRuHOcePZkqpwtm2bRtdunThgw8+4Po2bTmWLCQXMBgT4mHhXJg3y7B6FSQnZf77rVVXaHI1XNVYqFMf6tSDihdaIZ9VSgoc3Cfs2QUzPvuLb2bvweUey8H9FRnzRhc+HuOg533Qb7BQtZq1j0+sJ/24TH22SviRvYDKXNj7REgV66vT4WDAgAEAJCUlMXHiRHbt2sW6deu47777SvhKlbKPv//+mzFjxnDppZdywQUXsH37dj6bOo1aV7cpUFRu+h0+H2+YNwviYs8k91VNhDY3Q4tWQuNmUK5Cwa8pKAiq17SWa1vfzcWXbGL3zj9YsqA7F1XpweGDrzHpo0NM/+w6nntduOehnN80zhdlrjUOWDX2BxKEmBTBL9atFBISwoIFC5g0aRIXXXQRe/bsOf1Uv3HjRsLDw203VoZSxWHr1q0sXbqUESNGMHXadGKSfXTs3oMBw17IM+hF4Nv50ONWw52tHHzxiSEu1tD0GuG1MX7WRvuZ973w5AtW4Bcm6LMKDg5m+KtvUvFCq9xm1LhHeOvDfQQFdyUpcTnDBznof4/hxLGzP0dJMyKl8yNI8+bNZd26dYXezyfC0uUrufyaGwCrTC3SbQh3nalNFxFOnDhBZGQk7777LmvWrGHmzJnceeedzJs3L8/jiwhesT7O+TMsgrVY38vp1wzgMGAwGKwng4wPB7k9KKQfTyT9uHL63/4M69KPYYz1szqNwe0AtwOCHefegkBlt2LFCtq2bVvSl3FeOBkTQ4cOt5OYnExYeCRxcbHMWvI9QUFBue4jAiu+g1EvGzaut+7fiEihex+450GreCZQThw7xv59f1KuXHlaN6iNw+Gge5+xzP5iLaneWUAcIaHhdO/dm76PD6F6zaIfNfPCEMP/vl951veYMeYXEWme9fUyV4yTlU/gRIpwygsRLgh3W4EYFRXF8OHDefXVV3n00UcZNWoUq1evJjIykri4OMLDw+nTpw9Dhw6lRs2aJKRaNerJPitsCy/Ab6qS7RsA3A6rQinMVbK9A5W97PxzH9t27qZBi+uITUhk8+/rGTvpC+7s1iPP/X5ZA689Z1i32rpXK10k9B8i9LwPws+iFbXTWBWpbodJexhKq1TFegiDMw9pPoHIyhW5sOIFeAV2nfKy8rtF9O3ZNdPAakmJsUyZMIGZUz7jw6kzuPHWDoW/sBJQ5sM+nU/gpFc46QWP0+ol17JVK6pWrUq5cuV49tlnT491DZye6ODTSZN4f8r58wvNyuu3umGf8kKoU6gQZHBr6KsAiU3xcygmnldff4OYE8cZcWUjXhr5LiP+7ymqVL0k9/1OwRsvGCZ/bN2bFaKER4cK9/aFUE/hriHEAaEuq8VMYe/1MKBCkCHJJ2zYvpsB9/bMeQRN8ZKc5OWRu3rw9oTfuLNbrVJfnm+bsM8oIa3rdYM27Zk6bzEdrr86z4kOBvTpwaI1vwXkI1txSvRBUqIQFQTh7lJ+Z6rzSpLPapbY//7e/LRiGRUvqszunTvo9WBfrm7Vmq+W/ZjrvksWwLODDYcOGFwu4Z+Dof8QISKyYOc2QIgTPE5DqMv65H6uQpyGT8eOznd8HZ/Py78eeIcx/x3DP+4ROt0FF+f+nlaiymQFbWF8/P5YUgow0cH4sW8X0xUFlgDHUqzKa6XOVUKqcDjRz+EkIT7Zy+J5czh65G/GfjqVNz+YQMOm2YqOTzt0AB673/BIDweHDhgaNRfm/yA89WLBgj7EARcEGS7xGC4McRDuNkUS9OmmTJmS7yQo4MWYyezYanj9OQet6hvu7mCYPgliThbZpRQJWz7ZZzRn+uf5vnuner3MnDyFipXGkBBv8Putj5Y1agnVa8JltaDCBedXs6yTXsGkVV4rVRgiQoIPYlKsxgoAe3dFM/SfDzJg6DPUqVef2mlL9n1hy0aYO90w+WNITDCEeqwWNQ/0B2c+Iz4aINxliHAXvoimsAo+3n0cH0/3M2ea4bsFsOZ7w5rvDc8NEW7uAF3uFtreajX1LEm2D/v4Av5CkxLjGP1K1g9CZ262iHLCZbWsNrs168DlVwh160ON2uAqpf/LJ1IElwFPIbqAK/vyi9WZKNZr9WXJaPLHH7Bu9Y8MGf4iLdvelG3fndutjlDzZsGuP87cb+07CcNfE6pVz/vcBohwF99olADh4eHEFmBc/LCIcG65A265QzgVA4u+FuZMszp9LZhjWDDHUK6CcEdX6Hq30OzazMMxFJdSGkNFRwSSkyEpARISIDHDkpAAwSHhJCXm/wt1OkPpN1goV15wOCDmhGHPLti7C/ZEQ2yMYcOvsOHX9D2sG9ITJjS7Blq0FK5uBY2bQ0ho4H7ewjqWLGlNNTXwVc68fiHWaw0KlltLtLa3tmf21MnUa9Dw9GsJ8TB3BkwZb9j8+5n764KKwu1doWsvoenV+Z8/3GUo5y6+kE/Xp08fxo8fn2dRjtPlouvdfU7/O7Ic9LgXetwrHNwPX88Uvppm2LbJMHUiTJ1oqFZDuKuP0K03p3vmFocy1c7+77+hcWMhPj4Vv7hISQFvCojkdZMMAMYDeRfl1Lq8Hkt/2ZzjOhE4dsQK/t3RsHO7YccW2L4F9v+Z+dxBQULDZtCiJVzdUriyMVTKpTt3cQl2QOVQ21ffFJhd2tkn+YRTXmu89Zzs/+tPXC4XF1W5mGNHjhBz8gQ169Tlz93w2TjDjMlw6qR1Y0eWF9p3go7dhetuKNin3RAHVAg2JdZkODo6moYNG+bYeCOdMYblv22jRq3aeR5r2yaYM8Mwdzoc3G/S9hWuud562m/fGcqVt7YNVDv7MhX2x45BxYrZXw8KEkI84PFYZe3pi8cDfolmzapG+Hx5/0L7DhpKx249qFK12uledgXx92FY+yOs/cnwvx+tX3rWN5/yUULdelC7HlxSXbj4ErioinWN7iBwu8DvB58ffKng84HfZ31NTbXW+f1Q6SKofhmczWxrUUGGCC2/L5CyHvYpfqtlTW5DDP+5exfValzGoIf6MP/LGbw+9iN63PcQf+2B158zLJhz5h5veo1w/z+tMAsOLtj5ncZq/liYESYDZeHChXTv3j1Ts2wAt9uNMYY3PxhP5569C3w8nw9+WgnTJxm+nX9m4Lag4DPl+z06Gdb/7zwLe2NMNWA0cAtWucYSYLCI/JnfvmcT9n4/7D8orPn5J+pfe50VlO78K32Wf7uQAX164PV6M1XWutxu3G4370+ZQfT2bYwY9iT/eno4Q59/qVDXlVHMSavjyM8/GX5ZDdu2WEVARalGLaFVW2jdzqoYCgnJfx8HcLGnaFszlFVlNex9IpxMsQb6ynG9z8dD3Tuy8rvFtOtwB8HBISxd9A1zV25l7ozqTBhrhVdQsNUE8f5/Clc1Kdw1RLqtIpvS1PM7Ojqa0aNHM3ny5NMdLu+9916eeOIJatSsyZFEPwf+PsoFlSoV6rhW+T6ny/fT3yCjooRBgzbz/PMNzup6iz3sjTEe4HcgGXgWq9XfCMADNBSR+Lz2L6rhEgpq765oxo9Nm+ggNo6wiHC69+rDo48P5rKatdi+dTO3Xn8tLa5ryeS5ixHg6N9/89PKZXS66+5CX2c6ETh8EHZshejtcGCf4cA++PugVdfg9VpFUQ4HOF3WG5fTCQ4nuNK+Op1WMdDB/fDXHvB6M1cc39EVHnxUuPzKvK8lzAUVg7U4Jz9lLex9YpXJx3rPlMlv+HUdVatVR0TwhIXxzVczad/pH/h9Ph7u0Zlm17Zk8P+9xrh3TjLxvShiTlj3XNe7haf/I1SpWrhrCHJYny6DAzQlX6DExMRQv359Dh48yJbDp/Cc5fDpVvk+p8v3x49fy8MPtzirY5VE2A8CRgGXi8jOtNcuA/4AnhaRUXntX9xhny7ECRFpve+yDn98/PhxJk6cyJIlS3jn/Q9p0aQRfr+f5b9t48LKVTh+9ChBwcGEl+DsWKmpsOk3+GEZLJ53ZmwRY4SuveCF/0qeA0ZdFGICNgdmWVFWwj7VL8SmWvOfZqx4/XH5Unp3vBWAkNBQ2tx8G4vnzeHZ10fyQP/HOH7sJCsWV2T0K+Z0+fM11wvPvCw0OYt8Kpf2NH8+Djfu9/tp3bo1//vf//h60XdceV2bcz7m8d2GmKNFX4wTyMe4TsCa9KAHEJHdwI9A5wCet9CCHFDebbg41HBRiAOPy+R440VFRfHWW2+xePFiPhn3Id3+8Q+aNmnCldUv5kD0Nrre1JKpE8eVwE9whstltfh57GmY972wZJ2f+/oJLhfMnmpof6010UNuTmhnqzJNREjyWfOr7k+0KmCztrCJylAckZSYiNebAkCDRk1ZutDFPbdX4ukBDg7uN9S/Svhktp9pCwsf9KFOuDjUUD4o57+384HD4eDbb79l9+7d3H7zjSQe+jPXwQ0LKofuCUUikE0vrwTm5vD6ZuCuAJ63QAzWFGPhLgr10XH+/PlMnz6dZ599FhHh559/5tTRw+zauJ69u6JZu2oZg4cMJdF3Zkiyvbui+fjdUcyZ/jnxcXGEhYfTpWfgRs3LqHY9eGmU8NBAGPwI/LbW0PtO+Hi6cP2N2bdP8VtPejqcwvnNnzavQ6rfmmUpfYykFH/+Q/LVb9CQ7zftpMol1dixdTN16zfiq2lJPD8kmB1brefDajWEoc9ZZfOFaTPuNta4NR5n4f7uSrOwsDA8Hg+NGjViw4YN7PpzH64LqhRocvTiFMhinBRglIg8k+X1EcAzIpLtjcYY0w/oB3DRRRc1mzZt2lmd+1RsHCFh4TlfF1Ztf1G15hIRunbtSkxMDMOHD+eGG25g586dVK9eHYyD//u/YWzZsgXx+/H5zjRvcDqduNxunnv+RVpcc03RXEw+UlMNb4+qy3eLq+B2+3n9zd9pcFVMtu0M1hDJKmfplXQlZf/+/cyYMYMlS5aQmJhIaGgo7W6+mbvu6kGVqlURgf0H9vPljBksW3pmm5va3Uy3Hj24+OKq2Y53KiaG+lnmaE5OdvDtosrMmlmNQwetziEVKybT4+4/uf3OA7jdBcuO9L+5rMN7lzXDhg1j8+bNvPTSSzRq3JjUAryx5sTtsDp7nu09duONNxZ7mX2hwz6joi6zdxmrbDDMVbRlg0ePHqVS2sdev99PamoqNWvW5OjRo3Ts2JGZM2fmuX+ox1Osg6z5/TB8kOGLTwzlo4SvlgmX5dBEuEKQ0aEUclFcZfbR0dGMHDmSKVOmnH6Dad26NcuWLcPn82VqCpix5RiQb+uyudOnsv/PP5n45TxeePJxFs2dzRcLllKl6iWMfPlVTp1sxtqfHuToEeseuKy20P8JocvdBW9CGeSw/ubs0kP7yJEjREVF4Uxr/uf1C4eTCj/R+Pk4nv0JIKeqwKi0dcXCmRby4UUc8ukqVqzI119/TaVKlTDG4PV6GTx4MBMmTODw4cP57p8+yNrLo8YU+bXlxOGAl0cLhw/CskWGB7vB7KVCVJb+Cae8kmnCF1W8cmrfHRsby4IFC3LcPjUt2Pvf0x2DISkpMfdtenUnOTmJmnXq4k1JYe+uaBo2bUF4RD2efWIZ332zDPHvBx7iqibCo0OE2zrl34Q5XbADygUZQstIMU1BVcpQ1xETE8OcOXO45977zirwAyGQH9Y3Y5XbZ3UFsCWA5z0twmVVuka4A1sB1LFjR6699loAPB4PtWvX5sMPP2T9+vX57pvq9fLVtCkBu7acuFww5lPhykbCnmjDkH7W4G4Z+QRi8xvwTwVEdHQ03bt3JyEhoQCjLmaWnJREcnJSntt4vSk0u+Y67vxHD8DBTbc9yQWVFnPb1ZF8Oy8Y8R+hSYvXmTLPz9errKENChL0bmM9lVYOddgu6DPyer1ceeWV9OvXj8S4WC4KsSZOKWmBfLL/GnjLGFNTRHYBGGNqAK2AZ/LY75wZA5VDSq7NbufOVmOjgo6aFx8bh6F456gPC7cqaW9vCSu+NYx7R+j/ROZtTnmFsGIceEpBsk949c2R+Q67nZf8imb9fj9bN22mVdsf6dQG9u3tCoDTKXTofBt9+v5Bq7blCnXO0tgZqqS43W7q1KlD3bp1OXz4MHUiI4nwJxDrCC3RJ/xAPtl/DOwB5hpjOhtjOmG1zvkL+ChQJ3VgPWGUhpr+glawhIQEc2DTWioFG8JdptgqRy++BEZ+ZN19b/3HsHVT5vV+rLHvVWCl+q35BQ4k+DmUJMyYOiXfYbfPVUJ8HO/+17Bvr6FKVWHAk8KqTcIHn5tCBX1688kKQUaDPoMlS5awbNkyLrvsMl5++WXa33IzF4aYEp1AJGBP9iISb4y5CWu4hMlYFfFLsYZLKOhA0YVWmtrrFmTUPIDExET6PvII4eHhvPfeezRt2hRJazqXPrF5Ro4sc2iCtU2qWE0nk3xWE7uCaNcB7u0rTP7Y8PSj8NVyyTRIVZLPesLXytqil9tAYwUddvvchNOtt9Ctl3BN64KXx6dzpY1fY5fK18JKr6RNTEzkhRdesP6d6qVSiJvDSSXzABXQNxoR+VNEuolIpIhEiEgXEdkTyHOWJkOHDsXtdue5jdvtpn79+kydOpX4+HhefPFFFi9ezPXXX88Lzw4nxGn9QWVcQpxWEZXbcWYJdloDR1UIMlQJdVA11FDObQrUxPTfLwlVLxU2rjeMeyf7+hMpQnJpqGEqA/wixHqFA2mzO636/geeH/IvEuLj8fv9fPT2W+f4wGLIr4Gj0+mm14N9GPmR0LJt4YLeYHVArBKqQV8QERERTJgwgfbt27No0SIcPi9/bfo136K2QNDW1AFUq1YtZs2ahcfjyRb6brcbj8fD3Llz2bx5M7Vq1eLUqVNUqlQJv9/PTz/9xGuvvca7775L37592bKlcHXaLofVM7Fq+kfsPLYNj4DXx1o339uvGnZuy77NkWTBV0pHSC1toqOjGTBgAJGRkTgcDiIjI7njjjtYuGwV+xOF4ynCyVNxiAjPDfkXJ08c59efk3hh6A+8/eo4/FlrywshKCiY4HxGvgsKdtP/icGFPnaYyyqyKadFNoXSqVMn5s+fT+fOnWnUqBGtr23BW88+mWmbn1YsY/WqFYG9EBEplUuzZs3kbC1fvvys9w2EnTt3ysCBAyUyMlIcDodERkbKwIEDZefOnZm227Nnj8ybN09OnDghU6dOFaw6WwGkXLly4vf7Zd26dSIi4vf7C3UNXp9fDiT4ZE9c7kvP+/0CIk2u9svOk9nXH0jwia+Q5y2L8rq/FixYIB6PR9xWj6Nsyxvvj5c9cT7p0rO3VLzwUgHEmDCBBIE4gUsFXhbw5Lh/bovL7ZZQj0c+mT1fPpk9X0I9HnFluYaM2+R1H2Rc9sb55JDnPV4AABOTSURBVGiSX1J8+ns/W4cOHZKnn35aBg4cKNOmTZOaNWvKpk2b5ESyX/bE+STamhBaAPnjRJIkpPrPKcOAdZJDppZ4qOe2lKWwPxsbN26USy+9VNq1ayctW7aUFStWSOvWrQWQ0NBQad26dY777d+/P9ubSDq/3y9/J+b+h/37Pp9UvtgK/CHP5rzNvnifJKXa+w8/t/tr586d4vHkHdIul1taXDdOXK5rBJwCfwhslMoX+6VrrxPy6NBlsnJDqnzyZe6BHRISKje1v0PCIyPFGIeER0bKvf0GyMoNO07/nlZu2CH39huQ5zZ5LX/F++Rksl9S9c29yKWkpJz+/miSFfhVq1lv/Ks2/hGwsC/z0xKerxo0aMDevXtJSUkhKG2m4m7duvH999+TmJhIREQEqampuFwufD4fM2fOpGXLljz00EMsXbqUl156ieeeey7TMY0xVAyGo8nWhNFZlStvtc7p3dHwzmuG1u2yD26VKnAoSSjvtjrOqDNGjhyZb2V8aqqXtav7AaeoeOEiuvWuRftOQqNmgsMRCVijJlav2YFFa37LNux217v78Mhjg/PtcV29Zi1eHjWm0J318hr1VRWN9CLdpKQkfli8mNqNr2bkuE9p0LhpQEfM1bAv5YIyTEn/+OOP07JlS6ZMmUKPHj1wpTWbWb58Offccw9NmjRh3rx5NGjQgF9//TXH46UH/uEkITmHouFWN0Lfx4WP3zUMfhi++VEIz+H+O+kVEn3CBcFG569NM2XKlAJ1gnI6Q5n/Yxj1ruyGMbnXg5xtYBdWiBM8TivgtU9F8XnggQeYPn06AJHlyvHLnvx73J8LraA9jxhjaNGiBe+88w6tWrXi1KlTzJgxg7/++gsRISgoiPLly7Nr1y6++uqr0/slJSWxfv162rRpw1NPPYUxhkp59Op78gWh/lXC3l2GF5405FYvm+yHg4nCyRStvE3ySYE70fn9ydRvkH3e4fQB6EKcVmVouMvqdxHpPrOEp48Y6bD6kzjPYnCxIIfVCapSsKGaxxrWO8JtNOiLWYcOHU5/fyomht3bcp7juqjok/15bMOGDfTs2ZN69eqRmJhISForDI/HA8CPP/4IwOeff84HH3wAwKpVq3jzzTdxGkOltCf8rDEdHAzvThTubA1ffm5wOuGVd4ScWpEKEOMVTnkh0s15OwnF2fKL8PPGbVxYozZh4eHExcbmu09YhNXZLtgBIU5DkMMK4IKHbfbtRKzxV9J/l/4M36dzGqt9vJ1+P6XZfffdR1BQEFFRUaxYsYJJ773N51Mmc/RUYPpZaNifx6655ho6dOjADTfckK1pZ3JyMjNmzGDMmDGn2/TWrVuX//znP6e3CXYaooJy7iVbpz68P1kYeB/M+Mxw+KA1nk5kLp0r00M/yQcVg+1RHBDnFTbv/pPrm17F6PGfcVWT3qxeNQ6yTQdyhsvt5p7efajmKdrmi8YYtNn7+cUYQ69evQCoV68e9evXJyIigrDQ0ICcT4txzmNut5sFCxbwzDPPnO6xl27hwoW8++673H///SQnJyMibN++nQoVKtCtW7fTY+uHpxUN5KRdB/higRB1gbDyO0OnGwybN+R9TelFO3HeslusExsXx6FEP8dSBKcriIhyUYwY9h2rVz0J5D3+b5DbzdNDh2g7dZVJ9erV2b9/P6tWrSLEFZhY1rAvo7p06YKI8Mknn5yu5PX5fHz55ZfMnj2bmTNn4vf7EREqBFnlvzlp0sIaQuGKhtYImV1vNHw+gVzL8eHMmDqHk/x4S9t0PecgJjaWNjfdzF133cXvGzbi88EHo/4iNqYdfx/6L+WjatL38ZmEejy4culEN2vWLGrVKp65C9T5pUKFCjRu3Dhgx9ewt5FNmzYxa9YsnnrqKXr27Mk333xD3bp1mTVzJuGksGXj72zfvCnbftVrwuxlwj0PCSnJhuGDHAx6yJAQn/f5knxnKnCllFfg5tTrdcCAAURHRwMQnyqccoZxTZubSE5Kov21jWlYtS0T3/Pj831Bp7sqsWSdMPzVDixe8xv3P9w307H69evHhg0bMlXKKVWscmp8XxoWu3eqCpSMPW8HDRokgDRu3DhTx50Fq3/NtbPNOxN94gmzOl5dfoVflv9WsJ6Ypbkz1oQJE8TlcuXQAcoloaGhckWDhvLk8y/LnjifbPnbK13/8T+BegJIxUrrZMLMMz/n34k+8WpvU3WOAtGpSp/sbSZjS4yWLVuycuVK+vXrl2mbZwb2y7rbaZ17wNcrhVp1he1bDJ3aGJYuzP+86Z2xYktZWf7EiRN5+OGHSU1NzbYuNTWVxMREtmzawKED+1n7E3S83slXs68GltOuw0IW/3wF7TpYrVwuDDFUCnHYonJanX+0NY6N9ejRA7Ba9WzZsoVq1arx+4YNXHxZHeJiYzHG4AkLIz4ujp9/XMWfu3fzwKOPUbsezFkhPPlPWDzP8PBdhju7Cc+8LFxyad7nPJ4iJPuFqFIwmFZ0dHS2N7qcGONgxXcHmTLeejaqdmk8oydcSPPrbgV04g51ftCwVwQHBzNmzJlemrfffgcNqpSnarVLqVGrDtE7tnHowH6CQ0Lo2L0nF1SqREQkfDhVGPeOMGqEYf6Xhu++gWEvC/f3z95hKKP4VGsy5orBlGjv25EjR55ulZQXET/79i7H5RIGDIVb2v7CVdddj8vABcHWkNNKlXZajKOyefzxf2GM4cH+j7Fh/ToaNWtBg8ZNGfrcS4RlmH3LGPjnYFi2XujYXUhOMrz4lIN/PWCIy6dvUYofDpVwE80pUwoz928c838QhjwnBAX5CXNBlVANenX+0Cd7lU379u2tMmxj6NqlC6NHj+SJ4S9Sr8FVgNWE0+l08vfhQyBC1WpVGPOpcFtH4d8Draf8rRvh3U+FKxvmfp70JpoJPqtYp7jKupcvX86KFSsKPLwBQHhEOPUaWH1XXQYqButzkjq/6B2rcuRwOHAYQ9Mr6vDZuA9o07wh5dyGsf8dQf0LIxg+aADXX1GTWZ9/ht/vZ9Hc2Rw6+Dafzz9B3fpC9I5kOl6/mzdeNCQl5X2uRB8cSBROFMMYO16/cNNNN/HSSy8RHJz3JB8Zde3VhxCHNXmH1r+q85GGvcqXMVZxReKxQ7zz+ghSkpMJ9XhISU5m984dbNu8kQH39mTEM0NZ+9NEJs05Tp16A/H7a/P+Wz9w+3WG1avyPodgzXW7P0E4llx00yCm+oX4VGH2wu/4vxH/ZdeJRO7s1oNGzVrQvvM/CnQMp8vF0Cee4KJQbWmjzl9ajKMKLD4+njp16rBlyxbGjxnNwCeHUaN2bWrWrsvo8Z8BQqe7enF/19v5Y9u3AFSIWsiuP1rT63ZDt97CC29kHl9n765oPn53FHOmf058XBxh4eF06dmbvo8P4bKatXA6rAG8rNEdjTXDag55K5LeQN4aEMznh9179nBw/z6WLJjHR2+/BVjNKcdO+oKN6+HtV3cBX5DXWDYAH3zwIY3q1S6K/0KlSk5Oje9Lw6Kdqkqvjz76SDp16iTfLP8+W+epbUfipM0ttwkga6MPyPZjPnliuE+Cgq2OWJdU98vsZda2Zzt93soNO6TPI/0lPCJCjDESHhEhfR7pn2kWpl2nvHJBxUqZjlu+QpSM+fSUXN3KuhYQcTi+EafTIw5n9k5VTqdTJkyYkO3n1/tLBZpOS1hA+sdYfI6nzaOZcbm376Py2FP/J+t2HZTR4ydJ02uukzkrjkiDxlbIOp1+uefh1RISGprnFH6hHk+2afTye4P4R697pXOPXrJ6+97T62rWqSf3PPSV1Kh1JuQjIv3S93G//Lg1+xR+uc0RnE7vLxVoGvYFpH+MxSvO65e/4nMeJqH5da0kIjJSvlzyvfy+L1bqNegnMEcgVMCRZ9gbY8Ttdp9+eu/c4x4JDgnJcx93UJBUuaSajP1smsz/0Sd9+p6UchXOhHzVS/3y3H99svFA5us8mOCTeG/BhjnQ+0sFms5Bq0qlsLQ5S4/lMLfts6+9xSN3debwwQNs+m092zaNA8YV6Lgicnqav7jYWL6e+YX1hJKHVG8qx48k8fyQSI4fdQBWBUHjFkLffwm3dQJXhrve47R6wAZre3lVxmnYqyLhSJvq8GSKEJOho1Tj5lezbvdBABLi49m8YT3tO3Xloe6dyT6XUt7yC3prGz/JySdITj7KhZWFW+6Aux8QrmqSebtgB1QI0pBX9qFhr4pU+SCD22E95WeNZk9YGG+8Px6wOikVZAq/s2L8fL2yNw0aC44sjYudBsq5DRG5DeCvVBml7exVkQtzGaqEWnOr5qZLz97ZJvgoKuER4TRsSqagdwDl3YaLQzXolT1p2KuAcDsMlUMM5XIJ1r6PD8k2b25RcLnddL27T6bX0sexKVcKRtpUqqRo2KuAMcZQPsh6mg7JPEUu1WvW4v0pM3Kcwu9cuN1uHnlsMAChTqgcYqgYrD1fldKwVwHndhguCnFwQZDVAzbdjbd2YNGa3+j1YF/CIyMxxoHL7c40wUpusm7jcrsJ9Xh4f8oMrqhbi8ohhgtDHFoBq1QaDXtVbMLdVll+xgEjq9esxcujxrDpwAl2x3pZ+stmQkJD8zxOSEgonXvec/oNIjwykt4P9uWndb/Tp/PtVAzWkFcqK22No4qV22GoHGo45U2biDzL+vTinQF9euD1eklNa2cP1tO72+3m/SkzuPFWa+Juj9N6EwnVcFcqT/pkr0pEZFrLmHBX9pDOqXgnPDKSXg/2ZdGa3+jQvgNRQYZLPNacrxr0SuVPn+xViXE5DBcEQzm3NVVhgk9ISRuAMr145+VRY3AaCHFCqNOq6HVqixqlCk3DXpU4l8NQLgjKYRARUgXSh7N3OzTclSoKGvaqVDHG4DYQmO5WStmXltkrpZQNaNgrpZQNaNgrpZQNaNgrpZQNaNgrpZQNaNgrpZQNaNgrpZQNaNgrpZQNaNgrpZQNaNgrpZQNaNgrpZQNaNgrpZQNaNgrpZQNaNgrpZQNaNgrpZQNaNgrpZQNaNgrpZQNaNgrpZQNaNgrpZQNaNgrpZQNaNgrpZQNaNgrpZQNaNgrpZQNaNgrpZQNaNgrpZQNaNgrpZQNaNgrpZQNaNgrpZQNaNgrpZQNaNgrpZQNaNgrpZQNaNgrpZQNaNgrpZQNaNgrpZQNaNgrpZQNaNgrpZQNaNgrpZQNaNgrpZQNaNgrpZQNaNgrpZQNaNgrpZQNaNgrpZQNaNgrpZQNaNgrpZQNaNgrpZQNaNgrpZQNaNgrpZQNaNgrpZQNaNgrpZQNaNgrpZQNaNgrpZQNaNgrpZQNaNgrpZQNaNgrpZQNaNgrpZQNaNgrpZQNaNgrpZQNaNgrpZQNaNgrpZQNaNgrpZQNBCTsjTF1jTHvGGM2GGPijDEHjTFfG2MaBeJ8Siml8haoJ/tbgRuBSUBHYABQCVhjjGkWoHMqpZTKhStAx50GvCcikv6CMWYZsAcYBNwXoPMqpZTKQUDCXkSO5vBajDFmB1A1EOdUSimVu2KroDXGRAENgK3FdU6llFKWQBXj5GQMYIC3c9vAGNMP6Jf2zzhjzPazPFdFINunC6WKiN5fKtDO5R6rntOLJkOxeq6MMTcD3xXgJCtFpG0O+w8DXgUeFpGJBTjOOTHGrBOR5oE+j7Invb9UoAXiHivok/1PQP0CbJeQ9QVjTH+soH+2OIJeKaVUdgUKexFJALYV9uDGmHuB94GRIvJKYfdXSilVNAJWQWuM6Qp8AowXkScDdZ5cjCvm8yl70ftLBVqR32MFKrMv9EGNuQH4FtgM/AvwZ1idLCLri/ykSimlchWo1jg3AcFAU+DHLOv2AjUCdF6llFI5CMiTvVJKqdKlTI96qQOyqaJijKlmjJlljIkxxpwyxsw2xlxa0telygZjTHdjzJfGmL3GmERjzHZjzGvGmIgiO0dZfrI3xjyG1UlrEvArUB54GmgMXC8iv5Tg5anzhDHGA/wOJAPPAgKMADxAQxGJL8HLU2WAMWYN8CcwF9gHNAFexGoF2VJE/LnvXcBzlPGwrwgcyzIgWzmsAdnmiYgOyKbyZYwZBIwCLheRnWmvXQb8ATwtIqNK8vrU+c8YU0lEjmR57T6sB9V2IrLsXM9RpotxROSoZHk3E5EYQAdkU4XRCViTHvQAIrIbq/FB5xK7KlVmZA36NGvTvhZJVpXpsM+JDsimzsKVwKYcXt8MXFHM16Lso03a1yLJKtuFPQUYkE2pLKKAEzm8fhyoUMzXomzAGFMVeAlYIiLriuKY51XYG2NuNsZIAZYVuew/DLgHeCzjR3KllCotjDHhWBW1qcCDRXXc4hziuCjogGyqJJwg5yf43J74lTorxphQYB5QE2gjIvuK6tjnVdjrgGyqhGzGKrfP6gpgSzFfiyqjjDFuYBbQHLhFRDYW5fHPq2Kcs1HCA7KpsuFr4FpjTM30F4wxNYBWaeuUOifGGAfwOdZQM11EZE2Rn6OMt7PXAdnUOTPGhGF1qkrkTKeql4EIrE5VcSV4eaoMMMZ8APQHXgHmZ1m9ryiKc8p62L8IvJDL6r0iUqP4rkadz9KGRhgN3ILVmmspMFhE9pTkdamywRizh1ymEwT+IyIvnvM5ynLYK6WUspT5MnullFIa9kopZQsa9kopZQMa9kopZQMa9kopZQMa9kopZQMa9kopZQMa9kopZQP/D/VoKM27wVpEAAAAAElFTkSuQmCC\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "train: 10100 loss=-0.05301 val_loss= 0.3748\n",
+      "train: 10200 loss=-0.3752 val_loss=-0.7454\n",
+      "train: 10300 loss=-0.5065 val_loss=-1.36\n",
+      "train: 10400 loss=-0.1608 val_loss=-0.4235\n",
+      "train: 10500 loss=-0.3573 val_loss=-0.1387\n",
+      "train: 10600 loss=-0.007047 val_loss= 0.7716\n",
+      "train: 10700 loss=-0.002887 val_loss=-0.2827\n",
+      "train: 10800 loss=-0.6093 val_loss= 0.6792\n",
+      "train: 10900 loss=-0.3313 val_loss=-1.244\n",
+      "train: 11000 loss=-0.5322 val_loss= 0.9645\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "train: 11100 loss=-0.7242 val_loss= 0.5701\n",
+      "train: 11200 loss=-0.9163 val_loss= 1.758\n",
+      "train: 11300 loss=-0.7383 val_loss=-0.7432\n",
+      "train: 11400 loss=-0.3554 val_loss= 0.6336\n",
+      "train: 11500 loss=-0.3788 val_loss=-1.637\n",
+      "train: 11600 loss=-0.1507 val_loss= 0.947\n",
+      "train: 11700 loss= 0.2748 val_loss=-0.4106\n",
+      "train: 11800 loss=-0.8627 val_loss=-0.4712\n",
+      "train: 11900 loss=-0.02113 val_loss= 1.296\n",
+      "train: 12000 loss=-0.4049 val_loss= 1.174\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "train: 12100 loss=-0.6371 val_loss= 1.407\n",
+      "train: 12200 loss=-0.7504 val_loss=-1.054\n",
+      "train: 12300 loss=-0.5446 val_loss=-1.731\n",
+      "train: 12400 loss=-0.6009 val_loss=-0.5427\n",
+      "train: 12500 loss=-0.3949 val_loss=-0.9042\n",
+      "train: 12600 loss=-0.4139 val_loss=-0.3413\n",
+      "train: 12700 loss=-0.7882 val_loss= 0.7199\n",
+      "train: 12800 loss=-0.2358 val_loss= 0.4558\n",
+      "train: 12900 loss=-0.133 val_loss= 1.631\n",
+      "train: 13000 loss=-0.8925 val_loss=-0.2054\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "train: 13100 loss=-0.3349 val_loss= 0.6909\n",
+      "train: 13200 loss=-0.3534 val_loss=-0.5158\n",
+      "train: 13300 loss=-0.4553 val_loss= 1.181\n",
+      "train: 13400 loss=-0.2239 val_loss=-0.4758\n",
+      "train: 13500 loss=-0.5028 val_loss= 0.7517\n",
+      "train: 13600 loss=-0.5748 val_loss= 1.059\n",
+      "train: 13700 loss=-0.8389 val_loss= 0.08524\n",
+      "train: 13800 loss=-0.7235 val_loss= 0.2337\n",
+      "train: 13900 loss=-0.6328 val_loss=-0.4903\n",
+      "train: 14000 loss=-0.7552 val_loss= 0.6968\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "train: 14100 loss=-0.513 val_loss=-1.127\n",
+      "train: 14200 loss=-1.21 val_loss=-0.09703\n",
+      "train: 14300 loss=-0.4397 val_loss=-0.8424\n",
+      "train: 14400 loss=-0.7667 val_loss=-0.1598\n",
+      "train: 14500 loss=-0.5753 val_loss=-0.09461\n",
+      "train: 14600 loss=-0.5541 val_loss= 0.8457\n",
+      "train: 14700 loss=-0.2401 val_loss=-1.294\n",
+      "train: 14800 loss=-0.3916 val_loss= 0.8861\n",
+      "train: 14900 loss=-0.5086 val_loss=-0.8828\n",
+      "train: 15000 loss=-0.6116 val_loss=-0.2872\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "train: 15100 loss=-0.3264 val_loss=-0.9836\n",
+      "train: 15200 loss=-0.6587 val_loss=-0.5693\n",
+      "train: 15300 loss=-0.4401 val_loss=-1.634\n",
+      "train: 15400 loss=-0.6585 val_loss= 0.9375\n",
+      "train: 15500 loss=-0.5953 val_loss=-0.9451\n",
+      "train: 15600 loss=-0.7546 val_loss= 0.4929\n",
+      "train: 15700 loss=-0.9229 val_loss= 0.3884\n",
+      "train: 15800 loss=-0.5856 val_loss=-0.2925\n",
+      "train: 15900 loss=-0.2148 val_loss=-0.8883\n",
+      "train: 16000 loss=-0.7017 val_loss=-0.3683\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "train: 16100 loss=-0.461 val_loss= 0.08153\n",
+      "train: 16200 loss=-0.6937 val_loss=-1.902\n",
+      "train: 16300 loss=-0.814 val_loss=-0.2374\n",
+      "train: 16400 loss=-0.5636 val_loss=-1.466\n",
+      "train: 16500 loss= 0.275 val_loss= 1.016\n",
+      "train: 16600 loss=-0.5511 val_loss=-0.8371\n",
+      "train: 16700 loss=-0.7323 val_loss= 0.9235\n",
+      "train: 16800 loss=-0.6481 val_loss=-0.06874\n",
+      "train: 16900 loss= 0.2401 val_loss=-1.002\n",
+      "train: 17000 loss=-0.1661 val_loss=-0.7689\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "train: 17100 loss=-0.4972 val_loss= 2.187\n"
+     ]
+    },
+    {
+     "ename": "KeyboardInterrupt",
+     "evalue": "",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
+      "\u001b[0;32m<ipython-input-49-f98eb86ba395>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m     34\u001b[0m     y_pred, kl, loss, mse_loss, y_std = model(context_x, context_y, target_x,\n\u001b[1;32m     35\u001b[0m                                               target_y)\n\u001b[0;32m---> 36\u001b[0;31m     \u001b[0mloss\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbackward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     37\u001b[0m     \u001b[0moptim\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstep\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     38\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;32m~/.pyenv/versions/3.7.2/envs/jup3.7.2/lib/python3.7/site-packages/torch/tensor.py\u001b[0m in \u001b[0;36mbackward\u001b[0;34m(self, gradient, retain_graph, create_graph)\u001b[0m\n\u001b[1;32m    164\u001b[0m                 \u001b[0mproducts\u001b[0m\u001b[0;34m.\u001b[0m \u001b[0mDefaults\u001b[0m \u001b[0mto\u001b[0m\u001b[0;31m \u001b[0m\u001b[0;31m`\u001b[0m\u001b[0;31m`\u001b[0m\u001b[0;32mFalse\u001b[0m\u001b[0;31m`\u001b[0m\u001b[0;31m`\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    165\u001b[0m         \"\"\"\n\u001b[0;32m--> 166\u001b[0;31m         \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mautograd\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbackward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mgradient\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mretain_graph\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcreate_graph\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    167\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    168\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mregister_hook\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mhook\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;32m~/.pyenv/versions/3.7.2/envs/jup3.7.2/lib/python3.7/site-packages/torch/autograd/__init__.py\u001b[0m in \u001b[0;36mbackward\u001b[0;34m(tensors, grad_tensors, retain_graph, create_graph, grad_variables)\u001b[0m\n\u001b[1;32m     97\u001b[0m     Variable._execution_engine.run_backward(\n\u001b[1;32m     98\u001b[0m         \u001b[0mtensors\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mgrad_tensors\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mretain_graph\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcreate_graph\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 99\u001b[0;31m         allow_unreachable=True)  # allow_unreachable flag\n\u001b[0m\u001b[1;32m    100\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    101\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
+     ]
+    }
+   ],
+   "source": [
+    "\n",
+    "\n",
+    "writer = SummaryWriter(comment='-anp_1d_reg')\n",
+    "print(writer.logdir)\n",
+    "\n",
+    "hparams = dict(\n",
+    "    x_dim=1,\n",
+    "    y_dim=1,\n",
+    "    hidden_dim=128,\n",
+    "    latent_dim=128,\n",
+    "    latent_enc_self_attn_type=\"multihead\",\n",
+    "    det_enc_self_attn_type=\"multihead\",\n",
+    "    det_enc_cross_attn_type=\"multihead\")\n",
+    "model = LatentModel(**hparams).cuda()\n",
+    "\n",
+    "optim = torch.optim.Adam(model.parameters(), lr=1e-4)\n",
+    "\n",
+    "for n_iter in tqdm(range(epochs)):\n",
+    "    model.train()\n",
+    "\n",
+    "    data_train = dataset_train.generate_curves()\n",
+    "\n",
+    "    (context_x, context_y), target_x = data_train.query\n",
+    "    target_y = data_train.target_y\n",
+    "\n",
+    "    context_x = context_x.cuda()\n",
+    "    context_y = context_y.cuda()\n",
+    "    target_x = target_x.cuda()\n",
+    "    target_y = target_y.cuda()\n",
+    "\n",
+    "    optim.zero_grad()\n",
+    "    y_pred, kl, loss, mse_loss, y_std = model(context_x, context_y, target_x,\n",
+    "                                              target_y)\n",
+    "    loss.backward()\n",
+    "    optim.step()\n",
+    "\n",
+    "    writer.add_scalar('train/loss', loss, n_iter)\n",
+    "    writer.add_scalar('train/mse_loss', mse_loss, n_iter)\n",
+    "    writer.add_scalar('train/y_std', y_std.mean(), n_iter)\n",
+    "    writer.add_scalar('train/kl', kl.mean(), n_iter)\n",
+    "\n",
+    "    if n_iter % PRINT_AFTER == 0:\n",
+    "        y_pred, kl, val_loss, y_std = test(\n",
+    "            model, dataset_test, writer, plot=False, global_step=n_iter)\n",
+    "        print(\n",
+    "            f\"train: {n_iter} loss={loss.item(): 4.4g} val_loss={val_loss.item(): 4.4g}\"\n",
+    "        )\n",
+    "\n",
+    "    if n_iter % PLOT_AFTER == 0:\n",
+    "        test(model, dataset_test, writer, plot=True, global_step=n_iter)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 50,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2020-02-01T05:07:42.329572Z",
+     "start_time": "2020-02-01T05:07:40.964521Z"
+    },
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -1010,35 +1713,191 @@
     }
    ],
    "source": [
-    "epochs = 100000\n",
-    "PLOT_AFTER = 10000\n",
-    "PRINT_AFTER = 1000\n",
+    "for i in range(5):\n",
+    "    set_seed(i)\n",
+    "    test(model, dataset_test, writer, plot=True, global_step=i)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 51,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2020-02-01T05:07:48.898112Z",
+     "start_time": "2020-02-01T05:07:42.333019Z"
+    },
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "e796d265654f4679b0d9bd53d71997db",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "HBox(children=(FloatProgress(value=0.0), HTML(value='')))"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "val loss (n=100) tensor(-0.3734)\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Final validation\n",
+    "loss = torch.stack([test(model, dataset_test)[2] for _ in tqdm(range(100))]).mean().cpu()\n",
+    "print('val loss (n=100)', loss)\n",
+    "writer.add_hparams(hparams, dict(val_loss=loss))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2020-02-01T03:26:03.797075Z",
+     "start_time": "2020-02-01T03:19:32.800Z"
+    }
+   },
+   "source": [
+    "## Improved\n",
+    "\n",
+    "These have no been extensively tested:\n",
+    "\n",
+    "- use torches ~50% faster multiheaded attention\n",
+    "- calc loss in log domain for stability (and untested changes to clipping)\n",
+    "- dropout"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2020-02-01T04:20:15.678601Z",
+     "start_time": "2020-02-01T04:20:15.671286Z"
+    }
+   },
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "ExecuteTime": {
+     "start_time": "2020-02-01T05:07:42.600Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "runs/Feb01_13-07-48_mjcdesktop-anp_1d_impr\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "9a665278d4ee4a69bd1b2811a16e1ea3",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "HBox(children=(FloatProgress(value=0.0, max=100000.0), HTML(value='')))"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "train: 0 loss= 1.559 val_loss= 1.574\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "train: 100 loss= 1.02 val_loss= 0.8722\n"
+     ]
+    }
+   ],
+   "source": [
+    "writer = SummaryWriter(comment='-anp_1d_impr')\n",
+    "print(writer.logdir)\n",
+    "                 \n",
+    "hparams = dict(\n",
+    "    x_dim=1,\n",
+    "    y_dim=1,\n",
+    "    hidden_dim=128,\n",
+    "    latent_dim=128,\n",
+    "    latent_enc_self_attn_type=\"ptmultihead\",\n",
+    "    det_enc_self_attn_type=\"ptmultihead\",\n",
+    "    det_enc_cross_attn_type=\"ptmultihead\",\n",
+    "    use_lvar=True,\n",
+    "    use_self_attn=True,\n",
+    "#     attention_dropout=0.3,\n",
+    "    dropout=0.3,\n",
+    "#     batchnorm=True,\n",
+    ")\n",
+    "model = LatentModel(**hparams).cuda()\n",
+    "\n",
+    "optim = torch.optim.Adam(model.parameters(), lr=1e-4)\n",
+    "\n",
     "for n_iter in tqdm(range(epochs)):\n",
     "    model.train()\n",
-    "    \n",
+    "\n",
     "    data_train = dataset_train.generate_curves()\n",
-    "    \n",
+    "\n",
     "    (context_x, context_y), target_x = data_train.query\n",
     "    target_y = data_train.target_y\n",
-    "    \n",
+    "\n",
     "    context_x = context_x.cuda()\n",
     "    context_y = context_y.cuda()\n",
     "    target_x = target_x.cuda()\n",
     "    target_y = target_y.cuda()\n",
     "\n",
     "    optim.zero_grad()\n",
-    "    y_pred, kl, loss, mse_loss, y_std = model(context_x, context_y, target_x, target_y)    \n",
+    "    y_pred, kl, loss, mse_loss, y_std = model(context_x, context_y, target_x,\n",
+    "                                              target_y)\n",
     "    loss.backward()\n",
     "    optim.step()\n",
-    "    \n",
+    "\n",
     "    writer.add_scalar('train/loss', loss, n_iter)\n",
     "    writer.add_scalar('train/mse_loss', mse_loss, n_iter)\n",
     "    writer.add_scalar('train/y_std', y_std.mean(), n_iter)\n",
     "    writer.add_scalar('train/kl', kl.mean(), n_iter)\n",
-    "    \n",
+    "\n",
     "    if n_iter % PRINT_AFTER == 0:\n",
-    "        y_pred, kl, val_loss, y_std = test(model, dataset_test, writer, plot=False, global_step=n_iter)\n",
-    "        print(f\"train: {n_iter} loss={loss.item(): 4.4g} val_loss={val_loss.item(): 4.4g}\")\n",
+    "        y_pred, kl, val_loss, y_std = test(\n",
+    "            model, dataset_test, writer, plot=False, global_step=n_iter)\n",
+    "        print(\n",
+    "            f\"train: {n_iter} loss={loss.item(): 4.4g} val_loss={val_loss.item(): 4.4g}\"\n",
+    "        )\n",
     "\n",
     "    if n_iter % PLOT_AFTER == 0:\n",
     "        test(model, dataset_test, writer, plot=True, global_step=n_iter)"
@@ -1049,19 +1908,15 @@
    "execution_count": null,
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2020-02-01T03:19:26.014782Z",
-     "start_time": "2020-02-01T03:11:00.300Z"
+     "start_time": "2020-02-01T05:07:42.800Z"
     },
     "scrolled": true
    },
    "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
    "source": [
-    "# Test"
+    "for i in range(5):\n",
+    "    set_seed(i)\n",
+    "    test(model, dataset_test, writer, plot=True, global_step=i)"
    ]
   },
   {
@@ -1069,14 +1924,15 @@
    "execution_count": null,
    "metadata": {
     "ExecuteTime": {
-     "start_time": "2020-02-01T03:19:32.800Z"
+     "start_time": "2020-02-01T05:07:42.900Z"
     }
    },
    "outputs": [],
    "source": [
     "# Final validation\n",
     "loss = torch.stack([test(model, dataset_test)[2] for _ in tqdm(range(100))]).mean().cpu()\n",
-    "print(loss)"
+    "print('val loss (n=100)', loss)\n",
+    "writer.add_hparams(hparams, dict(val_loss=loss))"
    ]
   },
   {
@@ -1084,14 +1940,21 @@
    "execution_count": null,
    "metadata": {
     "ExecuteTime": {
-     "start_time": "2020-02-01T03:19:32.800Z"
+     "start_time": "2020-02-01T05:07:43.000Z"
     }
    },
    "outputs": [],
    "source": [
-    "writer.add_hparams(hparams, dict(val_loss=loss))"
+    "(hparams, dict(val_loss=loss))"
    ]
   },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
   {
    "cell_type": "code",
    "execution_count": null,
@@ -1110,12 +1973,17 @@
    "base_numbering": 1,
    "nav_menu": {},
    "number_sections": true,
-   "sideBar": false,
+   "sideBar": true,
    "skip_h1_title": false,
    "title_cell": "Table of Contents",
    "title_sidebar": "Contents",
    "toc_cell": false,
-   "toc_position": {},
+   "toc_position": {
+    "height": "calc(100% - 180px)",
+    "left": "10px",
+    "top": "150px",
+    "width": "384px"
+   },
    "toc_section_display": true,
    "toc_window_display": true
   }