From 9ffe936043aa52e87fbc28bf7444efed13da8b5e Mon Sep 17 00:00:00 2001 From: wassname Date: Thu, 18 Jan 2024 18:59:57 +0800 Subject: [PATCH] 0.78 ood auroc? --- notebooks/12_tae.ipynb | 1147 ++++++++++++++++++++++++++++------------ research_log.md | 8 + 2 files changed, 821 insertions(+), 334 deletions(-) diff --git a/notebooks/12_tae.ipynb b/notebooks/12_tae.ipynb index 74007a0..83e1ef1 100644 --- a/notebooks/12_tae.ipynb +++ b/notebooks/12_tae.ipynb @@ -127,7 +127,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 338, "metadata": {}, "outputs": [], "source": [ @@ -144,7 +144,7 @@ "DECIMATE = 1 # discard N features for speed\n", "\n", "device = \"cuda:0\"\n", - "max_epochs = 84\n", + "max_epochs = 840\n", "\n", "l1_coeff = 1e-2 # 0.5 # neel uses 3e-4 ! https://github.dev/neelnanda-io/1L-Sparse-Autoencoder/blob/bcae01328a2f41d24bd4a9160828f2fc22737f75/utils.py#L106, but them they sum l1 where mean l2\n", "# x_feats=x_feats. other use 1e-1\n", @@ -647,7 +647,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 339, "metadata": {}, "outputs": [], "source": [ @@ -673,7 +673,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 340, "metadata": {}, "outputs": [ { @@ -692,7 +692,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 438, "metadata": {}, "outputs": [], "source": [ @@ -710,7 +710,8 @@ "# encoder=Encoder(config=coder_cfg)\n", "# decoder=Decoder(config=coder_cfg)\n", "\n", - "from src.vae.sae2 import AutoEncoderConfig, Encoder, Decoder, Affines\n" + "from src.vae.sae2 import AutoEncoderConfig, Encoder, Decoder, Affines\n", + "from einops import reduce" ] }, { @@ -722,7 +723,7 @@ }, { "cell_type": "code", - "execution_count": 289, + "execution_count": 481, "metadata": {}, "outputs": [], "source": [ @@ -739,6 +740,7 @@ " encoder_sizes=[32, ],\n", " importance_matrix=None,\n", " tokens_per_layer=6,\n", + " probe_embedd_dim=3,\n", " **kwargs,\n", " ):\n", " super().__init__(\n", @@ -781,16 +783,16 @@ " decoder=decoder,\n", " )\n", "\n", - " embed_dim2 = 16\n", - " self.probe_embed = nn.Embedding(vocab_size, embed_dim2, max_norm=1.0)\n", - " n = embed_dim2 * n_layers * tokens_per_layer\n", + " self.probe_embed = nn.Embedding(vocab_size, probe_embedd_dim, \n", + " max_norm=1.0\n", + " )\n", + " n = n_layers * tokens_per_layer * probe_embedd_dim\n", " # self.probe_embed.weight.data.uniform_(-1.0 / vocab_size, 1.0 / vocab_size)\n", "\n", " self.head = nn.Sequential(\n", - " nn.BatchNorm1d(n),\n", - " LinBnDrop(n, n, bn=True, dropout=dropout),\n", + " # LinBnDrop(n*embed_dim2, n, bn=True, dropout=dropout),\n", " # LinBnDrop(n, n, bn=True, dropout=dropout),\n", - " # LinBnDrop(n, n // 4, dropout=dropout, bn=False),\n", + " # LinBnDrop(n, n, dropout=dropout, bn=False),\n", " # LinBnDrop(n // 4, n // 12, bn=False),\n", " nn.Linear(n, 1),\n", " )\n", @@ -822,9 +824,10 @@ "\n", " # we want a probe tokenizer. reusing the decoder hurts performance\n", " latent = self.probe_embed(tokens)\n", + " pred = reduce(latent, \"b l h v -> b\", \"max\")\n", "\n", - " latent2 = rearrange(latent, \"b l h v -> b (l h v)\")\n", - " pred = self.head(latent2).squeeze(1)\n", + " # latent2 = rearrange(latent, \"b l h v -> b (l h v)\")\n", + " # pred = self.head(latent2).squeeze(1)\n", " return dict(\n", " pred=pred,\n", " loss=loss,\n", @@ -927,7 +930,7 @@ }, { "cell_type": "code", - "execution_count": 297, + "execution_count": 482, "metadata": {}, "outputs": [ { @@ -958,7 +961,7 @@ }, { "cell_type": "code", - "execution_count": 298, + "execution_count": 533, "metadata": {}, "outputs": [ { @@ -976,22 +979,34 @@ " (encoder): Sequential(\n", " (0): NormedLinears(\n", " (linears): ModuleList(\n", - " (0-4): 5 x NormedLinear(in_features=17920, out_features=96, bias=False)\n", + " (0-4): 5 x NormedLinear(in_features=17920, out_features=64, bias=False)\n", " )\n", " (act): ReLU()\n", " )\n", " (1): NormedLinears(\n", " (linears): ModuleList(\n", - " (0-4): 5 x NormedLinear(in_features=96, out_features=64, bias=False)\n", + " (0-4): 5 x NormedLinear(in_features=64, out_features=64, bias=False)\n", " )\n", " (act): ReLU()\n", " )\n", - " (2): Rearrange('b l f -> b (l f)')\n", - " (3): Linear(in_features=320, out_features=320, bias=True)\n", - " (4): Rearrange('b (l f) -> b l f', l=5)\n", - " (5): NormedLinears(\n", + " (2): NormedLinears(\n", " (linears): ModuleList(\n", - " (0-4): 5 x NormedLinear(in_features=64, out_features=8192, bias=True)\n", + " (0-4): 5 x NormedLinear(in_features=64, out_features=64, bias=True)\n", + " )\n", + " (act): ReLU()\n", + " )\n", + " (3): NormedLinears(\n", + " (linears): ModuleList(\n", + " (0-4): 5 x NormedLinear(in_features=64, out_features=64, bias=True)\n", + " )\n", + " (act): ReLU()\n", + " )\n", + " (4): Rearrange('b l f -> b (l f)')\n", + " (5): Linear(in_features=320, out_features=320, bias=True)\n", + " (6): Rearrange('b (l f) -> b l f', l=5)\n", + " (7): NormedLinears(\n", + " (linears): ModuleList(\n", + " (0-4): 5 x NormedLinear(in_features=64, out_features=3072, bias=True)\n", " )\n", " )\n", " )\n", @@ -1001,36 +1016,42 @@ " (decoder): Sequential(\n", " (0): NormedLinears(\n", " (linears): ModuleList(\n", - " (0-4): 5 x NormedLinear(in_features=8192, out_features=64, bias=True)\n", + " (0-4): 5 x NormedLinear(in_features=3072, out_features=64, bias=True)\n", " )\n", " (act): ReLU()\n", " )\n", " (1): NormedLinears(\n", " (linears): ModuleList(\n", - " (0-4): 5 x NormedLinear(in_features=64, out_features=96, bias=True)\n", + " (0-4): 5 x NormedLinear(in_features=64, out_features=64, bias=True)\n", " )\n", " (act): ReLU()\n", " )\n", - " (2): Rearrange('b l f -> b (l f)')\n", - " (3): Linear(in_features=480, out_features=480, bias=True)\n", - " (4): Rearrange('b (l f) -> b l f', l=5)\n", - " (5): NormedLinears(\n", + " (2): NormedLinears(\n", " (linears): ModuleList(\n", - " (0-4): 5 x NormedLinear(in_features=96, out_features=17920, bias=True)\n", + " (0-4): 5 x NormedLinear(in_features=64, out_features=64, bias=True)\n", + " )\n", + " (act): ReLU()\n", + " )\n", + " (3): NormedLinears(\n", + " (linears): ModuleList(\n", + " (0-4): 5 x NormedLinear(in_features=64, out_features=64, bias=True)\n", + " )\n", + " (act): ReLU()\n", + " )\n", + " (4): Rearrange('b l f -> b (l f)')\n", + " (5): Linear(in_features=320, out_features=320, bias=True)\n", + " (6): Rearrange('b (l f) -> b l f', l=5)\n", + " (7): NormedLinears(\n", + " (linears): ModuleList(\n", + " (0-4): 5 x NormedLinear(in_features=64, out_features=17920, bias=True)\n", " )\n", " )\n", " )\n", " )\n", " )\n", - " (probe_embed): Embedding(512, 16, max_norm=1.0)\n", + " (probe_embed): Embedding(512, 512, max_norm=1.0)\n", " (head): Sequential(\n", - " (0): BatchNorm1d(1280, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (1): LinBnDrop(\n", - " (lin): Linear(in_features=1280, out_features=1280, bias=True)\n", - " (bn): BatchNorm1d(1280, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (act): ReLU()\n", - " )\n", - " (2): Linear(in_features=1280, out_features=1, bias=True)\n", + " (0): Linear(in_features=15360, out_features=1, bias=True)\n", " )\n", ")\n" ] @@ -1042,19 +1063,20 @@ " steps_per_epoch=len(dl_train),\n", " max_epochs=max_epochs,\n", " lr=lr,\n", - " dropout=0.3,\n", - " encoder_sizes=[96,64],\n", + " dropout=0.2,\n", + " encoder_sizes=[64,64, 64, 64],\n", " weight_decay=wd,\n", " n_latent=512, # there will be layers * n_latent latent features\n", " importance_matrix=importance_matrix,\n", - " tokens_per_layer=16\n", + " tokens_per_layer=6,\n", + " probe_embedd_dim=512,\n", ")\n", "print(net)" ] }, { "cell_type": "code", - "execution_count": 299, + "execution_count": 534, "metadata": {}, "outputs": [ { @@ -1076,7 +1098,7 @@ }, { "cell_type": "code", - "execution_count": 300, + "execution_count": 535, "metadata": {}, "outputs": [ { @@ -1094,85 +1116,110 @@ "│ │ └─AffineInstanceNorm1d: 3-4 [32, 17920] [32, 17920] --\n", "│ │ └─AffineInstanceNorm1d: 3-5 [32, 17920] [32, 17920] --\n", "├─Tokenizer: 1-2 -- -- (recursive)\n", - "│ └─Encoder: 2-2 [32, 5, 17920] [32, 5, 8192] 2,795,840\n", - "│ │ └─Sequential: 3-16 -- -- (recursive)\n", - "│ │ │ └─NormedLinears: 4-1 [32, 5, 17920] [32, 5, 96] 8,601,600\n", - "│ └─Decoder: 2-12 -- -- (recursive)\n", - "│ │ └─Sequential: 3-17 -- -- (recursive)\n", - "│ │ │ └─NormedLinears: 4-25 -- -- (recursive)\n", - "│ └─Encoder: 2-13 -- -- (recursive)\n", - "│ │ └─Sequential: 3-16 -- -- (recursive)\n", - "│ │ │ └─NormedLinears: 4-3 [32, 5, 96] [32, 5, 64] 30,720\n", - "│ └─Decoder: 2-12 -- -- (recursive)\n", - "│ │ └─Sequential: 3-17 -- -- (recursive)\n", - "│ │ │ └─NormedLinears: 4-25 -- -- (recursive)\n", - "│ └─Encoder: 2-13 -- -- (recursive)\n", - "│ │ └─Sequential: 3-16 -- -- (recursive)\n", - "│ │ │ └─Rearrange: 4-5 [32, 5, 64] [32, 320] --\n", - "│ │ │ └─Linear: 4-6 [32, 320] [32, 320] 102,720\n", - "│ │ │ └─Rearrange: 4-7 [32, 320] [32, 5, 64] --\n", - "│ │ │ └─NormedLinears: 4-8 [32, 5, 64] [32, 5, 8192] 2,662,400\n", - "│ └─Embedding: 2-7 [2560] [2560, 512] 262,144\n", - "│ └─Decoder: 2-8 [32, 5, 8192] [32, 5, 17920] --\n", - "│ │ └─Sequential: 3-17 -- -- (recursive)\n", - "│ │ │ └─NormedLinears: 4-9 [32, 5, 8192] [32, 5, 64] 2,621,760\n", - "│ │ │ └─NormedLinears: 4-25 -- -- (recursive)\n", - "│ │ │ └─NormedLinears: 4-11 [32, 5, 64] [32, 5, 96] 31,200\n", - "│ │ │ └─Rearrange: 4-12 [32, 5, 96] [32, 480] --\n", - "│ │ │ └─Linear: 4-13 [32, 480] [32, 480] 230,880\n", - "│ │ │ └─Rearrange: 4-14 [32, 480] [32, 5, 96] --\n", - "│ │ │ └─NormedLinears: 4-15 [32, 5, 96] [32, 5, 17920] 8,691,200\n", - "├─Tokenizer: 1-3 [32, 5, 17920] [32, 5, 512, 16] 23,234,624\n", - "│ └─Encoder: 2-9 [32, 5, 17920] [32, 5, 8192] (recursive)\n", - "│ │ └─Sequential: 3-16 -- -- (recursive)\n", - "│ │ │ └─NormedLinears: 4-16 [32, 5, 17920] [32, 5, 96] (recursive)\n", - "│ └─Decoder: 2-12 -- -- (recursive)\n", - "│ │ └─Sequential: 3-17 -- -- (recursive)\n", - "│ │ │ └─NormedLinears: 4-25 -- -- (recursive)\n", - "│ └─Encoder: 2-13 -- -- (recursive)\n", - "│ │ └─Sequential: 3-16 -- -- (recursive)\n", - "│ │ │ └─NormedLinears: 4-18 [32, 5, 96] [32, 5, 64] (recursive)\n", - "│ └─Decoder: 2-12 -- -- (recursive)\n", - "│ │ └─Sequential: 3-17 -- -- (recursive)\n", - "│ │ │ └─NormedLinears: 4-25 -- -- (recursive)\n", - "│ └─Encoder: 2-13 -- -- (recursive)\n", - "│ │ └─Sequential: 3-16 -- -- (recursive)\n", + "│ └─Encoder: 2-2 [32, 5, 17920] [32, 5, 3072] 1,163,200\n", + "│ │ └─Sequential: 3-24 -- -- (recursive)\n", + "│ │ │ └─NormedLinears: 4-1 [32, 5, 17920] [32, 5, 64] 5,734,400\n", + "│ └─Decoder: 2-20 -- -- (recursive)\n", + "│ │ └─Sequential: 3-25 -- -- (recursive)\n", + "│ │ │ └─NormedLinears: 4-41 -- -- (recursive)\n", + "│ └─Encoder: 2-21 -- -- (recursive)\n", + "│ │ └─Sequential: 3-24 -- -- (recursive)\n", + "│ │ │ └─NormedLinears: 4-3 [32, 5, 64] [32, 5, 64] 20,480\n", + "│ └─Decoder: 2-20 -- -- (recursive)\n", + "│ │ └─Sequential: 3-25 -- -- (recursive)\n", + "│ │ │ └─NormedLinears: 4-41 -- -- (recursive)\n", + "│ └─Encoder: 2-21 -- -- (recursive)\n", + "│ │ └─Sequential: 3-24 -- -- (recursive)\n", + "│ │ │ └─NormedLinears: 4-5 [32, 5, 64] [32, 5, 64] 20,800\n", + "│ └─Decoder: 2-20 -- -- (recursive)\n", + "│ │ └─Sequential: 3-25 -- -- (recursive)\n", + "│ │ │ └─NormedLinears: 4-41 -- -- (recursive)\n", + "│ └─Encoder: 2-21 -- -- (recursive)\n", + "│ │ └─Sequential: 3-24 -- -- (recursive)\n", + "│ │ │ └─NormedLinears: 4-7 [32, 5, 64] [32, 5, 64] 20,800\n", + "│ └─Decoder: 2-20 -- -- (recursive)\n", + "│ │ └─Sequential: 3-25 -- -- (recursive)\n", + "│ │ │ └─NormedLinears: 4-41 -- -- (recursive)\n", + "│ └─Encoder: 2-21 -- -- (recursive)\n", + "│ │ └─Sequential: 3-24 -- -- (recursive)\n", + "│ │ │ └─Rearrange: 4-9 [32, 5, 64] [32, 320] --\n", + "│ │ │ └─Linear: 4-10 [32, 320] [32, 320] 102,720\n", + "│ │ │ └─Rearrange: 4-11 [32, 320] [32, 5, 64] --\n", + "│ │ │ └─NormedLinears: 4-12 [32, 5, 64] [32, 5, 3072] 998,400\n", + "│ └─Embedding: 2-11 [960] [960, 512] 262,144\n", + "│ └─Decoder: 2-12 [32, 5, 3072] [32, 5, 17920] --\n", + "│ │ └─Sequential: 3-25 -- -- (recursive)\n", + "│ │ │ └─NormedLinears: 4-13 [32, 5, 3072] [32, 5, 64] 983,360\n", + "│ │ │ └─NormedLinears: 4-41 -- -- (recursive)\n", + "│ │ │ └─NormedLinears: 4-15 [32, 5, 64] [32, 5, 64] 20,800\n", + "│ │ │ └─NormedLinears: 4-41 -- -- (recursive)\n", + "│ │ │ └─NormedLinears: 4-17 [32, 5, 64] [32, 5, 64] 20,800\n", + "│ │ │ └─NormedLinears: 4-41 -- -- (recursive)\n", + "│ │ │ └─NormedLinears: 4-19 [32, 5, 64] [32, 5, 64] 20,800\n", "│ │ │ └─Rearrange: 4-20 [32, 5, 64] [32, 320] --\n", - "│ │ │ └─Linear: 4-21 [32, 320] [32, 320] (recursive)\n", + "│ │ │ └─Linear: 4-21 [32, 320] [32, 320] 102,720\n", "│ │ │ └─Rearrange: 4-22 [32, 320] [32, 5, 64] --\n", - "│ │ │ └─NormedLinears: 4-23 [32, 5, 64] [32, 5, 8192] (recursive)\n", - "│ └─Embedding: 2-14 [2560] [2560, 512] (recursive)\n", - "│ └─Decoder: 2-15 [32, 5, 8192] [32, 5, 17920] (recursive)\n", - "│ │ └─Sequential: 3-17 -- -- (recursive)\n", - "│ │ │ └─NormedLinears: 4-24 [32, 5, 8192] [32, 5, 64] (recursive)\n", - "│ │ │ └─NormedLinears: 4-25 -- -- (recursive)\n", - "│ │ │ └─NormedLinears: 4-26 [32, 5, 64] [32, 5, 96] (recursive)\n", - "│ │ │ └─Rearrange: 4-27 [32, 5, 96] [32, 480] --\n", - "│ │ │ └─Linear: 4-28 [32, 480] [32, 480] (recursive)\n", - "│ │ │ └─Rearrange: 4-29 [32, 480] [32, 5, 96] --\n", - "│ │ │ └─NormedLinears: 4-30 [32, 5, 96] [32, 5, 17920] (recursive)\n", - "├─Embedding: 1-4 [32, 5, 16] [32, 5, 16, 16] 8,192\n", - "├─Sequential: 1-5 [32, 1280] [32, 1] --\n", - "│ └─BatchNorm1d: 2-16 [32, 1280] [32, 1280] 2,560\n", - "│ └─LinBnDrop: 2-17 [32, 1280] [32, 1280] --\n", - "│ │ └─Linear: 3-18 [32, 1280] [32, 1280] 1,639,680\n", - "│ │ └─ReLU: 3-19 [32, 1280] [32, 1280] --\n", - "│ │ └─BatchNorm1d: 3-20 [32, 1280] [32, 1280] 2,560\n", - "│ └─Linear: 2-18 [32, 1280] [32, 1] 1,281\n", + "│ │ │ └─NormedLinears: 4-23 [32, 5, 64] [32, 5, 17920] 5,824,000\n", + "├─Tokenizer: 1-3 [32, 5, 17920] [32, 5, 512, 6] 14,132,224\n", + "│ └─Encoder: 2-13 [32, 5, 17920] [32, 5, 3072] (recursive)\n", + "│ │ └─Sequential: 3-24 -- -- (recursive)\n", + "│ │ │ └─NormedLinears: 4-24 [32, 5, 17920] [32, 5, 64] (recursive)\n", + "│ └─Decoder: 2-20 -- -- (recursive)\n", + "│ │ └─Sequential: 3-25 -- -- (recursive)\n", + "│ │ │ └─NormedLinears: 4-41 -- -- (recursive)\n", + "│ └─Encoder: 2-21 -- -- (recursive)\n", + "│ │ └─Sequential: 3-24 -- -- (recursive)\n", + "│ │ │ └─NormedLinears: 4-26 [32, 5, 64] [32, 5, 64] (recursive)\n", + "│ └─Decoder: 2-20 -- -- (recursive)\n", + "│ │ └─Sequential: 3-25 -- -- (recursive)\n", + "│ │ │ └─NormedLinears: 4-41 -- -- (recursive)\n", + "│ └─Encoder: 2-21 -- -- (recursive)\n", + "│ │ └─Sequential: 3-24 -- -- (recursive)\n", + "│ │ │ └─NormedLinears: 4-28 [32, 5, 64] [32, 5, 64] (recursive)\n", + "│ └─Decoder: 2-20 -- -- (recursive)\n", + "│ │ └─Sequential: 3-25 -- -- (recursive)\n", + "│ │ │ └─NormedLinears: 4-41 -- -- (recursive)\n", + "│ └─Encoder: 2-21 -- -- (recursive)\n", + "│ │ └─Sequential: 3-24 -- -- (recursive)\n", + "│ │ │ └─NormedLinears: 4-30 [32, 5, 64] [32, 5, 64] (recursive)\n", + "│ └─Decoder: 2-20 -- -- (recursive)\n", + "│ │ └─Sequential: 3-25 -- -- (recursive)\n", + "│ │ │ └─NormedLinears: 4-41 -- -- (recursive)\n", + "│ └─Encoder: 2-21 -- -- (recursive)\n", + "│ │ └─Sequential: 3-24 -- -- (recursive)\n", + "│ │ │ └─Rearrange: 4-32 [32, 5, 64] [32, 320] --\n", + "│ │ │ └─Linear: 4-33 [32, 320] [32, 320] (recursive)\n", + "│ │ │ └─Rearrange: 4-34 [32, 320] [32, 5, 64] --\n", + "│ │ │ └─NormedLinears: 4-35 [32, 5, 64] [32, 5, 3072] (recursive)\n", + "│ └─Embedding: 2-22 [960] [960, 512] (recursive)\n", + "│ └─Decoder: 2-23 [32, 5, 3072] [32, 5, 17920] (recursive)\n", + "│ │ └─Sequential: 3-25 -- -- (recursive)\n", + "│ │ │ └─NormedLinears: 4-36 [32, 5, 3072] [32, 5, 64] (recursive)\n", + "│ │ │ └─NormedLinears: 4-41 -- -- (recursive)\n", + "│ │ │ └─NormedLinears: 4-38 [32, 5, 64] [32, 5, 64] (recursive)\n", + "│ │ │ └─NormedLinears: 4-41 -- -- (recursive)\n", + "│ │ │ └─NormedLinears: 4-40 [32, 5, 64] [32, 5, 64] (recursive)\n", + "│ │ │ └─NormedLinears: 4-41 -- -- (recursive)\n", + "│ │ │ └─NormedLinears: 4-42 [32, 5, 64] [32, 5, 64] (recursive)\n", + "│ │ │ └─Rearrange: 4-43 [32, 5, 64] [32, 320] --\n", + "│ │ │ └─Linear: 4-44 [32, 320] [32, 320] (recursive)\n", + "│ │ │ └─Rearrange: 4-45 [32, 320] [32, 5, 64] --\n", + "│ │ │ └─NormedLinears: 4-46 [32, 5, 64] [32, 5, 17920] (recursive)\n", + "├─Embedding: 1-4 [32, 5, 6] [32, 5, 6, 512] 262,144\n", "=============================================================================================================================\n", - "Total params: 50,919,361\n", - "Trainable params: 50,919,361\n", + "Total params: 29,689,792\n", + "Trainable params: 29,689,792\n", "Non-trainable params: 0\n", - "Total mult-adds (Units.GIGABYTES): 2.87\n", + "Total mult-adds (Units.GIGABYTES): 1.40\n", "=============================================================================================================================\n", "Input size (MB): 11.47\n", - "Forward/backward pass size (MB): 90.36\n", - "Params size (MB): 99.56\n", - "Estimated Total Size (MB): 201.38\n", + "Forward/backward pass size (MB): 67.17\n", + "Params size (MB): 57.58\n", + "Estimated Total Size (MB): 136.22\n", "=============================================================================================================================" ] }, - "execution_count": 300, + "execution_count": 535, "metadata": {}, "output_type": "execute_result" } @@ -1192,7 +1239,7 @@ }, { "cell_type": "code", - "execution_count": 301, + "execution_count": 536, "metadata": {}, "outputs": [], "source": [ @@ -1201,7 +1248,7 @@ }, { "cell_type": "code", - "execution_count": 302, + "execution_count": 537, "metadata": {}, "outputs": [], "source": [ @@ -1213,7 +1260,7 @@ }, { "cell_type": "code", - "execution_count": 303, + "execution_count": 538, "metadata": {}, "outputs": [ { @@ -1225,14 +1272,14 @@ " | Name | Type | Params\n", "-------------------------------------------\n", "0 | norm | Affines | 0 \n", - "1 | ae | Tokenizer | 23.2 M\n", - "2 | probe_embed | Embedding | 8.2 K \n", - "3 | head | Sequential | 1.6 M \n", + "1 | ae | Tokenizer | 14.1 M\n", + "2 | probe_embed | Embedding | 262 K \n", + "3 | head | Sequential | 15.4 K\n", "-------------------------------------------\n", - "24.9 M Trainable params\n", + "14.4 M Trainable params\n", "0 Non-trainable params\n", - "24.9 M Total params\n", - "99.556 Total estimated model params size (MB)\n" + "14.4 M Total params\n", + "57.639 Total estimated model params size (MB)\n" ] }, { @@ -1242,6 +1289,283 @@ "training ae\n", "requires_grad: True\n" ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAbwAAADmCAYAAACu0jD6AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAABV3UlEQVR4nO3dd3zTdf7A8dc3SdNd6KJC2aBF2QJlKnrKUEGQceABKh6ouM+td6cnd8pw43kecjgYAiK4AAf+HAjIkKmAzDIKFNrSmaZJv8nn90eakLQpLSVd9P18PO4kyXd88mmbdz6fz/vz+WhKKYUQQghxkTPUdAGEEEKI6iABTwghRL0gAU8IIUS9IAFPCCFEvSABTwghRL0gAU8IIUS9IAFPCCFEvSABTwghRL0gAU+IWubYsWP16r5CVBcJeELUsP/+9788+OCDAOzevZuRI0dWexm+++477r333godu3z5coYMGVLFJRIi8Ew1XQAh6rt77rnH8++8vDyKioqqvQzZ2dnIKoPiYictPFEvbdu2jTFjxtC1a1euv/56li9fDsCiRYsYNGgQ3bp1Y8yYMfzyyy+ec5KSkli6dCnXXXcdXbp04dlnn2X9+vUMHjyYrl278tBDD6HrOgATJkzgP//5DyNGjKBLly5MmDCB3377jQkTJtC1a1dGjx7N8ePHAXjzzTe5++67OXXqFJMnT6agoICuXbty7Nix87oOwNKlSxk8eDDdu3dnwoQJHDhwwKf88+bN47rrrqN79+5MmTKFvLw8tm3bxnPPPcfBgwfp2rUrDofjvOry66+/5uabb+bKK69k2LBhfPvtt57XVq1a5SnP0KFD+eSTTzyvvfbaa/Tr14+ePXsybtw4duzYcV73FeK8KSHqmTNnzqju3bur999/X9ntdrVt2zbVuXNn9e6776revXurHTt2qKKiIrVs2TLVuXNndfToUaWUUpdddpmaNGmSysvLUwcOHFCXX365GjNmjMrMzFSpqakqOTlZffXVV0oppcaPH6+uueYadfToUZWXl6cGDRqkkpOT1Z49e1RBQYEaN26cmjp1qlJKqVmzZqm77rpLKaXUhg0bVJcuXTxlPZ/rfP3116pPnz7qt99+U3a7Xc2bN09dddVVqqCgwFP+O++8U2VnZ6u0tDT1hz/8Qc2ePVsppdSyZcvUTTfdVKH68z52/fr1qlOnTmrNmjVK13X1ww8/qE6dOqktW7aogoIC1b59e7V582allFJr165VnTt3VmfOnFHr169Xffv2Venp6crhcKjXX39djRw58oJ+rkKUR1p4ot754YcfiImJ4fbbbycoKIguXbrw4Ycfsnz5csaPH0+nTp0wmUyMGDGCzp07s3LlSs+548ePJyIigjZt2hAfH8/IkSOJiYkhMTGRtm3bcuLECc+xN954I82aNSMiIoKOHTty1VVX0a5dO0JDQ+nRo4dPy+xcKnqdjz76iHHjxtG+fXuCgoKYMGECYWFh/PDDD55r3XbbbTRo0ICEhAT69u1LSkrKBdXlJ598wpAhQ7jqqqswGo3079+fm266ydOSCw4OZtmyZWzevJnk5GS2bt1KdHQ0QUFB5OTk8NFHH7F//34eeOABPv744wsqixDlkYAn6p309HSaNGni89wVV1yB3W4nMTHR5/mmTZv6BLHo6GjPv41GI5GRkZ7HBoMBp9NZ5rFRUVE+x6oKjplV9DonTpzgnXfeoXv37p7/paWl+ZQ/JibG82+TyXTB43aZmZll1lloaCgLFy7EYrFw//3307NnT2bMmIHdbqd79+688sorbNy4kdGjR3PttdeydOnSCyqLEOWRpBVR7yQkJJCWlubz3IcffkijRo1ITU31ef7o0aMkJyd7HmuaVuH7nM+xgbhOQkIC48aNY9y4cZ7nDh8+THx8fEDK4U/jxo1L1dmxY8eIj48nPz+fnJwcZs2ahdPpZPv27dx///0kJSXRu3dvEhMT+eCDDygsLOSrr77iySefpFevXjRr1qzKyivqN2nhiXqnf//+nDlzhkWLFuFwONixYwevvPIKffv2ZeHChezcuRNd11m+fDnbt2/nxhtvrLaymc1mioqKKCwsPO9zR44cybvvvsu+fftQSvHtt98yZMiQCnVbms1mCgoKfFqoFXHLLbewcuVKfvrpJxwOB2vWrGHlypUMGzaMgoIC/vznP/Ptt9+iaRqNGjVC0zQaNmzIzp07ufvuuzl48CAhISFER0djNpsJDw8/7/ctREVJC0/UOw0bNmTOnDlMmzaNl19+mbi4OP75z39y4403EhkZyeOPP87p06dp3bo1s2fPpk2bNtVWtqSkJDp06EDv3r2ZN2/eeZ07ZMgQ8vLyePDBBzl16hRNmjRh5syZdOjQodxze/ToQUhICN27d+ebb74hLi6uQvfs1q0b06dPZ+bMmaSmptKkSROmTZtG7969AVcm5muvvcbjjz9OZGQk48eP5w9/+AMA+/fvZ+LEieTm5pKYmMjrr7/u0+UqRKBp6kI78YUQQog6QLo0hRBC1AvSpSmE8NG3b18KCgr8vtaqVSvPJH0h6hrp0hRCCFEvSJemEEKIeqFGAp7dbueBBx5g7NixzJ49uyaKIIQQop6pkYD35Zdf0q1bNxYvXsyvv/7K6dOna6IYQggh6pEaCXi//fabZ/WK7t27yyrpQgghqlyNBDyLxUJYWBgAoaGhWCyWmiiGEEKIeqRGpiWEhYV50p6tViuxsbGVvlZurhWH4/yWQ/IWHR1OVpYE3ECR+gwsqc/AkvoMrNpQn0ajgaio0AodWyMBr0OHDmzatIkrrriCTZs2MXDgwEpfy+FwouuVC3juNXkdDicyOePCSX0GltRnYEl9BlZdrM8aCXg33ngjjz32GCtXruTqq68utVXL+arsovTu8wK0qH29J/UZWFKfgSX1GVh1sT5l4rkQQoh6IaAtvNdff5309HReeOEFAH766SdefvllbDYbjRs3ZsaMGTRq1CiQtyQry1LpMTxNg9jYSDIz8zxNcmW3Yl07H8epAxgT2hLabwKauWL9w/Wdv/oUlVfT9amUuuANYmsTTYOYmAjOnMmX388AqO76NBj851gajQaioyu2rVRAAl5qairTpk1j7dq1DBkyBIAzZ87w2GOPMW/ePJKSkpg3bx5PP/00c+fODcQtfVxoZSt19hrWtfPRD2wA5UTPy8AKhF571wWXsT7xrk9x4aq7Pp1OJ3l52Vit+cDF9YM8fdpw3nv+ibJVZ30ajSaioxthMgVV+hoBCXhLliyhT58+XHrppaSnpwOwdu1akpKSSEpKAmDs2LHMnDmT9PT0Kt2B+UI5Th0AVfwDVE4cpw7WbIGEqGZnzpzCYDAQG3sJRqMRqEODNOUwmQyVTnITpVVffSry83PJyjpNfHxipa8SkID36KOPAvDmm296nktLS6Nx48aex2azmejoaE6ePFmrA54xoS16XoYr6GkGjAnVt/mnEDVNKSe6bic+vmlxsLu4GAwGyugZE5VQnfUZERFFQUEuTqezzO7N8lRZlqZSCs1P+k5lC1pdQvpOoBBwnDqIMaENIX0nVOg8ZbdSuO7s2F9IXxn7E3WPu+vU39+uEDXrwn8nqyzgNWnShA0bNnge2+12srKyLngKQlUrVEEssPTlYE5H2kREMV4FUZGwVbjOd+yvEBn7E0KI2qTKmlt9+/Zl9+7d7Nu3D4ClS5fSuXNnYmJiquqWAbFg9V427jrF6SwrG3edYsHqvWUeq+xWrN+/Q/7iJ9AP/eIz9qefLPs8IYQQ1a/KWngxMTG89tprPPnkk9hsNmJjY5k5c2ZV3S5gDh7PxVncreNUrsdl8W7VlX4xv4pKKIQQojICGvAeeOABn8d9+vThk08+CeQtqlybxCgysq04FRg01+Oy+GR0lnpRr6ISClF7WW06C1bv5eDxXNokRjF+QBKhwTWyoJPH1q2/MGPGv1iy5FPPc7ffPpZ33nmf4OCQmitYsenT/0n//tfSu3c/3n//fzRr1oLrrhtQ5fddseJTLBYLY8aMO+dxL7zwDxITm3LHHZOqvExVrWZ/E2uh8QNc0yi8/2DLYohriSPX/15+WkTt7roVoiq4hwScCjKyrQBMHtK+hkvl68CB/SQmNqsVwQ7gqaf+7vn3L79sonHj6slz2LFjO4mJTavlXrWFBLwSQoNNTBrY2pNxyfq2qDIyLktlspmCwamjhccQNvTpaiqxELXH+QwJVNbUqX+nefMWnhbHjz9+z8KFHzBixGiWL1+KrutkZ2dx00038+c/313q/B9//I6rr74GgA0b1jN79r9xOByYTEE88MBf6Nq1G7/+uoP//OeN4l1dNP70pwkMGnQjJ0+e4P7776J3737s2LGVwsJC7rvvIb777lsOHTpIeHg406e/SnR0NP379+S22+5kzZrvycvLY9Kke/j11x38/vtunE4n//zndJo3b8n999/F0KHDyc7OYu/ePZw8eQJN09i8eSPBwSH8/vtusrLO0KlTF3r06MmqVV+QmnqM2267kxEjRgOwcOEH/N//fYNSiujoGB5++HGaN2/BCy/8g5CQUI4ePUxa2kkSE5sxdeo0Nm5cz9q1azCbgzCbzfzpT7dVqO4PH07h9ddfIivrDEopbrppKGPGjEcpxVtvvcHmzRswmYJo0KABzzzzHHFx8Xz44Ty+/noVQUFmzGYzjz32NK1b18x0Lwl4flQ049KRnuLzWAtrSMTYGdVUSiFqn/MZEqisYcNG8OKLz3sC3sqVnzFo0I0sX76UadNeJjY2jrS0NP74x5sZOXJMqfPXr1/La6+9RVZWFs899zSvvvoW7dt3YPv2rbz++su88cZ/ePrpx5g6dRpXXtmdU6fSuOuuO7jkksY0apTAqVNpdO16JY899hTvvvsOL744lfnzl5CQcAkPP3wv33yzijFjxuFwOAgODuaDDxbz5ZcrmDZtKnPmzCMpqR0zZvyL5cs/5uGHH/OUa8yYcfz0048MHTqcgQNvYPPmjezatZP//vc9HA4Hw4YNJjo6mn//+x127tzO448/xIgRo/n661Xs2vUbs2e/T1BQED/99APPPPM4CxZ8BMCePbt46605mEwm7rlnIt988yUjRoxmw4b1JCY2rXCwczgcPPnkX5g4cTKDB99Ebm4uDzxwFw0bxtC27WWsXv0Vy5evxGg0smjRAn77bSc9evTknXf+w8qV3xIeHsFXX61k+/atEvBqk4qutuIzSR1Q1hys378jc/BEvXU+QwKV1blzV4KCzGzfvpWmTZuza9evTJ06nQEDBvPzz2tJTT3G4cMpKKUoLLT6nJuaeozIyEiioqL48cfvaNq0Oe3bdwCgS5cref/9D/n553U0apTAlVd2ByAh4RKuvfZ61q37iVtuGQVA//5/ACAxsSlt2rQhIeESz+OcnBzP/a699noAmjRpSkxMLElJ7TyPU1LKX8WpT5+rCA4OBlyJgL179/Xcx2KxoOs6a9eu4fffdzN58u2e83Jzc8jNdZWjR4+enmu0bt2W7OysCte1t2PHjpKXl8fgwTcBEBUVxZAhN7Nu3U9cc811xMXFc+ed4+jZszfJyb3p3j0ZgOTkXtx553h69+5L9+7JXH/9oErdPxAk4PlR0dVW3JPU9ZQtoNugqBB9/3oKnQ5Cr5tSvYUWohYIDTZVy5jdsGEjWLXqC5o3b8F11w0kNzeHe+65k5tuupkrrmjPkCHD+OGH/yu1+PWPP37P1VdfC7jWZiw5LHHgwH50vajU/ZRy4nA4is8zYjKd/eg0Gsv+GA0KOrvuo/c5FeV9fln3cjodjBnzJ0/yicPhIDMzg8hIV+vaHezANQxT2QXB/a2Z6XQqHA6d4OBg5sz5gN27f2Pr1l+YNesVOnXqymOPPcXMma+zf/9etmzZzMKFH/Dpp8t4+eVZlSrDhardy57UkJC+EzC17YUWlYCpba8yV1vRzKGurs4SfzT60R3VUUwh6q3Bg29i48af+fLLFQwbNpLff99DWFgYEydOpnfvfmzYsB6lVKkP6R9//MEzfte+fUdOnjzOvn2/A/Dbbzt55JH7ad++I6dOnWTr1l8AOHUqjR9++D969uxd5e/LaDR5AmtF9erVl5UrPyc31zVeunTpIv7yl/sqcC/jed2refMWREZG8tVXKwHIzc1l1aovSE7uzY4d25g0aQJt217GbbfdyZgx49i373dOnDjOqFFDiYtrxNix45k8+V727au5OcrSwvPDE8j88LeEWKml7C+uBeaFqHUiIyNJTu7F0aNHaNOmLU2bNuXLL1dw660jCAsLo1WrNjRv3oJjx45iNpsByMjIQCkncXGutXyjo6OZOnU6L730IkVFOmazmWnTXiEmJpYXX3yFt9+ehdVagMPhZOLEySQn9+LkyRNV+r769bua2bPfwm63VficIUOGkZGRzr33TsJg0IiKasCLL75c7vJwvXv35ZVXZqCUYtKke8q9j8lkYtq0V3jjjVdYtGg+RUVFDBp0AzfffAsA3bsnM3HinwgLC8dsDuIvf3mcJk0SGTlyDPffP5ng4BCMRgNPP/1shd9boNX5DWCzsiyVXq1b0yAuLpKMjIrvN2b9/p2zk801A6a2vVAOHcehTWcPMgVjatWt3o3lVaY+Rdlqoj6dTienTx+jUaNmtX7d28qQ3RICqzrrs6zfTZOpmvfDq09KJrToafshtiV2gjAqHQMKTbfJWJ4Qok745psv+fDD+X5f69KlKw8//Hg1l6jqSMArVtHdDkomtGiA4/AvmFEofIfzZCxPCFHbDRx4AwMH3lDTxagWEvCKVXTuXcntgxxp+zEUD9qV6jKXbj0hhKg1JOAVq+jcu5IJLdbv38Gel4EB5bWXmCvWaSHhKLu1Xo3jCSFEbXXxjUpXVlwbnMUbDDrRIK51uacouxXl0DGYzNg1Mzv15mSpcFewA7CcoXCd/75xIYQQ1UtaeMWWFvSghe0ULUzpHNHjOVLQg4llHOse7/NMOAfMmoEuSYnkHslFc09tUQo9ZSuqr7TyhBCipkkLr1jKyTxPy0wBW35PZ86KXVhtvtv8KLsVy7Jn0fev9wQ71wtOrAc3s6+goW8KuV4orTwhhKgFpIVXbFTYJlqQgkFTxBpcm7cu2uVa1sd7qaTCdfNReel+rxGMjoYTBxomr4yVssYDhRBCVB9p4RVrZUrHoLmClEFTtDSl+93exHHqgM9j79acpsHlQScwlkjPLGstTiEuNspuxfr9O+QvfgLr9++g7NbyT6qERx55gPR0/3tRlmX69H+yfv3aCh07bdpUtm3bUpmiBdynn37Me+/NAVw7PfznP9WzDuWePbt48cXnyz1u1aoveOihe6uhRBdOWnjFTJe0Rc93za9zKo3Derzf7U2MCW3Rc9OhOCtTAShXsHMqDY0S0xNMIWWuxSnExaai03su1KZNP5/3IshPPfX3Cq0M4nA42LXrV5544q8XUsSAGT58lOffe/bs8uyCUNVSUg5x6tSparlXdZGAV8yz80HaAY7o8fxIMj1bxZXa3iSk7wR+Tc2hsWUvwZqOQXO18gqdJnYWNceoOelqPuKam6cZMLW6UhJWRL1R0ek9F+L55/8GuFp5eXk5dO58JYcOHeDWWyfQpcuVvPLKdAoKCsjISKdJk0SmTp1Ow4YNuf/+uxg27BYGDLiBfv26M3nyFDZsWEd6ejrDh49k/Pg7ANixYxvt23fEaDRy/HgqL730IhkZrmGMW24ZzciRfyQjI51XXplBaupRNE2jd+9+TJ48BZPJxKhRQxk48AbWrfuJnJxsxowZx5kzmWzfvoW8vDyeeeY5OnXqwv3330W7dlewdetmsrKyGDBgEFFRDVi37idOnz7Fgw8+Sv/+1zJ37mzS009zww1D+Oyz5ei6TlhYGG3bXsb333+Lw+Hk5MnjhIdHcOedd7F06SKOHTtK167deOaZ59A0jZ9/Xst77/0PXS/CaDRy551307t3X1at+oLvvltNSEgIx44dRdMMPPPMs4SHR/C///2XvLw8nn32aaZOnVahn43Fks/rr7/Mnj270TTo0KETDzzwF8LCwvnqq5UsXrwQo9GIwWDgvvseokuXK9m48Wfeeec/nmtMmHAH11xzXWB/aYpJl2Yx9/y6yFtn0mnC40y9uz+Th7QnNPjsdwJ3dmaDgmOuc4pbcpoGuSqUhZZ+fGTpxZHQK8rdaUGIi5ExoS1oxR8r59ha60I899y/AHj11TcJCjLTrFlzFixYyk033cyKFZ9x7bXX89//vstHH32GwWDgyy9X+L1OUJCZt99+l+nTX2XOnLfJz3eN3a9Z84NnC6F//OMZevbsw4IFS3nzzXf4+OPFnDhxnOef/xtJSe2YP/8j5sz5gL1797Bgwfuea+fm5vDBB4t47rl/8dZbr9OxY2fmzJnHDTcM4cMP53mOO3Ikhf/9bz5vvz2XDz+cj9ls5u2353L33ffx7rvv+JS3c+euDBs2gquvvoYHH3wUgO3bt/Loo0+yaNFyQkNDef/9/zFjxmvMm7eYtWvXsH//XlJTj/HWW28wY8arvPvuQqZOnc706VNJS0sDYMeO7dx338N88MFiunXrzvz575OY2JRJk+7hiis6VDjYAbzxxiuYTCbmzVvM++8voqioiFmzXgVg1qxX+cc/XmDu3PlMnjyFLVs2AzB79ltMmnQPc+fO5+mnn2XTpg0Vvt/5khZeGUouNRbcYxQFX0xD5aUTUzyxXBV3ZSoFR/VYAAqVmQ8L+jH97qrfSkSI2qbkSkTV8YWvc+eunn+7Pkg38eGH8zl+/BhHjhymU6cufs+76qr+ALRteylKKfLz84iIiOCXXzYxZcoD5ObmsGfPbt5447+Aa3eFRYuWY7Va2bFjG9OnvwJAcHAIt9wymgUL3vfswu5uoSQmNgWgT59+nscbNqz3lKF//2sxGAxcckljjEYjvXu7jmvSpGmFui4vvTTJc4/ExKZER8dgNpsxm81ER0eTk5PDb7/9SmZmJn/5y/2e84xGEwcP7i9+/21p3LiJ53oXsn3Pzz+v4/XX/+NZ3PmPf7yVRx99EIDrrx/Iww/f69kIdvx414a11103gH/961l69epDt27J3HvvQ5W+f3kk4JWh5FiEI22/T3amO9B5Hnudm5Nv48m319O2WQPGD0jyaSUKcTE719ZaVSU4OMTz7+ef/xtWq5Xrrx9Ejx7JFBZayxzr87cx6u+/76ZVq9YEBwd7NoL13mYnNfUYMTExpa7pvUEsuFqP3sra/LWix5WlIuc7nQ46d+7C9Omvep5LTz9NdHQM33zzJWbz2fq7kA1iwVUPvvdWnnp55JEnGTVqLL/8solVq1Ywb967zJ27gHHjbuf66wexefNGNmxYz//+91/ef/9DoqIaVLocZZEuzTI40vb7jEX4m4rg3aXZzJTped5W5CQ9p5CNu06xYHXNbXYoxMWqrM1LN25cz2233cnAgYOJiIjkl182+92puyyuHdGvASA8PIL27TuycuVnAOTkZPPAA3dz/PhxOnXqwtKliwGw2Qr59NNl1bRB7Plt2grQvXtPtm3bwoEDrhbd7t2/MXbsLWRkZFTgXvo5jympZ88+fPzxYpxO1xeAjz9eTHJyL6xWK8OGDUbTNEaMGM2jjz7JkSOHsdttTJjwR44fT2XIkGE8+eRfyc/PJysr67zuW1HS9KgszQAoUMqT1VmSv2kNQogL17//H3jwwSlkZZ3xef6eex7g+ef/RmRkJEFBQXTt2o3U1KMVvu769Ws9XW0A//jHC7zyynS++OIzlHIyadI9XHrpZTz77D95/fWXuO22MdjtRfTq1YeJEycH7P2VpXv3ZD755GOmTZvq05V7Li1btuKZZ/7Biy/+A4fDCSief34al1xyyTnP69ChE3PmvM0jj9zPq6/+u0L3euihx3jzzVe5/faxFBXpdOjQkUceeZLQ0FDuu+8hnn76MczmIEDjySf/RlhYOA888AizZr2KprlamLfdNpEWLVpW6H7nSzaALWODzbxFj0Heub8B5RkaUFjkJEWP52NLMjZ8uxcMGvRsn+Azcf1iJhvABpZsABt4sgFsYMkGsBcJ0yWXoeefOdut6UdhkZN/5dzieRwcZCAy3BX0NKBt0walpjUIIURdcvToYZ599hm/r4WGhvD22+9Wc4kqTwIeYLXpzP9mLweP59ImMYrxA5J8ss0McS3QNA39yA7QCwHXJPOUEt2Y4WFBXNq0gc91JGFFCFGXNW/ekvff/9Dva3WtxSyfxsCCb/aycdcpnAoysl1LIU0e0p7Qa+/ynZ7QvBOappF1eC97CmL42JLscx1LQZHf6whRV7gTser4SIe4KF3476QEPODA8VycxXVZMtHEe3qCI/c0BIVwRG+CESePN1jpM36naVqZ1xGiLtA0AyaTmezsDKKiojEajfhOuqnbnE7OK2tTnFv11aciPz8Xo9F0QWPLEvCAtolRZGRbcSo862dabToLVu9l4PHfiNG8fqBFhbTXDoG5OKnAkIcRJ7sSR2I0amzec9rzPcSpFFabLt2aok6JiUkgLy+bzMw0AvGtujYxGAwS8AKoOuvTaDQRHd3ogq4hn8TA+IFJKPAZe1uw2tXN2Tosju7mPM9OClD8fddrDl77oFT2mw2MH5DEoZO5ZGS7xvkycwpZsHqvdGuKOsVgMNCgQQxRUdEXVdempkFsbASZmfmSRRwA1V2fgcgaloAHhAabSgWlg8XdnO5xus7mowRr/idhuoNlaLAJg9eqDEq6NUUdpmmazyojdZ2m4Vm4WALehauL9SkBrwxtirs5bcrMooJ+HG3RkLGRv+A4dRDl1FH5ma7d0RXsLmpKm1ZRnvPysnMYEbaJVqZ08sOao+xdZMcEIYSoYRLwyuCeP+fu5hx2dRve/z6InccvI0Qr4vbYrcTrJzmsx5PS4gbP8eMHJNEzaxUtCly7p8cX7qFw3fxqX19QCCGELwl4xdxJKseOZzCquHU2/pK2hEycgGYOZc6KXWze41pP04aRWSd7ENcwhOcnJtPXKyklNNhE66B0lHvMr4r2BBNCCHF+Lr61gyrJnaTS3/4jLQp2Q95p9AMbKFw3H2W3csXxT/lbg08YF76WYOwAZGQX+l8cOq4NzuKsFicaxLWuzrcihBDCD2nhFXMnqbQypZ/NyFRO9JSt5KdsoaNmQzNCrMG1SeRCSz/PeSUtLehBC9spWpjSOaLHc6SgBxOr7Z0IIYTwRwIers1e/xS2lgjnUcC1+4FBU67MI70QjbNTbw2aomPQUYKxY8OMw+EsNddu70kbPxUHRIBGJ23V+XaEEEL4IV2agHXtfFoV7iHemEesIZ9sIjjtiMSmTH7XmAjRdEaFbwIgM9dWqluzTWIUhuIT3RPZhRBC1Cxp4QGOUwc8uyIYNEBpvJAznHHha+luTvG09rw3fG1pOrshbMluzXH9m9MzaxUNCo6RE9aMtv3vqa63IoQQogzSwgOMCW2LN3QFNAM5Yc0A16TzX+ytOO2IJMMZgVMVJ6KU2PC1ZAtO+2URrQr3EKPl0qpwD9ovi6rnjQghhCiTBDwgtN8ETG17oUUlYGrbi7bD7yGuYQg2zHxsSeawHo8GnHGGk2dsQEro5Xxh70WI2Ujy5Y1K7Xnn3WKUaQlCCFE7SJcmoJlDfSaGW206rRpHkmexMyZkM11Nrm5NJxrGFr1ocv3dvH6O6xkT2qLnZbiCnmbAmNCmyt+DEEKIc5OA58eC1XvZ8ns6TgXNw057pikYUJBxqNzzvTePNSa0IaTvhCousRBCiPJIwPPj1PETPBP1GdEGC7oyeqYpONH4LSeK3St2nXM385ItRiGEEDVPAp4fdxpXEEG+azVwdHQtCIsxnN8LYlhq6UZR9img7N3MrTadxV/v5LKTX9LKlE5Ui8sJv/o2WUBaCCFqkAQ8PyJVvs9+dybNyb9ybqHQ7nA9Wc62PwtW76XNkRV0MKdgcCgchzZQaNSk1SeEEDVIsjT90CJifB5nOcPOBrti55pMfvB4Li29ligzoCRTUwghaliNB7wHH3yQI0eO1HQxfIQNfRotMh4MRvIMDXgta6DP6wYNRl5dduZlm8QoDuvxZ+ftoUmmphBC1LAaC3iFhYVMmTKFHTt21FQRymSIiCHi1peInDSXWY6x5BLu87pTwbI1ZbfYxg9I4kiLIfxGW/KMDTG27iWZmkIIUcNqLODZbDYmTZpE7969a6oIFZLUOJhx4WtLbQ10rjG80GATdwy+nK5toonUrKhj2yj86X2U3VpdxRZCCFFCtSStLF68mOXLl3sejx49mtGjR9OtWzeWLl1aHUUol7JbKVw3H8epAxgT2hLS17Xx6+iwzTiCUzCgPFsDLSroV+6C0IXr5uM4tMnzWD+4EcvpQ4SPnCrZmqJOcW+OfPB4Lm0So845JUeI2qxafmvHjh3L2LFjq+NWlVa4bj76gQ2uPfDyMijENYFcHdvmmnCOa2ugtuYMerZKKLWcmDerTSfr0G4iSzyv8tKxLHtWgp6oU9ybIzsVZGS7einKmpIjRG1W40krtYW/9S8L182HokKf4xpd1oHJQ9qf8xvugtV7+b0gxrWfXgkqL911XSHqCPfmyOAavz5Xd74QtdlF0S+h+du07jzOK7TrHCqKp4UqnkpQvP6l49QB3xNMIYT2m1Du/Q4ez2WrJRkNJ13MhzGWKKPz1MFKl7k2894+SVy42lKfbROjyMi24lSuDOW2iVE1XqbKqC31ebGoi/VZ4wFv+vTpF3R+dHR4+QeV46MfDrHhREdGhFlpZUrHGtWCq4dNIePr/5H/29lFoCMu70l8k0blXq9961h+3FrIR5ZetDKlE2O0+Lwe1qIdcXElOzwvHrGxF+97qwk1XZ8P3dqN4OU7+f1IFu1aRHPPiE6EhQTVaJkuRE3X58WmLtXnBQW8119/nfT0dF544QUAfvrpJ15++WVsNhuNGzdmxowZNGpUfoC4EFlZFhwOZ6XO1TTXD2vXoUysysxCSz8AGhlC6ZDnQOs+FlNhEc5TBzEktEHrPpaMjLxyrzu6f2tstiIuP/4pMZrFd9d0U0iFr1PXuOszMzPPb3euOD+1qT5vG3iZ598F+YUU5Bee4+jaqTbV58WgttSn0WiocMOnUgEvNTWVadOmsXbtWoYMGQLAmTNneOyxx5g3bx5JSUnMmzePp59+mrlz51bmFuflQiu7ZJdNm8Qo1zWDQqHPncz7ag87t2aibdtEpzax3D643TnH8ELMJiYNaU/+4g9QJYY7TK2uhKDQi/oPTqkL/5mIs6Q+A0vqM7DqUn1WKmllyZIl9OnTh4kTJ3qeW7t2LUlJSSQlubIXx44dy8aNG0lPTw9MSavQ+IFJ9GyfQKPoUHq2983AXLB6L5v3pGMrclJod7Bpz2kWrN5boesa4lr6PhERKxPQhRCihlSqhffoo48C8Oabb3qeS0tLo3Hjxp7HZrOZ6OhoTp48SXx8/AUWs2qFBpvKTLP2l5FW0Sw1reRobmE+hevme+b4CSGEqD4BS1pRSpX+gAcMhroz88HfBNs2iVGczvJdIaW8SedujvQU3yd0G/qBDRSC7JwghBDVLGABr0mTJmzYsMHz2G63k5WVRZMmTQJ1iyrnPcH2dJaVbfsy6Ngmhm6XxfFbyhk0TaNTm9hzTjp3s9pKTHVwK57jJ4QQonoFrPnVt29fdu/ezb59+wBYunQpnTt3JiYmppwzaw/vCbYAhXYHm/eks2VfBpHhZv41qSf3DOtQoWWVFqzey+wTHfnF3gqr0+Q7qKucsq6mEEJUs4AFvJiYGF577TWefPJJbrzxRr766itmzpwZqMtXizaJURjKmESZkV3I9A+3VvhaB4/neqY6PJc9igxnhCfoqfwMWW1FCCGq2QV1aT7wwAM+j/v06cMnn3xyQQWqSe6uyq17XVmZJWXl2ip8rTZeUx1smAHt7IoESjaEFUKI6lZ3MkqqgTtb89X7+9G7Q0Kp1l50VHCFrzXy6jbENAjxPE7x2hDWvXSZEEKI6iMBzw934Js5pQ9xDUMwGjTiGobw1J+urPA1lq05yJmcs6tRfGPpgF0ZXfsuGIMwdxkS+IILIYQoU42vpVmbxUSFMPOePpU6t2QCzN0NviNY013LjOk2rF+9RsStLwWknEIIIconAQ/X5q/WtaU3f70QJefvRRssPquKK8uZC7q+EEKI8yNdmoB1rWvzV5V72jUxPAAZlOMHJPmMAWY5w32nJhhMMjVBCCGqkQQ8Sm/+qh/YiPX7dy4oIJWcqzcrZxA25fWcwy5TE4opuxXr9++Qv/iJC653IYQoi3RpAsaEtuh5GV5BzxGQJcBMRg277mrW5RJOvgolhOJtgWRqgkfhOlcLG+VEz8sos96V3UrhusB2PQsh6g8JeEBovwlYAf3ARlAO15MBWAKs86VxbN5zdreII85GxBjzzjari1dcqe8f2iVb2GXVu2XNPByHNmBAYc9Nx+FQGK/6c6n1TyuyEo4Qov6RLk1AM4cSeu1dmNr2BK24SgIwV+6OwZfTu0MCwUGuay7J68EZRwTuoTyVl45l2bO1pguvproWjQltK1TvuUf2YCiuPQOKjIO7+OCr39m46xSns6xs3HWqwls3CSHqHwl4XkL6TsDUthdaVAKmtr0ueO8693y+BhGuCes2zGgonx3Qa1PQc3ctBjJ5pyIqWu9H9Nizy7MpOGyPYefBTM/0D6eq+NZNQoj6R/p+vLhbeoHmXmYsSNlpaChAQamgV7hufo1vGVTRrsVAq2i9R4QGgdf3AoVrWyqDhs9u9SJwZNxUXEwk4FUD9xqdVxz/FIPm28Jzqw0JLD7JO9W4/Jm/fQj9jcO1DDoDxYvXaBq0MGXSqXksJqPB51wROBVNKBKiLpCAVw3cXZv5iz9AldHjVhvW1gzpO4FCXMHXmNDmgrt0K2rhqu20Tl3FdaZ0UlLiWbjqRibd0r3UcaZL2qLnuwKyU2nkRzTnjsGXS5JKFaqpVr8QVUE+KbxUtKVR2Wu7NoQ9XWpRai0yvtqCy7lUVZduedqe+JKu5hQMmiLWkI+WugqrrUupug/pOwGrQ8dxdCcGDS5tEkGIVoT8Gledmmr1C1EV5JPCi/eO5xnZrsGiyUPaB+za2090ZESYldam0wQHGYkKN2O85NKLflykvHGglsZTnl3hDZqipek0z723CYOm+XzxKFRBHDyRS4uiQjQN9IMbsZw6SPiof17U9VeTaqrVL0RVkIBXzGrT2bYvo8oy/rw3hAWIaxjC5eEhXLbvS1odeprIZpdiMhpwpKfUSHJAoFu33kEOpVD5GaCU33Egs8mIcrjG5dxZmBnZhcX/PfvFY8HqvQwvOOCZwQBnN9OVcaWqUVOtfiGqggS8YgtW70XZrYwL30QrUzopejxHGwdmCx+rTUd3+m4oq5yKFkdW0MGcgsGhUIc3oxe/pueeptDpIPS6KQG5f0UEunXrnezgw2scyB0UI515nrRVrUR3r/cXj2PHMwjSHKXuJeNKQoiKkIBX7ODxXEaFb6K711hSz7DNQMX3wCvLgtV7OZPju1t6kbWAjuFHPV15JTM39UObUVfdUW2tPO/tjALRuvVJdvBWPA6k7FbX/MO8dJ+XnUrjhKGxp7Xnnmqg7FbuNi7H4FA+xyuAmOYXVFaf60kavhAXLZl4XqxNYhStTOk+Y0lkHArItf0Fj6HmnwnWdD9HF1POal1cuk1ilCeZJhDz2XxWT0FDi4z3mVhuXfNeqWAHBoxRcXSOzOKhJltoGm2kZ/sExg9IKm4J5pRqAaIg/+jegK0OU1OT74UQVU9aeMXGD0hi/0fNiS3Y7Qp2AcxIK7k3HkArU3rpD+8S9EO/YHU60E8fRCtuA1ZVkot7/log5rMpuxXl0MEY5ApIKpii3EKyw5rTtvutaOZQHEd3+DnT6QmCrcjgiajThA+cimY2kX/qgN/5i5oG4Y5cVG5uQOaJVWcaflVmBQshSpMWXrHQYBMdx9yP+bLeAVtazG38gCTPeppuKXq87/54UOoxDjv6wY2Ql4HKS0flpaPvX0/+godx5gd2A9kQrYjx4ev4W4NPGB++rjjdv3Ksa+fjOLQZdBvKYSPckUu0lkeLgt1s/XAWVptOkV66u7Pk23evQAOuFqP7DKXwWWLM88UhAAGqout6BoJ73LS2rwMq2zeJi4V8nfRSVRlpocEmrkyK5+ffTnme+9iSTGvTKWJL7IReIbqNgi+mEXHrSwEr4/muqOGvdRIWYqKgsIisQ7uJxGts0tNVqmivDpC94FFsTjMxWpHPe/dXDXrKVlRfK87Ow8k/uIswRy45zjBAEWMocI31ee5z4QGqOtPwAz1uWlVktRVxsZCAV03GD0hi4+5TuJM1bZiZmTOUqQ0/JqR4LM+dqFGRAKjy0rF+/07AujfPpytP2a3s/+jfXJd/lNZ6PCt3dWV/1ipaB6Wzy96Q+KJclOb/fRhRRDhyCNfgjDOMaEMBGmW/Z1VUyMl5T5ER1JgWjlwMmiLaUIBdGT3naAAGI6Y2PS84QPn70lPZrsfyznOvsVrb1wGV1VbExUICXjUJDTbRPakRm/ac9jxnw8zOouYkB59NjjmfoBeITWrdKrKihjuDUU/ZQssiG5oR4gx59DAfggJQGjRVp6FEsPN+P97/DdfsPJc1kgcbfE2cId/ndTdNgwhHDkEOi09CkVKujE6DpnCiYW7Ts8paHZWdslHeeYEcN61KstqKuFhIwKtGtw9ux/b9Gdi9xq8+tiTTzZyCUSs5glUByomesgXV98I3kXV35ekn90JhPvqBDeSn7Sds6NMYImIA366tkgHMzV+gLit4B2s6w8O38FLOEIIp4h/RyzEo5feaQcrhCZxOpbGrqClODJ5Vawwn9wWkxWu16Sz+eieXn/ycdhxBQzFQhbNLDSaX8HK7Hr2nNVyR04Ctqhs2zH7Pc6+xWtvJaiviYiFJK9UoNNjEi3f1Iq5hiOc5G2a221v4T8Lwp+SLuu2CUufdCQmW5c+5Lo8Gus21G3teOpaPnvYkKZQ5t877evhJvimDpsGV5sOMCd9ALuH8I2sEDj8jea75eMrT+j3jDOMjSy8WWvpxSG9EuCMX8jMCMo1gweq9tDiygis4jFFzbT0UrVl4sMHXQPldj97TGjpoBxgdvqlC59Vm7m7eiLEzCL32LpmXKOosaeFVs5ioEGbe04enZv/smaqwxNILBwZamtKJ0qwEo5eKa57EDD/RpOSYir/J04Df57wnf+u5pylFt1Hww/9QmUf9zJsrzTtJxV3cc3XTahp0MR9hicVOLuFstbeih/mQ51j329W8jo/QbNgwE4ydTkFHPF2dKCd62v5yy3guB4/ncl2JKSOaBtEGC42iQ8vsenSP1w08/hsxmutLgQFFUtgZGpl9z5PJ7ULUDAl4NcR7bp6Ns2tsRuFqTcQa8j3JHOW1+lTuKQq+eZPQayahmUP9ZtUBfp+rSBBzHtl2zpadd1BDOxucSo7deYJXifdiQDEqfBMLLf342JJMp6CjPok8JRmNBiJNRTwUvoLgEkuNnW/Ca0ltEqM4nBJPnCHPJ+hajVFMn9S7zPPc43Wtw+Lobs5zjS0qjUxzItP/7HueZD0KUTMk4NWQ8QOS2Hssu9SSY7mE86+cEQRjZ1T4Jlqa0tFQxBnyzxn0HIe3kP/BNjCZiyeqlcyq8/Ocs/S6lG4l57edS1lB2dW9qXk+/LfaW9DSlF5qKoamuSbiw9lEHu9WXslypQa3ZmL8DuIKS9eJsuZ6umAr04oaPyCJxV8PIezk57RTrjG8AmMUDUb89ZznuacYfGHpSmvTKWIMFpwoogsOk7/ocZ8FAyTrUYiaIQGvhoQGm/jnnT155N9rsRWVDijerb5g7DzeYEW5QQ/lhKJC3+c0AzRsjCq5sonT4QoO+G8V+WRZlnGM5/UyWqB2ZWRnkSvIHdbj+diSDMAfwzfQxXwEo3v3d821mSs5rvM8iTwlpqIrBTZl5O2TXXii4UqfXRM8xxTZyP/hXUxBQRVuRZWcPjDymitYtiaYT89jGkJS42AG2lfTMegowZqrS9oANMCCyrOg52d6ymCIa4nDq/tYOXXyFz8h3ZtCVLF6H/AKCouY88UuDtTA8k7uCenu1PWy2DDzUs4Qnmjwhad1VF4QctEwNu+M4/huSq5jovIz/F7DX/DSynjefbw/SsGuomaeoO1tvuVqPi6wMzpiM5eGZNKgxeW07fknenx3mB37M7DpZrbZW9DNfLhUSxClYcPMEUcjYrW80mXVoOjIDrSIBr6tqBJje8puxbrmPRxHd1DkUFxa2IStll5szLZyMvU4E9TnjDJYyD4WzsdfjmPC8LK7MwFGh23GEZyCoUQ9e4rnVQatZKHzM1Eg3ZtCVLF6H/D+u3wnG6po09eK8J6L5VTKsw9cSe6J6qPCN7lS8Y0aEar0B74vhePIdkov2uVSVsvOb9Dzet77v5nOcI7psXQxH/U5x4nGEksvn2uYTRq6Q+FUYFVm5uX1hTzonZDA5MhIpgzrCLhaXPO+iICTq0oFPfc7OdDkBjqcnk0wpZdAMziLSkVipZxYv3/H08WJ04HjkCuDMghXtqgDAwst/RivPneNoWoQa8jn5lOzOTPnPYISL0fLPo7KPwOmILSQSIyNL3MlAGUcLBXsSnKXQT/0SxkHSPemEFWp3ge83w9n1ejyTqHBJsYPSGLB6r3sT83BbNKw6/4/ON3dnHENQ8g8U8hfGywvv5uznA9hfxzFpxnBJ3FD4ZoD554zqGngxMAiSx+amTLPtj4VbLe3wIbZ57ruYFeSv/lphpBw5luuBvAEPVersSnJlzfiT39oQfqHIZhVUakgbdAUylri51iY59PFicm3bJoG3c2H6BR0FLN2NktWK07CMSg7KtWrW1i3ofJt6Acy+TU1h7yCBnTUTvtN2Dlbhnzs+9djoPSXBzeZ1C1E1an38/DatYwO6LY4leHO8MvILiwz2HnLyC5EAbNyBnHGGeZZTLki89/8HVNyMebt9pY8kzWWbfbmntfcH/xFyohTuSrMqTQO6/Ge1udme2tOOyL5pag1n9r7lLpPWd22/urcHQQ/svTyXHezvTWf2ftwz7AOaL8somFxl6Y7GLtpAM4SWy85dJ8uTlVirFPh+vmHGHRPF25Jfr9XKEVE/lEWZHXD5jz7/dE7K9XNqRd5/uD8tqQ1A8E9Rvm7ixAiAOp9C++eEZ2w2Yp8xvCqm/ciwucjl3Cm5pz9gJwQvsanNVQqg/Ecc+EKnSZynaGe5BIbZj6wXEMn83xMXi06Ezq/2FuXSkTxTrKJbxhCkAGfBJrgIAMRoUFk5p7NStWAHpc38lvn7mkb3td1X8dq03GcOuATPBxKQ1PKK9A4fQOUcnrGLP1No/CJO16t2vKWeFMKIjUrL0YvKXXtUt3C7jKUsUoNyolt88cyhidEFan3AS8sJIjJQ9tXeHWQquC9iLAGRDcIJt9ir1Brz9tHll44MdDKdNozj6+ksgLhzqLmfhNMspzhnm5TpSDLGeH3OG/p2YXERgVj0PAsjHxlUjwjr27D9A+3kpVrIzoqmKf+dCUxUSF+rzF+QBK6w8mW39N9vgzYipwsWL2X8V7rOzqVhq6MmAy+i3CXzsihVMDxexy+r5975Rs8CwX4m3dYKummHLV5DE8mzIu6rt4HvNrA3yLCocEm/vvZbz6LTZfHuzXk3dpz0zSwOg0E4cSI68PfrkzsKmrqaamVNCtnEA82+Jpog4UsZzizcgb5vG7QwBxkxF7k8AlMeQV2erZPKPWeZt5TuqvTn9BgE1OGdcQ6WOfRt9ZRaD87Z/Dg8VzUn24lJTWHBgXHOEYCelERXc1HPAtLV3RNz7IWuXY/LjeTVflvsbmmUJj8rppzLrV5DE8mzIu6TgJeLVDWIsK3D26H0aixdW+637l65/KRpRddzUd85rIpBb8WtSy3heYer3OqsxPhwRXcSpYiyGTgP4/0595Xf/QJSgaDISDZrqHBJrpeFueZuuEeZ13441E2nuiGU3VDA0I0OxpOupbIFq3wdkt+MlBtysieosRSGagl/+3vHk40ns0e5TuVpAJl8bcws7JbXZvqnjqAIa4lmqbhSE+p9laWTJgXdV29T1qpzdyB8NX7+9Hj8vjzWjbLhmsum3cySqYzvMyWnFtcwxBemtKHnu0TSr3mVGAo8RvjnlPWqU2sz/MlH1+I8QOS6Nk+gUbRofRsn8D4AUk+454KCI2KpKU5q9S5FW1dleyKzHBG8EL2cBZZ+rDZ3hqr0+RTl95d4GVNurdh5o2cwdiU0W/r0ee/AJqBwnXzS+0obl17dkFqx6FNFB3ciMo9TdH+9eR//He/O5BbbTpzVuziqdk/M2fFLqw2vdQx56s6d4MXoipIC68OcHfvTTnww3m19Nxjet4JJiWnCnjr3SHB0yobPyDJb8syyGjA5jz7nDuw3T64HSajRkpaPq0uiWBcAJN//LWAS26emtSsITEnLKXOrWgLz/v4zfbWLLT0IzrSTJgGC3P7+Sz1lqpHu1p957jGrqKmgKuFDJrf7s58ZzARmg0zevG1nOj715OfsgVTq26E9psARJbapULz+q/Kz8C65j3Crr/X87rVpvPCe2u5tmgN15nSSUmJ54X3ruavE/td0KIKsk2QqOsk4NUhJVfocE+nKCvDs2SG47kYNHyyJUODTbwwuRd/nbPBE/Q0DTq1jcVkNJTatDQ02MTkoe2Ji4skIyOvypOA/I17FnxgIMhrrz53mb15L2DtbzFrBZ5WsNFoYOY9fbDadP7+7kYW5pytyyuCPvQscF2SDRP/F3QNpTuAz97jhexhxcEQZjT8kBCD17V0G/qBn7ECzmFTzjnfRAMcR3f6PLdg9V6uK/rBM4YbZ8jDYHfy/lexnsn9leFvN3gh6pJ6H/CctgIKvnunTmSedWoT65PE0vXSOMxmI3uPZWMpKKJId2Iyamiadt5jft3bNSr17T8mKoRX7+/ns85kdS69di7+Wn2nHMHEGsvuunMq2GFvXmqSvDe7MnlawVnFUyjc656+/9Uedh7IBFwtuCu9koK8N6fdRyv+OvFsve3Rm9JFOztdZJu9pSfYlUkpHGn7OfnFf3DmpZ9Xd/bB47kMD0r16aZtH5TKkv0Z53EVP0XyWo4NTcPUvDMhV91Ra/9ehCip5j+5aljG1/+rM5ln7iSWigSfKa+U3/3pzrDs1CaW2we383tMXdmVG+CgnkC0IcWTqelEw8DZuXmZzggWWfrweIOVfqcPeHdFAkRHBXv+7e5WBjiTW8jUOXYUrkCiochXISg0UvRGHG1xA3296u3vb9sosq8pNXfRrWTwdFN56RTuPXewUwosTjMRdteu91abjsPhLDU6b9YcGB22MqcWlDflQNmtPnsnAugHN1JoMLq6OmW6gqgD6n3AK0zdW2cyz84n+HRqG8vmPb573UVHmrm0aUMOp+XVqtZaoHxnvArseALLF5auPNjga888wliDhVHhm1wLTxvyi7ctcgVChWvVmM9tvTAaNM88QX+mf7iV3CIT84uuLvVacJCBVwd18nmuebN4Fu3q55lnGdswBCx2zxeSJZZedDEfwVA8cb4ivLtjwx25nnG8Bav3kp+bR36DYILV2SkRBhS3RvyM9cf9OFK2AK4Nf626jbABD5Q75aBw3Xy/eyc60vbLdAVRZ1w8n3aVFNI0ifzs066gdxFlnt0x+HIAdh7IRNM0TyvuYgpwJT06vjd/naNhs3i3bM8mjBg0RUtTOrMsQ3Aq5TeZJ8RsZM5j/c95n6xcm9/n3RPsS9axv/FGwLN+ap7FQLYzjFhj6aSbshYPAN/MUkfKL+QvfoIrchqQFG7zu+dgx6AjOFKO+FzLcXgbAHraPp8vfvqBDVjB01rT0w6ULkdx+UpOV9D3ryc/bT9hQ5/GEBHjt66EqAkX76dfBcUNmkRhYdFFl3nm3QVXX7jHHJ97b5Nn14kUPd6rNedqxeXpQSzU/SfzqApk20RHBZfa1cJo0Ei+wv8yaWW1zN3PPfHf9RwsSiDacAhDBZaF89sKVE5U7mk6aqfB7P8Yv3OQit+vhua7zLhyoh/4mUJAdb+VrNwCGpa4twaoghxo1hln7mnXotju5/PSKfhiGhG3vuTvrkLUiHof8AzBYYT94a4aXVpMBE5osInnJyZ7EkaONh5C95CN5B3bS4oez4qic89D7NS2/PmDT/3pylLZq8lXNLqgsU73uJ57t/SS8aqiE9c1QPk5pqwgqjRw5p/xfzGl0E/uJW/J32hIfqkEHQDlsGM5vAeT00iw5vDNeM1LJ2/ORDCaMbXoIgkuosZpqiJfaWuxrCwLun5+GYlumka1pdHXB3WhPues2OWzaku3dvGlpllUpNu35C7pFzIe+uTb60nPOdtiHBe+lh7mQ6VXbykeAyxrSoU/np+D5vMfn9e1oGBo2gl1eHOF11/1d4/yymK6tE+Nju3Vhd/PuqS21KfJZCA6upysZ/exVVwWv7KysnjsscewWq20a9eOZ599tiaKIeqhstYtPV+BzF5t26yBT8D72JKMASddzIc9exK6tm1qjo7JM/bYKegIwTjKT3TRylwf23WubqPo8DYMXnsdljrGS2UWxQbQU7ag+lpLtfK8M0TdS6fppw+6bmTNc231ZAySVqK4YDXSwnv77bdp3bo1gwYN4oknnuDOO++kXTv/afHlkRZe7SH1WTlWm85f/r0We4lpJN6ru/hbKefZBsv8Jrp4K6t1VtZSZ1B+a86JazywrOPO1SLUIuMJHznVJ2hZv3/Hk+VZngtpJcrvZ2DVlvqs9S288ePHExzsmuPkcDgwm8te7qqqKLsV67r5HM04BHGtZe6QqDGhwSZenNyLZ+Zs8Al6JVfKiY0K5u17+3Imt5Bn5mwonnd4NtEF/LTGiv/P3y4Q59rpocyApcEZRwQaqlQmqM99ywq0eenkvz8FY8tuhF4zCXC1/CoS7AD0tP0VOk4If6o84C1evJjly5d7Ho8ePZrRo0cD8H//938UFhbSunXrqi5GKZY183Ac2oABhTPrFA6HIuL6u6u9HEKAK8P0tfv78f5Xe0rNnwRXsHt6fDfPsQ0jgvk4y5Xo0tKUzlE9llam08QYCnySS361N6WD+bhnjp97HU+LCi6zdXiuBBmnck2u/9iSzJMNPvfcz3ulma32FgCuyfT4v47j8Bby399y/hVlzUXZS3eLClERVR7wxo4dy9ixY0s9v2bNGubOncvs2bOrugh+5R7ZQ2RxIrYBRe6RPUTUSEmEcHFPJTEZvRNrNHq1b8QkP4tn/5xl9d0NHjt/DN9QvPqLawWXpdZeBFmKSu1pODR8GzGG0okx4H8vP6XAgcZWeytP1+qMnJsZFb6JVqazy925g6ENMy1NGcQZ8wNbSbqNwnXzZWK7qJQa6dLcu3cvb731FnPmzCEyMrImikCKHk8Hcjzzs1L0eJrUSEmE8OWdWNO+dSyj+5fuAfG3m4UNM/MtZ1d/CQ4y0KFtLFv2pXv2NHRzJ8ZcaT7sWYQczibHrLR04Znoz8/uzKCB7jSy0NLPtUWUs/zFyQ/prhVtzme3ipL8tTT1/evJO/E72Cyypqc4LzUS8ObMmUNOTg733XcfAI8//jidOnUq56yyVeYPan/jG7AdWUELUzpH9HiOtriBfhfwhynKmRgtKiwsxMRdQ9u7lkOLjSQzs3RSQFiIiRfv6sWLC7aQmVN65ReDBi/e1YvQYBPB3xjYl5pTvKmvIivXhk25gqMTA93NKZ4vfr/YW3mCmF2Z/O4IEWQ0YHc6KStPIcikUaQrv9mm5Sm5AW++CiHW4Op69TnfcnbuoH5wI5a0/WA0YUxoS2g//+PxJX8/vTfWPdd5wr+6+Pde5+fhVVZBYRH/+3gzLY58QStTOnGXdeCSG+/CEBxW00UT4rxlZBfw1FvryMi2EtcwlOn39SWuof/fZfexp84UnDMT9LbwNZ5FrZWCrfaWzLNczVVdmmAyGvj9SBZOp+L0mQJP8EuICWP6fX2Zt2oP63eewFbk9NyjY9BRQjS9zA/IkuuausvyavR8v9MlymKIiiW0aTtsJw8S0jSJuEGT/P5dn/58Fvm/rqE4hQdTwwSaTnpZPgMuYpUOeK+//jrp6em88MILAPz000+8/PLL2Gw2GjduzIwZM2jUqFFAC+tPVpbFtTp8JVi/f4ei/a50aKfSOBJ2BZeN+ctFvd5kVTpXi0Scv6quz8feWkemn3VBzSYDdt3pNxhGREXyz0k9PX8jVpvOgm/2cuB4Lm0Toxg/MMnntb+8udbT7RqMnenRi326UOHsmOHOouZ+Nyn+W4PlngXAK8VkJnzEP7BvX4FKP4QW35rgHqPIX/I06CXev2bA1LoHoVdLF2l5asvfu9FY8WkJ5x3wUlNTmTZtGmvXrmXIkCG88MILnDlzhhtuuIF58+aRlJTEvHnz+PHHH5k7d26l3sD5uJB5eHmLnoC8swPu6Y5I/q/ZPXVmO5zaprbMy7lYVHV9nskt5IUFv5CVawdcCTJdL43jzpsu54OvfvfZe9H1Orz58NXn9YXwTG4hT89eT5HD9fiO8B9cu8Vr7jl9GtvtLVhi6VUq0LlFYeGvDT8ttXTZBfG3GaK3iFgiRv1Lgt451Ja/9yqdh7dkyRL69OnDpZdeSnq6K3167dq1JCUlkZTkGmwfO3YsM2fOJD09nfj4+PO9RbU5XBRDC3Xa87t/RI/l4PHcmi6WENUiJiqEV+71n3Ry++B2HDye49MC9LdJcEXu8fqDV7Ng9V427j7FIksfirxWiynZorvysliCzSb2p+YAkGexk1sUzrPZoxkbvt4VLMEne7RSQbC8T+j8TPKX/pWI0S9I0LuInHfAe/TRRwF48803Pc+lpaXRuHFjz2Oz2Ux0dDQnT56s1QEv31rk81jDle4tRH0XGmxi6p97llovtLLXcvea/PzbqXNmdqamFzD97t6ex1abzrNzN5KZCx9YrmGxxXvqhRNQBBePwQU8ecJyhvz3p7i2DWvRldBrJknwq+MCMlillELz89tmMPjdkKTWaGHKRCvuatE0aG9OJbl/85otlBC1RKB3ux8/IAnd4WTngUycTqenm9NN00p/4XQHXveWTyWnXoD3/MMjhJRIbjmfDXXLPFY50d0T5cMaQkG2BME6KiABr0mTJmzYsMHz2G63k5WVRZMmtXtmW3pQEyL0bM8verCmo21aANdNqdmCCXER8rdHo79dJ/yd9/zEZOau3MW2fZmlpkOUFQQr2gXqngJhxlHmyjBa8XFYij8vlNP/ajGaJtsh1WIBCXh9+/blX//6F/v27eOyyy5j6dKldO7cmZiY2r3b8TJrT/7CHkzuLhFAP7KjZgslRD1S0VZkaLCJ+0d09nmuZNKNNxtmTxfon8LX0snsWn2m5Bqi7mD3QvZwAFdyTBk7UFSotagU6Db0gxvJP7jR9zVTsATCGhaQgBcTE8Nrr73Gk08+ic1mIzY2lpkzZwbi0lWqeWIceqoRk9fk2iLdcY4zhBC1RcmkG6tN5/2v9rDzQCYAocFGsvPhPcsfoHjZUH/Lry2x9MKOGQVlJscEhG6j6MBGig5uPLtdkymYsFuewxhdu3vDLhZ1fuL5hUxLKLTrbJrzAl1MKZ5MzV20pvfdsj9fZdSWNOWLhdRnYLi7TfceyyYrx1aqS9RsMvDiXb0APDtW+BsXDGTw815RpixOoEiZPEHZO5vVoEHXS+O586bLa2zecG35/TyfaQn1OuBpGnz41a8k7PvEs8TYkRZDmHjzlQEuZf1QW/4ALhZSn4GlaRAWEcIrCzaz40AmmqbRqU0stw9u5zNZ/v2v9rBjfwZ23VXpUVh4uMGXxBgKAFe3qPcaoxXd8b2yzvdn70Rjp70Ziyx9ypzbGAiaBnENQrm0aRTjKrmRciBIwKsg9x/AG4u2cOACd8AW8gEdaFKfgVWZ+rTadL/JMt6r0BzVYzHipF1QKsGa0+/u8tW93mRd+n1xonHM3JY2ox4krBKbCUjAqyD5QAksqc/AkvoMrEDWp7sluH1feqnpFd6isPBQg6+IMVh8WoVwAZPmL0JKweGw9nSa8Ph5n1vrdzwXQoi6zN8UC39c44et2Z+ag9FhZbDzRzqZj2FAoQBDGYG3vgVCTYMGBceq/D4S8IQQooqUnnZxXaljvOciJjUOZoRpDc7U7b7BUDs7bqg8/3fxtBaVgpywZlV+Hwl4QghRg0oHxfKT5pTdinXNeziO7gQUWnA4FOaDo/ScxEDzDriB4B7Dazv8nsBdtAwS8IQQoo7RzKGEXX9vzZYhgGOiDQNSovLV7sUuhRBCiACRgCeEEKJeqPNdmkbjhcfsQFxDnCX1GVhSn4El9RlYNV2f53P/Oj8PTwghhKgI+aojhBCiXpCAJ4QQol6QgCeEEKJekIAnhBCiXpCAJ4QQol6QgCeEEKJekIAnhBCiXpCAJ4QQol6QgCeEEKJekIAnhBCiXpCAJ4QQol6otwHvp59+YtiwYQwePJiJEydy+vTpmi5Srbdo0SKGDh3KzTffzJgxY9i5cycAc+fOZfDgwQwYMIDnn3+eoqIiAJxOJzNmzGDQoEFcf/31/Pvf/0aWbi1tx44ddOjQgbS0NAA+++wzbrrpJgYNGsTDDz9Mfn6+59iy6lrA/v37mTBhAsOHD2fEiBFs374dkPqsrG+//ZahQ4cybNgwxo0bx8GDB4E6/veu6qHMzEyVnJysfv/9d6WUUh988IG68847a7hUtduWLVvUNddcozIzM5VSSn333Xeqb9++6ocfflCDBw9Wubm5Std19eCDD6rZs2crpZRauHChGj9+vLLZbMpqtaqxY8eqFStW1OTbqHUyMjLUsGHD1GWXXaZOnjyp9u3bp3r37q3S0tKUUkpNmzZN/f3vf1dKqXPWdX1ntVpVv3791Ndff62UUur7779X11xzjdRnJVmtVtWxY0e1f/9+pZRS8+bNU+PGjavzf+/1soW3du1akpKSSEpKAmDs2LFs3LiR9PT0Gi5Z7dWgQQP++c9/EhMTA0CnTp3IzMxk9erV3HTTTURGRmI0Grn11lv55JNPAFi9ejUjR47EbDYTEhLCqFGjPK8J0HWdRx55hMcff9zz3Lfffkv//v1JSEgAYNy4cXzxxRc4nc5z1nV9t3btWuLj4xk4cCAA/fv35+2335b6rCSHw4GmaeTk5ABQUFBASEhInf97r5cBLy0tjcaNG3sem81moqOjOXnyZA2WqnZr06YN/fr1A1xdFy+++CLXXHMNJ0+e9KnLSy65xFOPJ0+e5JJLLvH7moCZM2fSs2dP+vbt63nOX30WFBSQnZ19zrqu71JSUmjUqBF/+9vfGDFiBLfffjt2u13qs5LCw8N5/vnnuf3227n66qt59913efzxx+v833u9DHhKKTRNK/W8wVAvq+O85Ofnc//993P8+HFmzJgBUKou3Y/91bPUscuKFSs4evQoU6ZMKfWav99N93Nl1XV9p+s669atY/jw4Sxfvpw///nP3HXXXei6LvVZCXv37mXWrFl8/vnnrFmzhr/97W9MnjwZp9NZp//ea1dpqkmTJk04deqU57HdbicrK4smTZrUYKlqv5SUFEaNGkVERAQffPABUVFRpery1KlTnnpMTEws9Zr3t8P6bNmyZRw9epThw4czbNgwAP785z/TqFGjUnUWHh5OgwYNzlnX9V1CQgItW7ake/fugKtL02Qy+a0zqc/yrV27lo4dO9K6dWsAhg4disPhwOFw1Om/93oZ8Pr27cvu3bvZt28fAEuXLqVz586e8SlR2okTJxg3bhyjR49m5syZBAcHAzBgwABWrlxJbm4uTqeTxYsXe8ZRBgwYwPLly7Hb7RQWFrJs2TLPa/Xde++9x6pVq/jss8/47LPPAFf226BBg/jxxx89HxwLFy7k+uuvx2AwnLOu67urr76akydPejIzt2zZgt1u5/rrr5f6rIT27duzZcsWT+bw5s2b0XWdO+64o07/vZtqugA1ISYmhtdee40nn3wSm81GbGwsM2fOrOli1Wpz584lNzeXzz//nM8//9zz/DvvvMPIkSO59dZb0XWdK6+80tNN98c//pHU1FRuueUWioqKuP766xk5cmRNvYU64dJLL+WJJ55g0qRJFBUV0apVK6ZPnw64PtQPHjzot67ru7i4OGbPns2LL75IQUEBRqORN998k3bt2kl9VkKvXr247777mDhxIkFBQYSFhfH2229z5ZVXcuTIkTr7964pVdsmSgghhBCBVy+7NIUQQtQ/EvCEEELUCxLwhBBC1AsS8IQQQtQLEvCEEELUCxLwhBBC1AsS8IQQQtQLEvCEqCdSU1NJSkrizJkzNV0UIWqEBDwhhBD1ggQ8IWrQgQMHmDhxIsnJyQwaNIjFixcD8NRTT/H3v/+dsWPH0qVLF8aOHetZ+xVg48aNjBkzhm7dujF48GCWLFnieS0/P59nnnmG5ORkevbsyZNPPklBQYHn9SVLljBw4EC6dOnCQw895POaEBczCXhC1BCLxcLEiRPp06cP69at44033vBsWgrw6aefct9997Fp0ya6d+/OPffcg91u5+DBg0yaNIlbb72VjRs3MmPGDF577TVWrlwJwPPPP09qaipffvkl3377LSdOnODVV1/13PfQoUN8+umnfP3112zdupVly5bVyPsXorrVy8WjhagNfvzxR0JCQpg8eTIA7dq1Y9y4cXz00UfExMQwePBgrrrqKgAeeughFi5cyNatW9m4cSPdunVj+PDhAHTu3JkJEyawbNkyBgwYwFdffcW8efOIjY0F4KWXXqKwsNBz3ylTphAWFkZYWBjJyckcPXq0et+4EDVEAp4QNeT48eOcOHHCs4cbuHaTb9q0KTExMbRo0cLzfFBQEHFxcWRkZJCZmUliYqLPtZo2bcoXX3xBTk4OdrvdZ1839y7UqampADRs2NDnug6HoyrenhC1jgQ8IWpIQkIC7dq18+lSzMzMRNd1XnvttVKbFKenp3PJJZfQuHFjNmzY4HOtY8eOER8fT0xMDEFBQaSlpZGQkADArl272LhxY63bm0yI6iZjeELUkGuuuYa0tDSWLFmCruukpaUxceJE5syZA8CKFSvYtm0bdrudV199lYSEBLp27cqQIUPYvn07n376Kbqus2PHDhYsWMDw4cMxGo0MHTqUWbNmkZ2dTW5uLi+//LJnI08h6jMJeELUkKioKObOncuqVavo06cPI0aMoFu3bjzxxBMA9OjRg5kzZ9KrVy9+//135syZg9FopFmzZsyePZuFCxeSnJzMo48+yn333efZbPOvf/0riYmJDBkyhIEDB9KsWTMeffTRmnyrQtQKsgGsELXQU089RVhYGM8++2xNF0WIi4a08IQQQtQLEvCEEELUC9KlKYQQol6QFp4QQoh6QQKeEEKIekECnhBCiHpBAp4QQoh6QQKeEEKIekECnhBCiHpBAp4QQoh6QQKeEEKIeuH/AUAVcRrXHEJMAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
train/loss_rec_stepstepval/loss_rec_stepval/reconstruction_lossval/loss_rec_epochval/nval/commitment_losstrain/loss_rec_epochtrain/reconstruction_losstrain/commitment_losstrain/n
epoch
0.00.81656291.3657531.3628121.373674154.00.0108620.8128190.8018110.011008307.0
1.00.815083190.9561540.9594790.968225154.00.0087460.8108230.8014880.009336307.0
2.00.813955290.8299020.8356340.843351154.00.0077160.8095810.8012560.008325307.0
3.00.813080390.7986300.8053510.812484154.00.0071330.8085120.8009760.007536307.0
4.00.814331490.7958940.8013820.810269154.00.0088860.8084520.8005930.007859307.0
....................................
835.00.21158883590.5043200.5146530.521022154.00.0063690.3249220.3186320.006290307.0
836.00.21134683690.5041620.5146250.520995154.00.0063690.3248690.3185790.006290307.0
837.00.21134483790.5041620.5146020.520971154.00.0063690.3250050.3187150.006290307.0
838.00.21133983890.5041650.5146080.520977154.00.0063690.3249830.3186930.006290307.0
839.00.21133983990.5041650.5146080.520978154.00.0063690.3248640.3185740.006290307.0
\n", + "

840 rows × 11 columns

\n", + "
" + ], + "text/plain": [ + " train/loss_rec_step step val/loss_rec_step val/reconstruction_loss \\\n", + "epoch \n", + "0.0 0.816562 9 1.365753 1.362812 \n", + "1.0 0.815083 19 0.956154 0.959479 \n", + "2.0 0.813955 29 0.829902 0.835634 \n", + "3.0 0.813080 39 0.798630 0.805351 \n", + "4.0 0.814331 49 0.795894 0.801382 \n", + "... ... ... ... ... \n", + "835.0 0.211588 8359 0.504320 0.514653 \n", + "836.0 0.211346 8369 0.504162 0.514625 \n", + "837.0 0.211344 8379 0.504162 0.514602 \n", + "838.0 0.211339 8389 0.504165 0.514608 \n", + "839.0 0.211339 8399 0.504165 0.514608 \n", + "\n", + " val/loss_rec_epoch val/n val/commitment_loss train/loss_rec_epoch \\\n", + "epoch \n", + "0.0 1.373674 154.0 0.010862 0.812819 \n", + "1.0 0.968225 154.0 0.008746 0.810823 \n", + "2.0 0.843351 154.0 0.007716 0.809581 \n", + "3.0 0.812484 154.0 0.007133 0.808512 \n", + "4.0 0.810269 154.0 0.008886 0.808452 \n", + "... ... ... ... ... \n", + "835.0 0.521022 154.0 0.006369 0.324922 \n", + "836.0 0.520995 154.0 0.006369 0.324869 \n", + "837.0 0.520971 154.0 0.006369 0.325005 \n", + "838.0 0.520977 154.0 0.006369 0.324983 \n", + "839.0 0.520978 154.0 0.006369 0.324864 \n", + "\n", + " train/reconstruction_loss train/commitment_loss train/n \n", + "epoch \n", + "0.0 0.801811 0.011008 307.0 \n", + "1.0 0.801488 0.009336 307.0 \n", + "2.0 0.801256 0.008325 307.0 \n", + "3.0 0.800976 0.007536 307.0 \n", + "4.0 0.800593 0.007859 307.0 \n", + "... ... ... ... \n", + "835.0 0.318632 0.006290 307.0 \n", + "836.0 0.318579 0.006290 307.0 \n", + "837.0 0.318715 0.006290 307.0 \n", + "838.0 0.318693 0.006290 307.0 \n", + "839.0 0.318574 0.006290 307.0 \n", + "\n", + "[840 rows x 11 columns]" + ] + }, + "metadata": {}, + "output_type": "display_data" } ], "source": [ @@ -1275,7 +1599,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 539, "metadata": {}, "outputs": [], "source": [ @@ -1284,7 +1608,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 540, "metadata": {}, "outputs": [], "source": [ @@ -1293,7 +1617,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 541, "metadata": {}, "outputs": [ { @@ -1309,9 +1633,9 @@ "text": [ "| | train | val | test | ood |\n", "|:--------------------|--------:|--------:|--------:|--------:|\n", - "| loss_rec_epoch | 0.56 | 0.627 | 0.607 | 0.589 |\n", - "| commitment_loss | 0.053 | 0.04 | 0.039 | 0.046 |\n", - "| reconstruction_loss | 0.508 | 0.587 | 0.568 | 0.543 |\n", + "| loss_rec_epoch | 0.364 | 0.521 | 0.508 | 0.439 |\n", + "| commitment_loss | 0.006 | 0.006 | 0.006 | 0.006 |\n", + "| reconstruction_loss | 0.358 | 0.515 | 0.501 | 0.433 |\n", "| n | 307 | 154 | 154 | 615 |\n" ] } @@ -1332,7 +1656,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 542, "metadata": {}, "outputs": [ { @@ -1353,7 +1677,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 543, "metadata": {}, "outputs": [ { @@ -1365,7 +1689,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1377,12 +1701,12 @@ "name": "stdout", "output_type": "stream", "text": [ - "torch.Size([5, 4096])\n" + "torch.Size([5, 16384])\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1398,7 +1722,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 544, "metadata": {}, "outputs": [ { @@ -1410,7 +1734,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1422,12 +1746,12 @@ "name": "stdout", "output_type": "stream", "text": [ - "torch.Size([5, 448])\n" + "torch.Size([5, 192])\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1444,7 +1768,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 545, "metadata": {}, "outputs": [ { @@ -1464,52 +1788,206 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 546, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "tensor([[[107, 44, 47, ..., 7, 55, 12],\n", - " [ 77, 74, 32, ..., 104, 61, 81],\n", - " [ 45, 103, 51, ..., 42, 63, 67],\n", - " [ 55, 8, 115, ..., 55, 87, 89],\n", - " [ 51, 1, 55, ..., 119, 41, 43]],\n", + "tensor([[[199, 269, 447, 352, 480, 119],\n", + " [340, 174, 376, 194, 22, 218],\n", + " [466, 159, 348, 25, 326, 64],\n", + " [306, 441, 38, 434, 111, 17],\n", + " [503, 210, 262, 437, 384, 313]],\n", "\n", - " [[ 91, 55, 120, ..., 127, 55, 12],\n", - " [ 18, 54, 82, ..., 110, 76, 61],\n", - " [ 66, 55, 55, ..., 55, 55, 118],\n", - " [ 55, 55, 115, ..., 101, 87, 89],\n", - " [ 8, 8, 24, ..., 99, 2, 7]],\n", + " [[381, 171, 345, 417, 39, 277],\n", + " [405, 174, 78, 160, 337, 418],\n", + " [125, 321, 55, 386, 126, 451],\n", + " [122, 65, 425, 36, 198, 17],\n", + " [250, 446, 132, 52, 384, 359]],\n", "\n", - " [[ 55, 55, 120, ..., 55, 55, 12],\n", - " [ 77, 74, 2, ..., 104, 61, 81],\n", - " [ 55, 120, 115, ..., 55, 25, 109],\n", - " [106, 17, 70, ..., 65, 13, 75],\n", - " [ 5, 55, 55, ..., 55, 41, 43]],\n", + " [[ 66, 269, 495, 475, 121, 257],\n", + " [ 16, 331, 474, 112, 337, 439],\n", + " [ 79, 34, 348, 220, 442, 440],\n", + " [157, 200, 314, 295, 86, 104],\n", + " [385, 359, 406, 14, 468, 3]],\n", "\n", - " ...,\n", + " [[153, 192, 211, 270, 480, 461],\n", + " [151, 174, 297, 194, 243, 481],\n", + " [207, 254, 286, 25, 493, 80],\n", + " [306, 75, 242, 167, 111, 141],\n", + " [148, 210, 482, 19, 491, 313]],\n", "\n", - " [[ 91, 27, 120, ..., 127, 55, 6],\n", - " [ 77, 74, 2, ..., 104, 61, 81],\n", - " [ 66, 55, 55, ..., 50, 55, 118],\n", - " [ 92, 33, 57, ..., 79, 35, 27],\n", - " [ 55, 50, 55, ..., 55, 41, 55]],\n", + " [[298, 192, 13, 214, 177, 429],\n", + " [486, 48, 147, 144, 496, 358],\n", + " [371, 317, 354, 377, 373, 80],\n", + " [183, 366, 164, 402, 193, 188],\n", + " [ 61, 210, 482, 202, 46, 359]],\n", "\n", - " [[ 91, 55, 120, ..., 127, 55, 12],\n", - " [ 77, 74, 32, ..., 104, 112, 81],\n", - " [ 79, 120, 46, ..., 52, 25, 109],\n", - " [ 55, 8, 115, ..., 31, 87, 89],\n", - " [ 6, 50, 22, ..., 50, 49, 43]],\n", + " [[ 66, 228, 27, 459, 413, 119],\n", + " [ 16, 331, 474, 112, 337, 439],\n", + " [ 79, 138, 35, 143, 350, 308],\n", + " [102, 200, 105, 295, 86, 216],\n", + " [483, 359, 70, 31, 468, 313]],\n", "\n", - " [[ 55, 50, 55, ..., 55, 58, 12],\n", - " [ 77, 74, 32, ..., 104, 112, 81],\n", - " [ 6, 55, 46, ..., 31, 50, 109],\n", - " [ 51, 8, 115, ..., 101, 55, 89],\n", - " [ 51, 1, 83, ..., 119, 27, 43]]])" + " [[381, 502, 345, 459, 136, 166],\n", + " [ 16, 347, 474, 51, 337, 439],\n", + " [161, 159, 304, 143, 350, 308],\n", + " [102, 200, 105, 342, 382, 104],\n", + " [148, 210, 275, 19, 468, 359]],\n", + "\n", + " [[ 84, 458, 447, 472, 480, 173],\n", + " [327, 48, 484, 497, 170, 165],\n", + " [466, 81, 361, 25, 87, 80],\n", + " [183, 200, 246, 167, 193, 45],\n", + " [250, 446, 74, 52, 491, 359]],\n", + "\n", + " [[404, 163, 88, 475, 121, 113],\n", + " [340, 504, 372, 160, 337, 287],\n", + " [ 79, 159, 304, 220, 350, 308],\n", + " [102, 394, 21, 342, 86, 462],\n", + " [250, 446, 275, 52, 398, 203]],\n", + "\n", + " [[199, 228, 495, 294, 426, 257],\n", + " [340, 174, 332, 160, 337, 439],\n", + " [ 79, 159, 35, 353, 350, 440],\n", + " [102, 455, 230, 342, 428, 104],\n", + " [483, 210, 406, 19, 468, 359]],\n", + "\n", + " [[168, 163, 88, 300, 121, 166],\n", + " [340, 504, 372, 160, 337, 287],\n", + " [ 79, 159, 304, 220, 350, 308],\n", + " [102, 394, 21, 32, 86, 462],\n", + " [369, 252, 275, 52, 398, 203]],\n", + "\n", + " [[381, 488, 379, 352, 136, 328],\n", + " [ 16, 347, 58, 112, 337, 439],\n", + " [125, 159, 354, 217, 493, 281],\n", + " [306, 510, 105, 127, 428, 141],\n", + " [483, 210, 406, 437, 468, 203]],\n", + "\n", + " [[255, 171, 290, 475, 453, 461],\n", + " [ 16, 331, 332, 112, 337, 439],\n", + " [161, 159, 354, 143, 443, 308],\n", + " [249, 436, 105, 36, 86, 97],\n", + " [483, 252, 73, 19, 397, 313]],\n", + "\n", + " [[ 66, 228, 334, 459, 39, 166],\n", + " [ 16, 331, 474, 51, 337, 439],\n", + " [ 79, 34, 348, 220, 178, 440],\n", + " [157, 200, 105, 342, 86, 104],\n", + " [483, 359, 275, 31, 468, 313]],\n", + "\n", + " [[272, 92, 211, 352, 435, 2],\n", + " [340, 244, 376, 144, 496, 218],\n", + " [207, 159, 348, 25, 383, 80],\n", + " [122, 341, 38, 36, 428, 17],\n", + " [148, 252, 262, 343, 384, 313]],\n", + "\n", + " [[153, 338, 13, 456, 177, 429],\n", + " [486, 20, 484, 283, 359, 389],\n", + " [161, 94, 304, 217, 442, 213],\n", + " [182, 24, 246, 167, 193, 462],\n", + " [ 61, 252, 90, 238, 468, 146]],\n", + "\n", + " [[404, 92, 88, 459, 177, 312],\n", + " [ 28, 347, 85, 144, 115, 508],\n", + " [125, 94, 288, 217, 350, 427],\n", + " [182, 155, 246, 176, 76, 141],\n", + " [ 61, 501, 253, 279, 468, 54]],\n", + "\n", + " [[381, 502, 345, 459, 136, 166],\n", + " [ 16, 347, 474, 51, 337, 439],\n", + " [161, 159, 304, 220, 350, 308],\n", + " [102, 200, 105, 342, 382, 104],\n", + " [503, 210, 275, 19, 468, 359]],\n", + "\n", + " [[ 66, 228, 334, 459, 39, 119],\n", + " [ 16, 331, 474, 112, 337, 439],\n", + " [ 79, 34, 348, 220, 178, 440],\n", + " [157, 200, 105, 295, 86, 104],\n", + " [483, 359, 275, 31, 468, 3]],\n", + "\n", + " [[267, 248, 379, 103, 395, 277],\n", + " [292, 224, 85, 497, 170, 324],\n", + " [291, 285, 55, 82, 152, 240],\n", + " [102, 65, 242, 273, 198, 17],\n", + " [471, 446, 482, 52, 491, 313]],\n", + "\n", + " [[168, 228, 13, 270, 395, 119],\n", + " [236, 504, 474, 189, 99, 276],\n", + " [291, 94, 288, 217, 493, 427],\n", + " [182, 436, 314, 7, 86, 494],\n", + " [ 61, 359, 492, 202, 398, 146]],\n", + "\n", + " [[199, 228, 495, 241, 426, 257],\n", + " [340, 174, 332, 160, 337, 439],\n", + " [371, 159, 35, 353, 350, 440],\n", + " [102, 455, 230, 342, 428, 104],\n", + " [483, 210, 406, 19, 468, 359]],\n", + "\n", + " [[199, 502, 13, 475, 223, 119],\n", + " [340, 131, 4, 283, 337, 439],\n", + " [161, 261, 354, 143, 443, 509],\n", + " [122, 455, 230, 295, 86, 104],\n", + " [148, 252, 70, 202, 468, 359]],\n", + "\n", + " [[ 84, 192, 345, 456, 39, 119],\n", + " [405, 244, 225, 194, 496, 460],\n", + " [454, 333, 130, 353, 489, 368],\n", + " [463, 366, 164, 402, 382, 401],\n", + " [ 61, 252, 482, 343, 46, 359]],\n", + "\n", + " [[272, 228, 13, 352, 177, 119],\n", + " [236, 131, 474, 189, 99, 218],\n", + " [161, 261, 354, 258, 493, 281],\n", + " [122, 436, 230, 127, 86, 104],\n", + " [369, 359, 73, 26, 468, 146]],\n", + "\n", + " [[272, 92, 290, 259, 336, 113],\n", + " [409, 59, 474, 283, 505, 418],\n", + " [125, 261, 288, 217, 493, 427],\n", + " [157, 510, 187, 32, 76, 494],\n", + " [471, 446, 275, 52, 398, 203]],\n", + "\n", + " [[255, 502, 447, 352, 435, 119],\n", + " [ 16, 507, 85, 189, 496, 450],\n", + " [207, 399, 286, 377, 442, 67],\n", + " [122, 200, 242, 127, 128, 141],\n", + " [414, 210, 73, 19, 139, 203]],\n", + "\n", + " [[168, 92, 13, 475, 177, 166],\n", + " [340, 504, 4, 160, 337, 287],\n", + " [125, 159, 354, 258, 493, 281],\n", + " [157, 394, 230, 7, 428, 494],\n", + " [250, 252, 492, 343, 398, 203]],\n", + "\n", + " [[ 91, 228, 13, 103, 395, 2],\n", + " [236, 174, 78, 144, 496, 450],\n", + " [ 79, 321, 424, 82, 126, 368],\n", + " [306, 441, 187, 273, 382, 17],\n", + " [471, 252, 262, 343, 491, 359]],\n", + "\n", + " [[199, 502, 13, 300, 39, 119],\n", + " [340, 131, 4, 283, 337, 439],\n", + " [161, 261, 304, 143, 443, 308],\n", + " [122, 455, 230, 127, 86, 216],\n", + " [148, 252, 406, 202, 468, 359]],\n", + "\n", + " [[ 91, 502, 345, 103, 136, 113],\n", + " [ 16, 347, 474, 51, 337, 439],\n", + " [161, 138, 304, 143, 350, 308],\n", + " [102, 455, 105, 32, 382, 485],\n", + " [148, 210, 492, 19, 398, 359]],\n", + "\n", + " [[168, 163, 495, 103, 339, 134],\n", + " [227, 331, 422, 194, 115, 508],\n", + " [371, 254, 348, 377, 178, 80],\n", + " [183, 394, 314, 295, 150, 216],\n", + " [ 61, 29, 90, 63, 398, 54]]])" ] }, - "execution_count": 283, + "execution_count": 546, "metadata": {}, "output_type": "execute_result" } @@ -1527,7 +2005,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 547, "metadata": {}, "outputs": [ { @@ -1539,14 +2017,14 @@ " | Name | Type | Params\n", "-------------------------------------------\n", "0 | norm | Affines | 0 \n", - "1 | ae | Tokenizer | 6.5 M \n", - "2 | probe_embed | Embedding | 16.4 K\n", - "3 | head | Sequential | 1.2 M \n", + "1 | ae | Tokenizer | 14.1 M\n", + "2 | probe_embed | Embedding | 262 K \n", + "3 | head | Sequential | 15.4 K\n", "-------------------------------------------\n", - "1.2 M Trainable params\n", - "6.5 M Non-trainable params\n", - "7.7 M Total params\n", - "30.666 Total estimated model params size (MB)\n" + "277 K Trainable params\n", + "14.1 M Non-trainable params\n", + "14.4 M Total params\n", + "57.639 Total estimated model params size (MB)\n" ] }, { @@ -1581,12 +2059,12 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 548, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1596,7 +2074,7 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAbQAAADmCAYAAAC9BXAOAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAvKElEQVR4nO3de1xUZf4H8M/MwCgEKDMIglpeyPG3LqF5TSyt9bYV4mquuOqqrZpublfzlmUmpZDGdltLMxUvaeRtNbXV15qJBhmm7doqXjLBABkYQBQGZ+b8/iBHZhiY2xlmOHzer5cvOTPnPOc535k53/M85znnyARBEEBERNTEyb1dASIiIjEwoRERkSQwoRERkSQwoRERkSQwoRERkSQwoRERkSQwoRERkSQwoRERkSQwoRERkSQwoRERkSQwoRERkSQwoRF52IEDBzBmzBj069cPvXr1wvPPP4/KykrMnz8fr7/+unm+//znP9BoNACAvLw8xMTE4LXXXkPv3r2xbt06GI1G/OMf/8AjjzyCPn36YOrUqcjJyTEv//3332PcuHHo2bMnhgwZgh07djT6thJ5k5+3K0AkZfn5+Zg7dy7Wrl2LPn36IC8vD+PHj8fevXvtLltdXY2AgAB888030Ov1eP/997Fv3z58/PHHaN++PT7++GM8+eST2LdvH4xGI2bMmIHZs2dj06ZNOHPmDKZMmQKNRoPu3bs3wpYSeR8TGpEHqdVqfPHFF+jQoQPKysqg1WoRGhqKwsJCh5ZPSEiAv78//P39sXPnTjz//PPo3LkzAOCvf/0rdu7ciSNHjsBgMEClUmHy5MkAgB49emDLli1o3769x7aNyNcwoRF5kL+/P3bs2IH09HS0aNEC3bp1Q1VVFRx9alN4eLj5b61Wi3bt2lm8365dO+Tn5wMAoqKiLN77zW9+42btiZoWJjQiD9q/fz927dqFzz//HG3btgUAJCYmAgDkcjlu3bplnre0tLTBsqKiopCXl4fevXsDAARBQG5uLsLCwqBQKFBQUGAx/5YtW9C1a1fz/ERSx0EhRB5UVlYGuVwOpVIJg8GA9PR0nD59Grdu3ULHjh2RkZEBnU6HsrIybNiwocGyRo8ejVWrVuHSpUuorq7GqlWrUFFRgcGDB2PQoEEoKSnBp59+CqPRiNOnT2PlypUICAhopC0l8j620Ig8aPTo0fj2228xZMgQtGjRArGxsUhISEBOTg5SUlLwww8/YPjw4QgJCcG0adNw9OjResuaNm0aDAYDpk2bBp1Oh9/+9rdYt24dVCoVAGDNmjVYtmwZVqxYgbCwMCxdupQDQqhZkQmOduYTERH5MHY5EhGRJDChERGRJDChERGRJDChERGRJDChERGRJDChERGRJDChERGRJDChERGRJPj8nULKyythNJpcXj409C7odDdErBExpuJjTMXHmIrPGzFVKOQICXHsFm4+n9CMRhMMBtcSmkx2pwzeD0UcjKn4GFPxMabiawoxdanL8e9//ztefvllm+/pdDrMnDkTjz76KIYPH45Dhw65VUEiIiJHOJXQ8vLy8PTTT2PdunX1zrNkyRJ07doV+/btw9q1a7F48WLz85qIiIg8xakux23btmHAgAG49957UVRUVOd9g8GAw4cPY//+/QCA9u3bY+DAgdizZw9mzJghTo1J8oTqSlQd2whj4QUoIqLRMm4SZErfewyKdT1b9HkC+hOfW9QbQIPz3J6+or0EhHV2qwwx6iGlMnw9pr5ar4bKqC+mjpTRGL9jl+62/95776GgoABvvPGGxetFRUUYOHAg/ve//0Eur2n8paamory8HIsXL3apgjrdDZcHhchkgFodjOLi6z7b59vUiB1ToboSlRl3vvQBAyehMmMjDBcyAcEEyORQdOoNmcLPYp7aPwxbZQCweK1l3ydQ9e3n9ZbhaN1qL3Pz36st6ikLUkOoKDZP+0X3B4AG57E3zTKkW4av1stTZfhF90fgI843bBQKOUJD73JoXlEHhdzOjbLbZw9/dTu5ucLRDWmIWh3sdhlkydWYmvQ3of3yY1TlnUPL9hoIRoP5S2+4roXQ0h/QXqr5EQCAYIIp9wcIhmqLedqMfMZc5rV/rqtbBmDxWlXRRRjKiszTJn8ZZAo/cz1Ugyeg5KvN5umw4dOg/XJrnXJrr/eKVT2FGyUW09BeuvN3PfPYm2YZ0i3DV+vlqTKgvYSwMM/ui0VNaGq1Gi1atMC1a9cQEREBACgsLER0dLTLZTb1Fpq9o3xv1gOA03VzNqbW64XJCMOlE4BgQkXpNcBPafGlv/nzWcgjugCl18xHdsKv792e58blH3Hls5XmMo0F5+uUIUCweM1QprUsIycbMFab63Hj8o/mI8yK0muoqroFY+GFBtcL1T0W9ZTdpbI4SkVY55plG5jH3jTLkG4ZvlovT5WBsM7Qaq/b32lY8VoLTaFQ4He/+x22bNmC559/HlevXsXRo0cxc+ZMt8p1NxkJgvtlOLwuq/MqtXfghutaVAIIeLjxzyfW7sa7XQ/AshVz02iw6NprqM/b0Zhar9c6gUFAzZf91y+9PKILWsZNQhUAY+FFKCK6WMQQMnmdesuC1HXKAFCzvts/uCCrH5wMlkeYFZZHmDXrjrYow3q9ik694Rfd31zPO+cRaqbN5xFqbYv1PLenUefchPNliFEPKZXh6zH11Xo1VEZ9MXWkjJZxkzy+HxblHFpCQgKSkpIQExODkpISvPrqq7h8+TIMBgOefvppxMfHu1xBne6GW9ehhYUFQ6ttvBZa5WHL8yrwUwK3qu7UKSQCQYnJjVOZWiq2zoVQfs2iHoBg8Rr8WppbLbf7vK2Tr7MxtV6v9TrunB+786W3TqJ3DhJq5jEWnIdwvdagpOA28Gt7b90fU61lrH9w1knS1jmAlnGTGlyvWJ+lN76nUseYis9bMfXz83AL7W9/+5vF9O7du81/q1QqvP/++64UKwnW3VTWLRDFr62Hxmbd2rhdD4sWiFWrxVh4Ufz13n2f3QRmTaYMsEislYdXw1A7+bS912ar1/q12tNCdSWq5IoGjzDtrddbnyUR2ebzdwrxddZdjIo2nezuwL0xLN26G89Wl4B1q0WMHbat9bq7rfVtizOskxVgvytYjPUSkee41OXYmHy9y9G6i9GRLjTrZWx17bnLlaRp3bVn69oSeYsAduWIjN1j4mNMxSfZLke6w7qL0aT92e55FetlxOjas1Z1zHIwRhXst0BsdrFZlWHvOpKmclE0EUkPE5qT7HYxOtBNZ31eSR52DyoPr3YrCVjXy3oouytJ0zrxGgrO4+a/V5vvFmCrnq4kUiIiMTChOcl6h209dNuR8yo2h6W7mQSs62U9lN2V82HWiVeGWlf+l16zWc/GaH0SEdnChOYkV7oYrVl37VVsnSt6a0oAnE601qwTryOtvvpGUxIReRoTmpM8scMWo0zrMuobyu4MR4at27pBL8CRgETU+JjQnOSJodtilNkYQ8pvrwO1zqFZd3UCPGdGRN7BhOYkW9cv+UKZnqiXrXUEPjLDYuguz5kRka9gQmsAh6Dbx3NmROQrmNAa4K0h6I4kUl9Jtrx7BhH5Cia0BnirO82RROor13s1RlcnEZEjXH/yZjOgiIg2PzakMbvTHEmkPHdFRGSJLbQGeKs7zZE7ifDcFRGRJSa0BnirO82RO4nw3BURkSUmtFp8ZaCFI3cS4bkrIiJLTGi1+MpAC2vsXiQiso8JrRZfHWjB7kUiIvuY0Grx1ZYQuxeJiOxzOqEdPXoUK1asgF6vR2RkJJKTkxEeHm4xz7lz57B06VKUlpZCqVRi5syZGDZsmGiV9hS2hIiImi6nElpJSQnmzJmDtLQ0aDQapKWlYcGCBVi7dq3FfLNmzcJTTz2FcePGQavVYuzYsejYsSO6du0qauXFxpYQEVHT5dSF1RkZGdBoNNBoNACAxMREZGVloaioyDxPSUkJrl69ilGjRgEAwsLCEBMTg3/961/i1ZqIiMiKUy20goICREZGmqeVSiVCQ0ORn5+PNm3aAABUKhXuvvtu7NixA+PHj0deXh6ys7PRunVrlyspk7m3nKvLU12MqfgYU/ExpuJrCjF1KqEJggCZja2Ryy0beqtWrUJycjK2bNmC6OhoDBgwAP7+/i5VMDT0LpeWq02tDna7DLLEmIqPMRUfYyo+X46pUwktKioKmZmZ5unq6mrodDpERUVZzGcymfDBBx9AqVQCAGbOnIn77rvPpQrqdDdgNJpcWlYmqwl+cXHNs7vIfYyp+BhT8TGm4vNWTBUKucMNG6fOocXFxeHHH39ETk4OACA9PR2xsbFQqVQW8y1evBj79+8HAJw+fRonT57E8OHDnVmVBUFw/Z+7y/MfY8qYNs1/jKk0YuoMp1poKpUKqampmDdvHvR6PdRqNVJSUgAACQkJSEpKQkxMDJYuXYpFixbh448/hr+/P9577706Q/t9ga/c6oqIiNwnEwRnc2Dj0uluwGBwvcsxLCwYWq3tJnLl4dXmW11BJodfdH8O27fDXkzJeYyp+BhT8Xkrpn5+HupylBpfvdUVERE5r1knNG89wJOIiMTXrO/lyFtdERFJR7NOaLzVFRGRdDTrLkciIpIOJjQiIpIEJjQiIpIEJjQiIpIEJjQiIpIEJjQiIpIEJjQiIpIEJjQiIpIEJjQiIpKEZnWnED4uhohIuppVQqs6ttH8uBjDdS2qAN76iohIIppVlyMfF0NEJF3NKqHxcTFERNLVrLoc+bgYIqpNEEx8orWDZDLAaDTCZBI/ZjIZIJO5375qVgmNj4shIgAwmUwoKSmEwVDt7ao0KUVFcphMJo+U7eenhEoVAbnc9cTWrBIaEREAXL9eCrlcjjZt2kMmk3m7Ok2Gn58cBoP4CU0QBJSWanH9eilatVK5XI7TCe3o0aNYsWIF9Ho9IiMjkZycjPDwcIt5CgsLsXDhQly7dg0mkwlTpkzB2LFjXa4kEZFYBEFAZWUF1Oq2UCgU3q5OkyKXy+FGA6pBISGhKC4uQEhIqMsHGU5VraSkBHPmzEFKSgoOHDiAhx9+GAsWLKgzX2pqKjQaDfbs2YN169Zh2bJlyM3NdamCRERiEgQBgMBk5mNqPg/h18/HNU610DIyMqDRaKDRaAAAiYmJSElJQVFREdq0aWOez2g0oqKiAoIgoKqqCnK53K0vj6s9AreXY4+CeBhT8TGm4msopndeY8B9S83nUTNAxLUSnEpoBQUFiIyMNE8rlUqEhoYiPz/fIqHNmTMHEyZMwIMPPojS0lLMnj0bUVFRLlUwNPQul5arTa0OdrsMssSYio8xFZ+tmBqNRhQVyeHnJ3drAEJz5efnmZiZTDVdmmp1kMsNIKcSmiAINvs2rb8UL774IiZMmICpU6ciPz8fkydPRnR0NIYMGeJ0BXW6GzAaXTsJKZPVfKGLi69zaK5IGFPxMabiayimJpMJJpMJBoPJY+eDGtPJk98hOTkJ27btMr82eXIiVq9ejxYtWoq6Lk8NCgHufC7FxRUWOUWhkDvcsHEqoUVFRSEzM9M8XV1dDZ1OZ9H6KikpwYkTJ7BmzRoAQGRkJIYNG4bjx4+7lNAAuP0jFwT3yyBLjKn4GFPx2Yqp1GN84cJ5tGvXQfRk1ljc+R04dXwSFxeHH3/8ETk5OQCA9PR0xMbGQqW6M8wyNDQU7dq1w969ewEAFRUVOHbsGHr06OFaDYmIfEil3oA1e89g/kffYM3eM6jUG0Qt//XXX8H69R+bp48cOYwZM6bgwIEvMGPGFDz55ESMHv0Y1q79yObyR478Gw89NBgA6l3m5MnvMG7cKPMyp0+fwhNPxAMA1q79CM8991dMnjwec+c+BwDYuHEdJk78IyZOHIcXXvgbcnOvAKjpvv3HP95BYuJoTJz4RyxaNBc3blSIGg9nONVCU6lUSE1Nxbx586DX66FWq5GSkgIASEhIQFJSEmJiYrBq1SokJSVh/fr1kMlkiI+Px8iRIz2yAUREjWnTwXPIOlMIkwBoSysBANMf7y5a+QkJo/Hmm0swZco0AMAXX+zG8OGPYseOdCxbtgJqdRgKCgrwxz+OxJgx4+osf/x4BlJTP0BVVZXDy1jLz/8FGzd+BqVSif379+Lw4UP48MNP0Lp1CHbu3IF5857Hxo2fYffuHTh9+hTWrduMgIAAvPXWm9i583NMnDhFtHg4w+nr0AYMGICdO3fWeX337t3mvzUaDTZu3OhezYiIfNDFq+Uw/dolZhJqpsUUG9sT/v5KnDp1Eu3b340zZ/6D119fjqFDR+CbbzKQl5eLy5d/+nUUeaXFslev5iE4OBghISEAgBUr3rW7jC3/93/doVQqAQDffHMMjz4aj6CgIABAfPwovP9+KnJzryAr6ziGDRuBgICax3C99NJCMUPhNAmcEiUiajxd2oVA/uvYOLmsZlpsCQmjsW/fHhw4sBe/+90wlJeXYcqU8cjLy8VvftMds2c/BwB1rtk6cuQwHnroYQDAtWuF9S4jk8ksljUYblmU07LlnfNvtm51ZTIJMBqN8PPzQ+3LH8rLy1BQkO/OpruFCY2IyAkTh2rQr3sEwkMD0K97BCYO1Yi+jhEjHkNW1jfYv38vEhLG4OzZ/yEwMBBTp07HAw8MRGbmcQiCUCfZHD36lfn8WUPLtG4diuJiLYqLtRAEAV9/fbjeuvTvPwD79u1BRUXNubF//nMngoOD0bFjJ/Tp0x+HDn0Jvb4KAPDhh+8jPX2r6PFwFO/lSETkhIAWfqKeM7MlODgYffv2x5UrP6NLl2i0b98e+/fvxfjxoxEYGIhOnbrg7rvvQW7uFXPXoFZbk5zCwmquCe7Xr3+9y/TvPwDx8X/A9OmToVaH4cEHB9Vbl8ceGwmttgizZj0JQRAQGqrCihXvQKFQYOTIP6Co6BqmTfszAODeezV45pkXPRqbhsgEd+4z0gh0uhsuX/cgkwFhYcHQanl9j1gYU/ExpuJrKKYmkwnXruUiPLwDL6x2kqevQ7P1ufj5OX4dGj9NIiKSBCY0IiKSBCY0IiKSBCY0IiKSBCY0IiKSBCY0IiKSBCY0IiKSBCY0IiKSBCY0IiIf88ILf0NR0TWnllm+fCm++SbDoXmXLXsd33+f7UrVfBpvfUVE5AShuhJVxzbCWHgBiohotIybBJkyQNR1fPvtN3VuPGzP/PmvODSf0WjEmTP/wdy5L7tSNZ/GhEZE5ISqYxthuJAJCCYYrmtRBSDg4Rmilb9kySIANa2069fLEBt7Py5duoDx4yehR4/7sXLlcty8eRNabRGiotrh9deXo3Xr1pg9ewbi40dh+PBHMXBgb0yfPguZmcdQVFSEUaPGmJ9Rdvr09+jePQYKhQJnz/6I99//O6qrq6HVFqFbt9/gtdfegFKpxMCBvbFjxxcID48AAAwa1A/p6buRl5eHt99OQUhICMrKSrFq1Sf44YdT+OST1TAaDfD3V2LatJno338AgJqHjG7evAFyuRwBAYGYO3chOneOFi1etbHLkYjICcbCC4Dw6/0MBROMhRdFLX/x4iQAwNtvvwd/fyU6dLgbmzal47HHRmLv3t14+OEh+PDDT/DZZ7shl8uxf/9em+X4+yuxatUnWL78baxZs8p8t/yvv/7K/IiZ9PStmDhxClavXo9t23bh559/wvHjR+3W8fLlS1i4cDE2b/4cpaUlWLZsCV59dSk2bNiK+fNfweuvv4K8vFxcunQB77yzEsuXv40NG7Zi1Kgx+PDDD0SKVF1soREROUEREQ3DdW1NUpPJoYjo4tH1xcb2NP89ffosZGd/iy1bNuLq1Vz8/PNl3HdfD5vL3b6DfnT0vRAEARUV1xEUFITvvvsWs2b9DQCwYMGryMw8ho0b1yM392eUlJSgstL+A0DV6jC0b98BAJCd/R169LgfHTt2Mq/vvvticeJEFvT6KvTq1Rvt2rUHUPNYnBEjHnM5FvYwoREROaFl3CRUATAWXoQiogtaxk3y6PpatLjzsM0lSxahsrISQ4YMR58+fVFVVVnvubYWLVqY/779QM+zZ39Ep06dze/Nnj0DHTrcjQceGIgHHxyEX365alHe7b+NRqPFs9ccewCooc4DQA0GA37++TK6dGGXIxGR18mUAQh4eAaCEpMR8PAM0QeEAIBCoYDRaKzzelbWcfz5z09i2LARCAoKxnffnbCZUOpT80TrwQCA69ev47///QFPPTUbjzwyBNXVepw9+yNMppr1tm4divPnzwEAvv76cL2Js3fvvjh5MhuXL/8EALhw4TxOnTqJ3r374f77++DUqZMoKCgAABw+fAhvvPGaw/V1ltMttKNHj2LFihXQ6/WIjIxEcnIywsPDze8XFxfjySeftFjmwoULmDFjBp599ln3a0xEJHGDBj2CZ56ZBZ2uxOL1mTP/hiVLFiE4OBj+/v7o2bMX8vKuOFzu8eMZmDhxMoCah4hOnTodM2dORatWrREYGIj77++N3NxcAMDs2c/hnXfexiefrEHPnr0QGRlls8x77umIhQtfxeuvL4LBYIBcrsDLLy82d0E+//xcLFjwAgQBCAoKwmuvveFKSBzi1AM+S0pK8Pvf/x5paWnQaDRIS0vDkSNHsHbt2nqXSU9Px9atW7F582aLZqqj+IBP38KYio8xFR8f8OkZvv6AT6daaBkZGdBoNNBoNACAxMREpKSkoKioCG3atKkz/9WrV7Fy5Up8+umnLiWz22Qy+/M0tJyry1NdjKn4GFPxNRRTxtm3yWSuf0ZOJbSCggJERkaap5VKJUJDQ5Gfn28zob3zzjsYO3YsOnXq5FrtAIczc0PU6mC3yyBLjKn4GFPx2Yqp0WhEUZEcfn5yttBc4OfnmZiZTIBcLodaHQSFQuFSGU4lNEEQILOROm19Ka5du4aDBw/iq6++cqlit+l0N2A0ut7lqFYHo7iYXTliYUzFx5iKr6GYmkwmmEwmGAwmMJ85x9NdjiaTCcXFFRY5RaHwUJdjVFQUMjMzzdPV1dXQ6XSIiqp7svDLL7/Eww8/jFatWjmzCpvc/ZELgvtlkCXGVHyMqfhsxfTONIPtW2o+D3d+B04ltLi4OCQlJSEnJwddu3ZFeno6YmNjoVKp6syblZWFQYMGuVYrIiIPkcvlUCj8UFFRjqCgENS+TooaZjLZvu7MfQIqKsqhUPi51Q3sVEJTqVRITU3FvHnzoNfroVarkZKSAgBISEhAUlISYmJiAACXL1/Gn/70J5crRkTkKaGh4dDpruHmzXJvV6VJkcvlHkpogELhh9DQcPszNsCpYfvewGH7voUxFR9jKj5HY+qpnbMU1ZyXDEJxcYVHvqf1tcw8NmyfiEhKOMrRcTJZzR1M5HK5zx548dMkIiJJYEIjIiJJYEIjIiJJYEIjIiJJYEIjIiJJYEIjIiJJYEIjIiJJYEIjIiJJYEIjIiJJYEIjIiJJYEIjIiJJ4L0cm4BKvQGbDp7Dxavl6NIuBBOHahDQgh8dEVFt3CvW4quJY9PBc8g6UwiTAGhLKwEA0x/v7uVaNS2++tkSkXia9S/aeidnNAr47uw1n0scF6+Ww/Tr3a1NQs00OYcHBUTS16wTmvVOTumv8MnE0aVdCLSllTAJgFxWM90YbLVqAls2za8MDwqIpK9p7p1EYr2TEwQBchkaPXHYM3GoBgAsEktjsNWqmRHfNFs13jooIKLG06wTmvVO7r5oNfwU8kZPHPYEtPCz2z3miXNEUmrVeOuggIgaT7NOaLZ2ck11oIAnzhFJqVXjyEEBETVtTu+9jx49ihUrVkCv1yMyMhLJyckIDw+3mEev1+Ott97CiRMnUFVVhVGjRmHWrFmiVVos9nZyTWlknCdaU2zVEFFT4tTeuaSkBHPmzEFaWho0Gg3S0tKwYMECrF271mK+lStXorCwENu3bzcntB49euCBBx4QtfKeZqvVM3GoxieTnCdaU2K0aprSQQERNW1O7VkyMjKg0Wig0dQcqScmJiIlJQVFRUVo06aNeb5du3Zh06ZN8PPzQ1BQENavX4+goCCXKymTubecq8vbavVstkpyMgDTfWCgxKRhGsgAXLhajuh2IZg4TOP0dlfqDdj0r3MWZdROPrff/ym/Ap0ig+q8b4uvxsuavW33JHe/p1QXYyq+phBTp36xBQUFiIyMNE8rlUqEhoYiPz/fnNCKi4tRVlaG7OxsLF26FGVlZRg5ciSmTZvmUgVDQ+9yabna1Opgl5br3lkN7cmrMAkC5DIZundW4+xlnUWS+6mgAmFhrpUvtgVT+7u1/NtbspFpTj5VaNHCHy/8qZfN9wtLbtZ535af8it8Nl612dv2xuDq95Tqx5iKz5dj6lRCEwQBMhvpWS6/c0tIg8EAALh48SLWr1+PsrIyTJ48GeHh4Rg5cqTTFdTpbsBoNDm9HFBzJKFWB6O4+DoEwfnlxw7qDL3+lvmofeygztikP4fCkhvmrr1ObYOg1V53qX6+5syl4lrJR8CZS8UW22bvfVs6RQaJHi9PtKZc2TaxuPs9pboYU/F5K6YKhdzhho1Te4GoqChkZmaap6urq6HT6RAVFWV+LTQ0FP7+/vjDH/4AhUIBlUqFwYMH4/vvv3cpoQFwO3iC4FoZLZV+mGZ1DmnCUA0E3BkoMfqhLli954wkzhHZOg9XO2723rfFOl4ThmrsLmPvvNvGf1l2YwrwzIjOxt4Ruvo9pfoxpuLz5Zg6teeNi4tDUlIScnJy0LVrV6SnpyM2NhYqlco8j1KpxCOPPIIdO3age/fuuHnzJo4dO4Y///nPolfeG6wHSqzZe0Yyt1SyN6px4tCa83Q/FVSgU9sgTLAx6tFWMnI2HvYuQfDWiE4OcCHybU79GlUqFVJTUzFv3jzo9Xqo1WqkpKQAABISEpCUlISYmBgsXboUb775Jh599FEYDAb8/ve/R0JCgkc2wNt89eJjV3a+9kY1BrTww/T47ggLC4ZWa7vbQYzr4ezF1FsjOnk/SCLf5vTh5YABA7Bz5846r+/evdv8d6tWrZCcnOxezZoI653rPW2DsGav97sgvbXzFSPB20tY3ro+znrbzueV+cRnTUQ1+Otzk/XO1WgUfOIo3lstRzFaT/YSlrfu+mG9bQDc/qwr9QZsPnjnUogJTIpELuMvx03WO9f5H33jdiIR41yNt25bJUbryVdvU2W9bRdyy9z+rGu3pAtLbjg0wMXe98OR7w/PB5IUNatvcGP8iMVIJGJ0F3prkIOvJiNrYpxjXLP3DIrLqxr8rO2tx5FuTAANPrfPYDRZ3FTb1nP9rO9wY6+MMQ91wfavLzLhUZPSrL6hjXFeSYwWihjdhRzk0LDGOmiwXo914ujYNthuN6b1a9bP7fvhQjFuGUwNPtfP3rP/rMs4n1eGkrKqBpOiddKzN20rOXuqjB1fXzR34472Yj18NT6ulNFQTB0pozEOippVQmuM80pitFA80V1oq6XgjfNs1vXwVkugsQ4arNdjnTh6dWuD/t0jzJdCnK+nG7Oh5/bJZDK7z/Wz9+w/6zJ05Xq7SdE66dmbvq0xyygsuYEcH6iHr8bHlTJsxdSRMgDPHzA3q4TmK49DsdcN5YlRfLZaJN6Ih72dIiDOl95ejBvroMF6PdaJ4+eCCiTPfMB8KcTqPba7MRt6bl/t7sP6nuu36eA5p8oIDWlh/lzqS4rWSc/etK3k3JzL8NV6eaqMxjhgblYJzRvDvW3t5Ox1d3nigZ62WiSLp/Qxv9dY8bC3UxTrS28vxo110GBrFGztxOHMJQkNDQJRKGQNfhfsPfvPugxbLWfrpGid9OxN20rOzbkMX62Xp8pojAPmZpXQvDFgwdZOTozuLmfPAdlqkXgjHtb1qO+H4C57MfbEtttap/V6bCUfR+pl94J3O9vi0EXzVu9bT1snRVfPzTRGGTu+vmjuxq3vHJq3t8Wb8XGljIZi6kgZjXHALBMEX70rVw2d7gYMBtdvTtzQXS0aw/yPvsE13Z0+5fDQAHRpF2JORnIZ0K97hNM7V1vlLn+q/ufNiTWi0d2YNtY5tNq3JHM1xo21Tl/4nkoNYyo+b8XUz89DNycm59lqGdk60nX2jhPOngPyleH0jrQExOCN7mU+4ZvIu5jQPKy+cxfu3uCYO8876mt9NnYC95WDBqLmignNw1wZ2u3IOTXuPO9oztfTEdEdcvuzkKd1aRdivqjWm5cTNFXeuJ6OiHwPW2g+gN2H7vGV6wuJyLskm9CE6kpUHtuIK9pLQFhntIybBJkywNvVsondhw3zxoXoRNT0SDahVR3bCMOFTEAwAaXXUAUg4OEZ3q4WuUCMC9FdwTvSEzUtkv11Ggsv1CQzABBMMBZe9G6FyGXeOkfGwSZETYtkB4UoIqIB2a+bJ5NDEdHFuxUil3lr0AwHmxA1LZJtobWMm4QqAKh1Do3E1xjdct46R8bBJkRNi9N7nqNHj2LFihXQ6/WIjIxEcnIywsPDLeY5ceIEnnrqKXTo0MH82sqVKxEdHe1+jR0kUwYg8JEZvP2NhzVGt5y3Bs1wsAlR0+JUQispKcGcOXOQlpYGjUaDtLQ0LFiwAGvXrrWY77vvvsO4ceMwb948USvrjEq9AZsPnjM/kG4CT+h7hJS75Tj6lKhpceocWkZGBjQaDTSamiPVxMREZGVloaioyGK+7Oxs/Pe//8WYMWPwxBNP4MCBA+LV2EGbDp5D5plC5BffQOaZQmw6eK7R69Ac8KJwIvIVTjVZCgoKEBkZaZ5WKpUIDQ1Ffn4+2rRpY349ODgY8fHxSEhIwIULFzBp0iRERESgZ8+eLlVSJnN+GVstB1fKIUu3Y3j7/0nDNJABuHC1HNHtQjBxmIZxdpJ1TMl9jKn4mkJMnUpogiBAZmNr5HLLhl5qaqr57+joaDz66KM4dOiQSwnN0ccGWOveWQ3tyaswCQLkMhm6d1YjLCzYpbKoLrX6TiwXTO3vxZpIR+2YkjgYU/H5ckydSmhRUVHIzMw0T1dXV0On0yEqKsr82o0bN7BhwwbMmDEDfn41xQuCYP7bWTrdDRiNzj8PbeygztDrb5kfSDd2UGdotdddqgPdIZPVfKGLiznQRiyMqfgYU/F5K6YKhYeehxYXF4ekpCTk5OSga9euSE9PR2xsLFQqlXmewMBAbN++HeHh4XjiiSeQm5uLAwcO4JNPPnFuK2pxJXgtlX6YHt/dYpQjv9jiYTzFx5iKjzEVny/H1KmEplKpkJqainnz5kGv10OtViMlJQUAkJCQgKSkJMTExOCDDz7A0qVLsWHDBhiNRixatAjdunXzyAYQEREBgEwQfDXX1tDpbsBgcL7LEeBj2D2BMRUfYyo+xlR83oqpn5+Huhy9QaFw/+5cYpRBlhhT8TGm4mNMxdfYMXVmfT7fQiMiInIED1+IiEgSmNCIiEgSmNCIiEgSmNCIiEgSmNCIiEgSmNCIiEgSmNCIiEgSmNCIiEgSmNCIiEgSmNCIiEgSmNCIiEgSJJvQjh49ioSEBIwYMQJTp07FtWvXvF2lJunTTz9FfHw8Ro4ciXHjxuGHH34AAKxduxYjRozA0KFDsWTJEty6dcvLNW1aTp8+jd/+9rcoKCgAAOzevRuPPfYYhg8fjueeew4VFRVermHTcv78eUyaNAmjRo3C6NGjcerUKQCMqzsOHTqE+Ph4JCQkYMKECbh48SIAH//tCxJUXFws9O3bVzh79qwgCIKwYcMG4cknn/RyrZqe7OxsYfDgwUJxcbEgCILw73//W4iLixO++uorYcSIEUJ5eblgMBiEZ555Rvjoo4+8XNumQ6vVCgkJCULXrl2F/Px8IScnR3jggQeEgoICQRAEYdmyZcIrr7zi5Vo2HZWVlcLAgQOFL7/8UhAEQTh8+LAwePBgxtUNlZWVQkxMjHD+/HlBEAQhLS1NmDBhgs//9iXZQsvIyIBGo4FGowEAJCYmIisrC0VFRV6uWdPSqlUrLF261PxE8vvuuw/FxcU4ePAgHnvsMQQHB0OhUGD8+PHYuXOnl2vbNBgMBrzwwgt46aWXzK8dOnQIgwYNQkREBABgwoQJ2LNnD0wm154D2NxkZGSgTZs2GDZsGABg0KBBWLVqFePqBqPRCJlMhrKyMgDAzZs30bJlS5//7UsyoRUUFCAyMtI8rVQqERoaivz8fC/Wqunp0qULBg4cCAAwmUx48803MXjwYOTn51vEt23btoytg1JSUtCvXz/ExcWZX7MVz5s3b6K0tNQLNWx6fvrpJ4SHh2PRokUYPXo0Jk+ejOrqasbVDXfddReWLFmCyZMn46GHHsInn3yCl156yed/+5JMaIIgQCaT1XldLpfk5npcRUUFZs+ejatXryI5ORkA6sTXVrzJ0t69e3HlyhXMmjWrznu24seYOsZgMODYsWMYNWoUduzYgb/85S+YMWMGDAYD4+qic+fO4d1338U///lPfP3111i0aBGmT58Ok8nk0799Se7ho6KiUFhYaJ6urq6GTqdDVFSUF2vVNP3000944oknEBQUhA0bNiAkJKROfAsLCxlbB2zfvh1XrlzBqFGjkJCQAAD4y1/+gvDw8DrxvOuuu9CqVStvVbVJiYiIQMeOHdG7d28ANV2Ofn5+Nr+njKtjMjIyEBMTg86dOwMA4uPjYTQaYTQaffq3L8mEFhcXhx9//BE5OTkAgPT0dMTGxprPBZFjfvnlF0yYMAFjx45FSkoKWrRoAQAYOnQovvjiC5SXl8NkMmHr1q3m8xdUv3Xr1mHfvn3YvXs3du/eDaBmxNjw4cNx5MgR845i8+bNGDJkCHsUHPTQQw8hPz/fPLIxOzsb1dXVGDJkCOPqou7duyM7O9s8CvfEiRMwGAyYMmWKT//2ZYIgCN6uhCccP34cb731FvR6PdRqNZYvX4527dp5u1pNytKlS7Ft2zZ06dLF4vXVq1dj3759+Pzzz2EwGHD//fdjyZIlUCqVXqpp06TRaHDkyBG0bdsWe/bswerVq3Hr1i106tQJy5cvZ0vCCdnZ2UhOTsbNmzehUCiwcOFC9OvXj3F1w6effoq0tDT4+/sjMDAQc+fOxf33349169b57G9fsgmNiIiaF7a9iYhIEpjQiIhIEpjQiIhIEpjQiIhIEpjQiIhIEpjQiIhIEpjQiCQiLy8PGo0GJSUl3q4KkVcwoRERkSQwoRF50IULFzB16lT07dsXw4cPx9atWwEA8+fPxyuvvILExET06NEDiYmJ5lu1AUBWVhbGjRuHXr16YcSIEdi2bZv5vYqKCixcuBB9+/ZFv379MG/ePNy8edP8/rZt2zBs2DD06NEDzz77rMV7RFLGhEbkITdu3MDUqVMxYMAAHDt2DO+88475OV0AsGvXLjz99NP49ttv0bt3b8ycORPV1dW4ePEipk2bhvHjxyMrKwvJyclITU3FF198AQBYsmQJ8vLysH//fhw6dAi//PIL3n77bfN6L126hF27duHLL7/EyZMnsX37dq9sP1Fj8/N2BYik6siRI2jZsiWmT58OAOjWrRsmTJiAzz77DCqVCiNGjMCDDz4IAHj22WexefNmnDx5EllZWejVqxdGjRoFAIiNjcWkSZOwfft2DB06FAcOHEBaWhrUajUA4K233kJVVZV5vbNmzUJgYCACAwPRt29fXLlypXE3nMhLmNCIPOTq1av45ZdfzI81AWoelNq+fXuoVCrcc8895tf9/f0RFhYGrVaL4uLiOjfSbt++Pfbs2YOysjJUV1dbPLKjbdu2AGoGhQBA69atLco1Go2e2Dwin8OERuQhERER6Natm0WXX3FxMQwGA1JTU+s8s6+oqAht27ZFZGQkMjMzLcrKzc1FmzZtoFKp4O/vj4KCAkRERAAAzpw5g6ysLJ96jAeRN/AcGpGHDB48GAUFBdi2bRsMBgMKCgowdepUrFmzBkDNE6y///57VFdX4+2330ZERAR69uyJxx9/HKdOncKuXbtgMBhw+vRpbNq0CaNGjYJCoUB8fDzeffddlJaWory8HCtWrDA/t4qoOWNCI/KQkJAQrF27Fvv27cOAAQMwevRo9OrVC3PnzgUA9OnTBykpKejfvz/Onj2LNWvWQKFQoEOHDvjoo4+wefNm9O3bFy+++CKefvppjBkzBgDw8ssvo127dnj88ccxbNgwdOjQAS+++KI3N5XIJ/B5aEReMH/+fAQGBuLVV1/1dlWIJIMtNCIikgQmNCIikgR2ORIRkSSwhUZERJLAhEZERJLAhEZERJLAhEZERJLAhEZERJLAhEZERJLAhEZERJLAhEZERJLAhEZERJLw/+QI8DBN/t9yAAAAAElFTkSuQmCC", + "image/png": "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", "text/plain": [ "
" ] @@ -1655,72 +2133,72 @@ " \n", " \n", " 0.0\n", - " 0.618977\n", + " 0.692286\n", " 9\n", - " 0.961134\n", - " 0.502351\n", + " 0.723101\n", + " 0.493977\n", " 154.0\n", - " 0.898227\n", - " 0.519481\n", - " 0.523359\n", - " 0.504886\n", - " 0.830820\n", + " 0.699209\n", + " 0.487013\n", + " 0.394130\n", + " 0.384365\n", + " 0.717699\n", " 307.0\n", " \n", " \n", " 1.0\n", - " 0.393360\n", + " 0.692163\n", " 19\n", - " 0.949908\n", - " 0.565964\n", + " 0.722961\n", + " 0.511086\n", " 154.0\n", - " 0.757949\n", - " 0.577922\n", - " 0.830488\n", - " 0.752443\n", - " 0.540736\n", + " 0.699164\n", + " 0.487013\n", + " 0.437799\n", + " 0.384365\n", + " 0.717477\n", " 307.0\n", " \n", " \n", " 2.0\n", - " 0.340576\n", + " 0.692005\n", " 29\n", - " 0.873132\n", - " 0.623321\n", + " 0.722819\n", + " 0.511891\n", " 154.0\n", - " 0.741842\n", - " 0.577922\n", - " 0.883357\n", - " 0.807818\n", - " 0.486286\n", + " 0.699072\n", + " 0.487013\n", + " 0.462298\n", + " 0.384365\n", + " 0.717280\n", " 307.0\n", " \n", " \n", " 3.0\n", - " 0.261349\n", + " 0.691817\n", " 39\n", - " 0.871362\n", - " 0.627005\n", + " 0.722676\n", + " 0.513401\n", " 154.0\n", - " 0.752500\n", - " 0.590909\n", - " 0.919472\n", - " 0.840391\n", - " 0.440035\n", + " 0.698977\n", + " 0.487013\n", + " 0.485565\n", + " 0.384365\n", + " 0.717067\n", " 307.0\n", " \n", " \n", " 4.0\n", - " 0.176418\n", + " 0.691583\n", " 49\n", - " 0.923451\n", - " 0.604904\n", + " 0.722533\n", + " 0.515158\n", " 154.0\n", - " 0.771581\n", - " 0.590909\n", - " 0.944006\n", - " 0.846906\n", - " 0.394002\n", + " 0.698884\n", + " 0.487013\n", + " 0.500515\n", + " 0.384365\n", + " 0.716844\n", " 307.0\n", " \n", " \n", @@ -1738,127 +2216,127 @@ " ...\n", " \n", " \n", - " 79.0\n", - " 0.000707\n", - " 799\n", - " 4.234869\n", - " 0.563605\n", + " 835.0\n", + " 0.615052\n", + " 8359\n", + " 0.670260\n", + " 0.781759\n", " 154.0\n", - " 2.793668\n", - " 0.564935\n", - " 0.999546\n", - " 0.993485\n", - " 0.010427\n", + " 0.633343\n", + " 0.487013\n", + " 0.850272\n", + " 0.384365\n", + " 0.648158\n", " 307.0\n", " \n", " \n", - " 80.0\n", - " 0.000707\n", - " 809\n", - " 4.235405\n", - " 0.563605\n", + " 836.0\n", + " 0.615052\n", + " 8369\n", + " 0.670260\n", + " 0.783925\n", " 154.0\n", - " 2.793969\n", - " 0.564935\n", - " 0.999546\n", - " 0.993485\n", - " 0.010426\n", + " 0.633343\n", + " 0.487013\n", + " 0.849354\n", + " 0.384365\n", + " 0.648158\n", " 307.0\n", " \n", " \n", - " 81.0\n", - " 0.000706\n", - " 819\n", - " 4.235732\n", - " 0.563605\n", + " 837.0\n", + " 0.615051\n", + " 8379\n", + " 0.670260\n", + " 0.780442\n", " 154.0\n", - " 2.794152\n", - " 0.564935\n", - " 0.999546\n", - " 0.993485\n", - " 0.010426\n", + " 0.633343\n", + " 0.487013\n", + " 0.850825\n", + " 0.384365\n", + " 0.648157\n", " 307.0\n", " \n", " \n", - " 82.0\n", - " 0.000706\n", - " 829\n", - " 4.235902\n", - " 0.563605\n", + " 838.0\n", + " 0.615051\n", + " 8389\n", + " 0.670260\n", + " 0.779970\n", " 154.0\n", - " 2.794244\n", - " 0.564935\n", - " 0.999546\n", - " 0.993485\n", - " 0.010425\n", + " 0.633343\n", + " 0.487013\n", + " 0.850982\n", + " 0.384365\n", + " 0.648157\n", " 307.0\n", " \n", " \n", - " 83.0\n", - " 0.000706\n", - " 839\n", - " 4.235960\n", - " 0.563605\n", + " 839.0\n", + " 0.615051\n", + " 8399\n", + " 0.670260\n", + " 0.780785\n", " 154.0\n", - " 2.794278\n", - " 0.564935\n", - " 0.999546\n", - " 0.993485\n", - " 0.010425\n", + " 0.633343\n", + " 0.487013\n", + " 0.852641\n", + " 0.384365\n", + " 0.648157\n", " 307.0\n", " \n", " \n", "\n", - "

84 rows × 11 columns

\n", + "

840 rows × 11 columns

\n", "" ], "text/plain": [ " train/loss_pred_step step val/loss_pred_step val/auroc val/n \\\n", "epoch \n", - "0.0 0.618977 9 0.961134 0.502351 154.0 \n", - "1.0 0.393360 19 0.949908 0.565964 154.0 \n", - "2.0 0.340576 29 0.873132 0.623321 154.0 \n", - "3.0 0.261349 39 0.871362 0.627005 154.0 \n", - "4.0 0.176418 49 0.923451 0.604904 154.0 \n", + "0.0 0.692286 9 0.723101 0.493977 154.0 \n", + "1.0 0.692163 19 0.722961 0.511086 154.0 \n", + "2.0 0.692005 29 0.722819 0.511891 154.0 \n", + "3.0 0.691817 39 0.722676 0.513401 154.0 \n", + "4.0 0.691583 49 0.722533 0.515158 154.0 \n", "... ... ... ... ... ... \n", - "79.0 0.000707 799 4.234869 0.563605 154.0 \n", - "80.0 0.000707 809 4.235405 0.563605 154.0 \n", - "81.0 0.000706 819 4.235732 0.563605 154.0 \n", - "82.0 0.000706 829 4.235902 0.563605 154.0 \n", - "83.0 0.000706 839 4.235960 0.563605 154.0 \n", + "835.0 0.615052 8359 0.670260 0.781759 154.0 \n", + "836.0 0.615052 8369 0.670260 0.783925 154.0 \n", + "837.0 0.615051 8379 0.670260 0.780442 154.0 \n", + "838.0 0.615051 8389 0.670260 0.779970 154.0 \n", + "839.0 0.615051 8399 0.670260 0.780785 154.0 \n", "\n", " val/loss_pred_epoch val/acc train/auroc train/acc \\\n", "epoch \n", - "0.0 0.898227 0.519481 0.523359 0.504886 \n", - "1.0 0.757949 0.577922 0.830488 0.752443 \n", - "2.0 0.741842 0.577922 0.883357 0.807818 \n", - "3.0 0.752500 0.590909 0.919472 0.840391 \n", - "4.0 0.771581 0.590909 0.944006 0.846906 \n", + "0.0 0.699209 0.487013 0.394130 0.384365 \n", + "1.0 0.699164 0.487013 0.437799 0.384365 \n", + "2.0 0.699072 0.487013 0.462298 0.384365 \n", + "3.0 0.698977 0.487013 0.485565 0.384365 \n", + "4.0 0.698884 0.487013 0.500515 0.384365 \n", "... ... ... ... ... \n", - "79.0 2.793668 0.564935 0.999546 0.993485 \n", - "80.0 2.793969 0.564935 0.999546 0.993485 \n", - "81.0 2.794152 0.564935 0.999546 0.993485 \n", - "82.0 2.794244 0.564935 0.999546 0.993485 \n", - "83.0 2.794278 0.564935 0.999546 0.993485 \n", + "835.0 0.633343 0.487013 0.850272 0.384365 \n", + "836.0 0.633343 0.487013 0.849354 0.384365 \n", + "837.0 0.633343 0.487013 0.850825 0.384365 \n", + "838.0 0.633343 0.487013 0.850982 0.384365 \n", + "839.0 0.633343 0.487013 0.852641 0.384365 \n", "\n", " train/loss_pred_epoch train/n \n", "epoch \n", - "0.0 0.830820 307.0 \n", - "1.0 0.540736 307.0 \n", - "2.0 0.486286 307.0 \n", - "3.0 0.440035 307.0 \n", - "4.0 0.394002 307.0 \n", + "0.0 0.717699 307.0 \n", + "1.0 0.717477 307.0 \n", + "2.0 0.717280 307.0 \n", + "3.0 0.717067 307.0 \n", + "4.0 0.716844 307.0 \n", "... ... ... \n", - "79.0 0.010427 307.0 \n", - "80.0 0.010426 307.0 \n", - "81.0 0.010426 307.0 \n", - "82.0 0.010425 307.0 \n", - "83.0 0.010425 307.0 \n", + "835.0 0.648158 307.0 \n", + "836.0 0.648158 307.0 \n", + "837.0 0.648157 307.0 \n", + "838.0 0.648157 307.0 \n", + "839.0 0.648157 307.0 \n", "\n", - "[84 rows x 11 columns]" + "[840 rows x 11 columns]" ] }, - "execution_count": 285, + "execution_count": 548, "metadata": {}, "output_type": "execute_result" } @@ -1871,7 +2349,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 549, "metadata": {}, "outputs": [ { @@ -1887,9 +2365,9 @@ "text": [ "| | train | val | test | ood |\n", "|:----------------|--------:|--------:|--------:|--------:|\n", - "| auroc | 0.778 | 0.564 | 0.579 | 0.665 |\n", - "| acc | 0.704 | 0.565 | 0.578 | 0.637 |\n", - "| loss_pred_epoch | 1.231 | 2.794 | 2.432 | 1.923 |\n", + "| auroc | 0.82 | 0.781 | 0.701 | 0.786 |\n", + "| acc | 0.384 | 0.487 | 0.494 | 0.437 |\n", + "| loss_pred_epoch | 0.65 | 0.633 | 0.662 | 0.649 |\n", "| n | 307 | 154 | 154 | 615 |\n" ] } @@ -1910,7 +2388,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 550, "metadata": {}, "outputs": [ { @@ -1936,8 +2414,8 @@ "probe accuracy for quadrants:\n", "| instructed to | did | didn't |\n", "|:----------------|------:|---------:|\n", - "| tell a truth | 0.59 | 0.53 |\n", - "| tell a lie | 0.38 | 0.65 |\n", + "| tell a truth | 0.52 | 0.33 |\n", + "| tell a lie | 0.38 | 0.62 |\n", "\n", "\n", "\n" @@ -1959,8 +2437,8 @@ "probe accuracy for quadrants:\n", "| instructed to | did | didn't |\n", "|:----------------|------:|---------:|\n", - "| tell a truth | 0.51 | 0.72 |\n", - "| tell a lie | 0.67 | 0.5 |\n", + "| tell a truth | 0.61 | 0.23 |\n", + "| tell a lie | 0.33 | 0.25 |\n", "\n", "\n", "\n", @@ -1969,16 +2447,16 @@ "probe accuracy for quadrants:\n", "| instructed to | did | didn't |\n", "|:----------------|------:|---------:|\n", - "| tell a truth | 0.63 | 0.64 |\n", - "| tell a lie | 0.6 | 0.72 |\n", + "| tell a truth | 0.49 | 0.29 |\n", + "| tell a lie | 0.3 | 0.43 |\n", "\n", "\n", "\n", "| | acc | acc_lie_lie | acc_lie_truth |\n", "|:-----|------:|--------------:|----------------:|\n", - "| test | 0.58 | 0.38 | 0.65 |\n", - "| val | 0.56 | 0.67 | 0.5 |\n", - "| ood | 0.64 | 0.6 | 0.72 |\n" + "| test | 0.49 | 0.38 | 0.62 |\n", + "| val | 0.49 | 0.33 | 0.25 |\n", + "| ood | 0.44 | 0.3 | 0.43 |\n" ] }, { @@ -2010,21 +2488,21 @@ " \n", " \n", " test\n", - " 0.577922\n", + " 0.493506\n", " 0.375000\n", - " 0.653846\n", + " 0.615385\n", " \n", " \n", " val\n", - " 0.564935\n", - " 0.666667\n", - " 0.500000\n", + " 0.487013\n", + " 0.333333\n", + " 0.250000\n", " \n", " \n", " ood\n", - " 0.637398\n", - " 0.600000\n", - " 0.716667\n", + " 0.437398\n", + " 0.300000\n", + " 0.433333\n", " \n", " \n", "\n", @@ -2032,17 +2510,18 @@ ], "text/plain": [ " acc acc_lie_lie acc_lie_truth\n", - "test 0.577922 0.375000 0.653846\n", - "val 0.564935 0.666667 0.500000\n", - "ood 0.637398 0.600000 0.716667" + "test 0.493506 0.375000 0.615385\n", + "val 0.487013 0.333333 0.250000\n", + "ood 0.437398 0.300000 0.433333" ] }, - "execution_count": 287, + "execution_count": 550, "metadata": {}, "output_type": "execute_result" } ], "source": [ + "# TODO wrong?\n", "a = calc_metrics(dm, net, split=\"test\", verbose=False)\n", "b = calc_metrics(dm, net, split=\"val\", verbose=False)\n", "c = calc_metrics(dm_ood, net, split=\"all\", verbose=False)\n", @@ -2060,7 +2539,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 551, "metadata": {}, "outputs": [ { @@ -2070,7 +2549,7 @@ "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mZeroDivisionError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[288], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[38;5;241;43m1\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;241;43m/\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\n", + "Cell \u001b[0;32mIn[551], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[38;5;241;43m1\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;241;43m/\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\n", "\u001b[0;31mZeroDivisionError\u001b[0m: division by zero" ] } diff --git a/research_log.md b/research_log.md index 5d6eb3b..fc5bc8f 100644 --- a/research_log.md +++ b/research_log.md @@ -1048,3 +1048,11 @@ Ok so it kinda works. But I think I need to mix the layers at the end. How to do So we have [batch layers features] as input then we use a series of linear to -> batch layer latent and finally we want to mix layer and latent... hmmm best to do it at a bottleneck + +# 2024-01-16 07:56:24 + +One interesting observation is that this tokenized SAE... allow the probe to overfit even with just 1 token per layer. That doesn't seem like enought information to overfit! What does the token represent? I suppose I can reconstruct last layer hidden states then decode? + +It actually promising because it seems like the SAe is working very well, encoding multiple usefull features. Because with multiple usefull features the model could overfit (e.g. truth vs instruction following vs sentiment vs following examles), but without them it couldn't. So this might be a success! How do I show this? Well I can follow the representation engienering paper. + +I think another conclusioon is that my method of getting the importance matrix doesn't work well.