From 6e01c90807583c25149d3e7dbdebd9d9385c848f Mon Sep 17 00:00:00 2001 From: kenoharada Date: Tue, 26 Jan 2021 09:28:45 +0900 Subject: [PATCH 1/2] added readme --- tutorial/README.md | 29 +++++++++++++++++++++++++++++ 1 file changed, 29 insertions(+) create mode 100644 tutorial/README.md diff --git a/tutorial/README.md b/tutorial/README.md new file mode 100644 index 00000000..f7e66a03 --- /dev/null +++ b/tutorial/README.md @@ -0,0 +1,29 @@ +# Pixyz Tutorials + +## [Pixyz Overview](https://github.com/masa-su/pixyz/blob/master/tutorial/English/00-PixyzOverview.ipynb) +Overviewing relationships between each Pixyz APIs(Distribution API, Loss API, Model API) by implementing VAE + +## [Distribution API Tutorial](https://github.com/masa-su/pixyz/blob/master/tutorial/English/01-DistributionAPITutorial.ipynb) +Detailed introduction of Distribution API + +## [Loss API Tutorial](https://github.com/masa-su/pixyz/blob/master/tutorial/English/02-LossAPITutorial.ipynb) +Detailed introduction of Loss API + +## [Model API Tutorial](https://github.com/masa-su/pixyz/blob/master/tutorial/English/03-ModelAPITutorial.ipynb) +Detailed introduction of Model API + +## [Example: Action conditional Deep Markov Model](https://github.com/masa-su/pixyz/blob/master/tutorial/English/04-DeepMarkovModel.ipynb) +Action conditional Deep Markov Model implemented in Pixyz + +## For more implementations +- [examples](https://github.com/masa-su/pixyz/tree/master/examples) + - GAN + - Glow + - Real NVP + - etc. +- [Pixyzoo](https://github.com/masa-su/pixyzoo) + - GQN + - VRNN + - TD-VAE + - HRSSM + - etc. \ No newline at end of file From 906389456df6de6bb0a0acab87241db450c7f023 Mon Sep 17 00:00:00 2001 From: kenoharada Date: Tue, 9 Feb 2021 10:58:12 +0900 Subject: [PATCH 2/2] DMM in Japense --- tutorial/English/04-DeepMarkovModel.ipynb | 1075 +++-- tutorial/English/utils.py | 50 +- tutorial/Japanese/04-DeepMarkovModel.ipynb | 3775 +++++++++++++++++ tutorial/Japanese/prepare_cartpole_dataset.py | 41 + tutorial/Japanese/utils.py | 87 + tutorial/README.md | 22 +- 6 files changed, 4620 insertions(+), 430 deletions(-) create mode 100644 tutorial/Japanese/04-DeepMarkovModel.ipynb create mode 100644 tutorial/Japanese/prepare_cartpole_dataset.py create mode 100644 tutorial/Japanese/utils.py diff --git a/tutorial/English/04-DeepMarkovModel.ipynb b/tutorial/English/04-DeepMarkovModel.ipynb index 1e02b337..3a3892d2 100644 --- a/tutorial/English/04-DeepMarkovModel.ipynb +++ b/tutorial/English/04-DeepMarkovModel.ipynb @@ -36,7 +36,7 @@ "from tensorboardX import SummaryWriter\n", "import numpy as np\n", "\n", - "from utils import DMMDataset, imshow\n", + "from utils import DMMDataset, imshow, postprocess\n", "from torch.utils.data import DataLoader\n", "import matplotlib.pyplot as plt\n", "%matplotlib inline\n", @@ -61,15 +61,25 @@ { "cell_type": "code", "execution_count": 2, - "metadata": {}, - "outputs": [], + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "torch.Size([30, 3, 28, 28])\n" + ] + } + ], "source": [ - "# you have to run prepare_cartpole_dataset.py or download from :\n", "batch_size = 256\n", "train_loader = DataLoader(DMMDataset(), batch_size=batch_size, shuffle=True, drop_last=True)\n", "# test_loader = DataLoader(DMMTestDataset(), batch_size=batch_size, shuffle=False, drop_last=True)\n", "\n", - "_x = iter(train_loader).next()" + "_x = iter(train_loader).next()\n", + "print(_x['episode_frames'][0][0:30].shape)" ] }, { @@ -79,6 +89,13 @@ "scrolled": false }, "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "torch.Size([30, 3, 28, 28])\n" + ] + }, { "data": { "image/png": "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\n", @@ -127,7 +144,7 @@ } ], "source": [ - "imshow(_x['episode_frames'][0][0:30])\n", + "imshow(postprocess(_x['episode_frames'][0][0:30]))\n", "\n", "# 0: Push cart to the left\n", "# 1:Push cart to the right\n", @@ -219,7 +236,7 @@ "\n", "\n", "# Emission p(x_t | z_t)\n", - "class Generator(Bernoulli):\n", + "class Generator(Normal):\n", " \"\"\"\n", " Given the latent z at time step t, return the vector of\n", " probabilities that parameterizes the bernlulli distribution p(x_t | z_t)\n", @@ -237,7 +254,7 @@ " h = h.view(h.shape[0], 128, 7, 7) # 128*7*7\n", " h = F.relu(self.conv1(h)) # 64x14x14\n", " generated_x = self.conv2(h) # 3x28x28\n", - " return {\"probs\": torch.sigmoid(generated_x)}\n", + " return {\"loc\": generated_x, \"scale\": 1.0}\n", "\n", "\n", "class Inference(Normal):\n", @@ -447,14 +464,30 @@ "name": "stderr", "output_type": "stream", "text": [ - " 0%| | 1/200 [00:03<11:42, 3.53s/it]" + "\r", + " 0%| | 0/200 [00:00" ] @@ -1192,14 +1260,15 @@ "name": "stderr", "output_type": "stream", "text": [ - " 26%|██▌ | 51/200 [03:03<08:56, 3.60s/it]" + "\r", + " 25%|██▌ | 50/200 [03:13<09:41, 3.88s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 51 Train loss: 3750.0143\n" + "Epoch: 51 Train loss: 56824.1820\n" ] }, { @@ -1207,14 +1276,14 @@ "output_type": "stream", "text": [ "\r", - " 26%|██▌ | 52/200 [03:07<08:52, 3.60s/it]" + " 26%|██▌ | 51/200 [03:17<09:37, 3.88s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 52 Train loss: 3748.5434\n" + "Epoch: 52 Train loss: 56812.5080\n" ] }, { @@ -1222,14 +1291,14 @@ "output_type": "stream", "text": [ "\r", - " 26%|██▋ | 53/200 [03:10<08:49, 3.60s/it]" + " 26%|██▌ | 52/200 [03:21<09:34, 3.88s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 53 Train loss: 3768.5098\n" + "Epoch: 53 Train loss: 56666.7160\n" ] }, { @@ -1237,14 +1306,14 @@ "output_type": "stream", "text": [ "\r", - " 27%|██▋ | 54/200 [03:14<08:45, 3.60s/it]" + " 26%|██▋ | 53/200 [03:25<09:30, 3.88s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 54 Train loss: 3756.0228\n" + "Epoch: 54 Train loss: 56668.7020\n" ] }, { @@ -1252,14 +1321,14 @@ "output_type": "stream", "text": [ "\r", - " 28%|██▊ | 55/200 [03:17<08:41, 3.60s/it]" + " 27%|██▋ | 54/200 [03:29<09:26, 3.88s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 55 Train loss: 3723.4896\n" + "Epoch: 55 Train loss: 56497.9160\n" ] }, { @@ -1267,14 +1336,14 @@ "output_type": "stream", "text": [ "\r", - " 28%|██▊ | 56/200 [03:21<08:38, 3.60s/it]" + " 28%|██▊ | 55/200 [03:33<09:22, 3.88s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 56 Train loss: 3716.0842\n" + "Epoch: 56 Train loss: 56479.9800\n" ] }, { @@ -1282,14 +1351,14 @@ "output_type": "stream", "text": [ "\r", - " 28%|██▊ | 57/200 [03:25<08:34, 3.60s/it]" + " 28%|██▊ | 56/200 [03:37<09:18, 3.88s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 57 Train loss: 3680.9559\n" + "Epoch: 57 Train loss: 56297.6360\n" ] }, { @@ -1297,14 +1366,14 @@ "output_type": "stream", "text": [ "\r", - " 29%|██▉ | 58/200 [03:28<08:31, 3.60s/it]" + " 28%|██▊ | 57/200 [03:41<09:14, 3.88s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 58 Train loss: 3692.5682\n" + "Epoch: 58 Train loss: 56295.1740\n" ] }, { @@ -1312,14 +1381,14 @@ "output_type": "stream", "text": [ "\r", - " 30%|██▉ | 59/200 [03:32<08:27, 3.60s/it]" + " 29%|██▉ | 58/200 [03:44<09:10, 3.88s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 59 Train loss: 3692.8695\n" + "Epoch: 59 Train loss: 56162.6200\n" ] }, { @@ -1327,14 +1396,14 @@ "output_type": "stream", "text": [ "\r", - " 30%|███ | 60/200 [03:36<08:24, 3.60s/it]" + " 30%|██▉ | 59/200 [03:48<09:06, 3.88s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 60 Train loss: 3680.1582\n" + "Epoch: 60 Train loss: 56182.1080\n" ] }, { @@ -1342,14 +1411,14 @@ "output_type": "stream", "text": [ "\r", - " 30%|███ | 61/200 [03:39<08:20, 3.60s/it]" + " 30%|███ | 60/200 [03:52<09:02, 3.88s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 61 Train loss: 3683.7855\n" + "Epoch: 61 Train loss: 56106.6000\n" ] }, { @@ -1357,14 +1426,14 @@ "output_type": "stream", "text": [ "\r", - " 31%|███ | 62/200 [03:43<08:16, 3.60s/it]" + " 30%|███ | 61/200 [03:56<08:58, 3.88s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 62 Train loss: 3668.7942\n" + "Epoch: 62 Train loss: 56055.0940\n" ] }, { @@ -1372,14 +1441,14 @@ "output_type": "stream", "text": [ "\r", - " 32%|███▏ | 63/200 [03:46<08:13, 3.60s/it]" + " 31%|███ | 62/200 [04:00<08:54, 3.88s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 63 Train loss: 3624.9806\n" + "Epoch: 63 Train loss: 55902.8800\n" ] }, { @@ -1387,14 +1456,14 @@ "output_type": "stream", "text": [ "\r", - " 32%|███▏ | 64/200 [03:50<08:09, 3.60s/it]" + " 32%|███▏ | 63/200 [04:04<08:51, 3.88s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 64 Train loss: 3645.8128\n" + "Epoch: 64 Train loss: 55918.1920\n" ] }, { @@ -1402,14 +1471,14 @@ "output_type": "stream", "text": [ "\r", - " 32%|███▎ | 65/200 [03:54<08:06, 3.60s/it]" + " 32%|███▏ | 64/200 [04:08<08:47, 3.88s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 65 Train loss: 3618.8245\n" + "Epoch: 65 Train loss: 55805.0120\n" ] }, { @@ -1417,14 +1486,14 @@ "output_type": "stream", "text": [ "\r", - " 33%|███▎ | 66/200 [03:57<08:02, 3.60s/it]" + " 32%|███▎ | 65/200 [04:11<08:43, 3.88s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 66 Train loss: 3585.8390\n" + "Epoch: 66 Train loss: 55797.4460\n" ] }, { @@ -1432,14 +1501,14 @@ "output_type": "stream", "text": [ "\r", - " 34%|███▎ | 67/200 [04:01<07:58, 3.60s/it]" + " 33%|███▎ | 66/200 [04:15<08:39, 3.88s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 67 Train loss: 3569.0584\n" + "Epoch: 67 Train loss: 55713.8000\n" ] }, { @@ -1447,14 +1516,14 @@ "output_type": "stream", "text": [ "\r", - " 34%|███▍ | 68/200 [04:04<07:55, 3.60s/it]" + " 34%|███▎ | 67/200 [04:19<08:35, 3.88s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 68 Train loss: 3492.4459\n" + "Epoch: 68 Train loss: 55664.8560\n" ] }, { @@ -1462,14 +1531,14 @@ "output_type": "stream", "text": [ "\r", - " 34%|███▍ | 69/200 [04:08<07:51, 3.60s/it]" + " 34%|███▍ | 68/200 [04:23<08:31, 3.88s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 69 Train loss: 3481.0924\n" + "Epoch: 69 Train loss: 55576.3620\n" ] }, { @@ -1477,14 +1546,14 @@ "output_type": "stream", "text": [ "\r", - " 35%|███▌ | 70/200 [04:12<07:48, 3.60s/it]" + " 34%|███▍ | 69/200 [04:27<08:27, 3.88s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 70 Train loss: 3413.0706\n" + "Epoch: 70 Train loss: 55548.3420\n" ] }, { @@ -1492,14 +1561,14 @@ "output_type": "stream", "text": [ "\r", - " 36%|███▌ | 71/200 [04:15<07:44, 3.60s/it]" + " 35%|███▌ | 70/200 [04:31<08:23, 3.88s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 71 Train loss: 3370.1745\n" + "Epoch: 71 Train loss: 55429.2280\n" ] }, { @@ -1507,14 +1576,14 @@ "output_type": "stream", "text": [ "\r", - " 36%|███▌ | 72/200 [04:19<07:41, 3.60s/it]" + " 36%|███▌ | 71/200 [04:35<08:20, 3.88s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 72 Train loss: 3317.5028\n" + "Epoch: 72 Train loss: 55480.1360\n" ] }, { @@ -1522,14 +1591,14 @@ "output_type": "stream", "text": [ "\r", - " 36%|███▋ | 73/200 [04:22<07:37, 3.60s/it]" + " 36%|███▌ | 72/200 [04:39<08:16, 3.88s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 73 Train loss: 3274.7025\n" + "Epoch: 73 Train loss: 55372.8140\n" ] }, { @@ -1537,14 +1606,14 @@ "output_type": "stream", "text": [ "\r", - " 37%|███▋ | 74/200 [04:26<07:33, 3.60s/it]" + " 36%|███▋ | 73/200 [04:43<08:12, 3.88s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 74 Train loss: 3227.9801\n" + "Epoch: 74 Train loss: 55322.9160\n" ] }, { @@ -1552,14 +1621,14 @@ "output_type": "stream", "text": [ "\r", - " 38%|███▊ | 75/200 [04:30<07:30, 3.60s/it]" + " 37%|███▋ | 74/200 [04:46<08:08, 3.88s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 75 Train loss: 3152.3159\n" + "Epoch: 75 Train loss: 55238.1540\n" ] }, { @@ -1567,14 +1636,14 @@ "output_type": "stream", "text": [ "\r", - " 38%|███▊ | 76/200 [04:33<07:26, 3.60s/it]" + " 38%|███▊ | 75/200 [04:50<08:04, 3.88s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 76 Train loss: 3171.5020\n" + "Epoch: 76 Train loss: 55280.2400\n" ] }, { @@ -1582,14 +1651,14 @@ "output_type": "stream", "text": [ "\r", - " 38%|███▊ | 77/200 [04:37<07:23, 3.60s/it]" + " 38%|███▊ | 76/200 [04:54<08:00, 3.88s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 77 Train loss: 3127.4684\n" + "Epoch: 77 Train loss: 55179.4380\n" ] }, { @@ -1597,14 +1666,14 @@ "output_type": "stream", "text": [ "\r", - " 39%|███▉ | 78/200 [04:40<07:19, 3.60s/it]" + " 38%|███▊ | 77/200 [04:58<07:57, 3.88s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 78 Train loss: 3017.8191\n" + "Epoch: 78 Train loss: 55209.4780\n" ] }, { @@ -1612,14 +1681,14 @@ "output_type": "stream", "text": [ "\r", - " 40%|███▉ | 79/200 [04:44<07:15, 3.60s/it]" + " 39%|███▉ | 78/200 [05:02<07:53, 3.88s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 79 Train loss: 2907.3863\n" + "Epoch: 79 Train loss: 55079.0920\n" ] }, { @@ -1627,14 +1696,14 @@ "output_type": "stream", "text": [ "\r", - " 40%|████ | 80/200 [04:48<07:12, 3.60s/it]" + " 40%|███▉ | 79/200 [05:06<07:49, 3.88s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 80 Train loss: 2952.3883\n" + "Epoch: 80 Train loss: 55045.5060\n" ] }, { @@ -1642,14 +1711,14 @@ "output_type": "stream", "text": [ "\r", - " 40%|████ | 81/200 [04:51<07:08, 3.60s/it]" + " 40%|████ | 80/200 [05:10<07:45, 3.88s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 81 Train loss: 2840.3833\n" + "Epoch: 81 Train loss: 55030.6360\n" ] }, { @@ -1657,14 +1726,14 @@ "output_type": "stream", "text": [ "\r", - " 41%|████ | 82/200 [04:55<07:05, 3.60s/it]" + " 40%|████ | 81/200 [05:13<07:41, 3.88s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 82 Train loss: 2835.3773\n" + "Epoch: 82 Train loss: 55005.8220\n" ] }, { @@ -1672,14 +1741,14 @@ "output_type": "stream", "text": [ "\r", - " 42%|████▏ | 83/200 [04:58<07:01, 3.60s/it]" + " 41%|████ | 82/200 [05:17<07:37, 3.88s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 83 Train loss: 2698.7593\n" + "Epoch: 83 Train loss: 54929.9360\n" ] }, { @@ -1687,14 +1756,14 @@ "output_type": "stream", "text": [ "\r", - " 42%|████▏ | 84/200 [05:02<06:57, 3.60s/it]" + " 42%|████▏ | 83/200 [05:21<07:33, 3.88s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 84 Train loss: 2676.6835\n" + "Epoch: 84 Train loss: 54969.1100\n" ] }, { @@ -1702,14 +1771,14 @@ "output_type": "stream", "text": [ "\r", - " 42%|████▎ | 85/200 [05:06<06:54, 3.60s/it]" + " 42%|████▏ | 84/200 [05:25<07:29, 3.88s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 85 Train loss: 2686.4679\n" + "Epoch: 85 Train loss: 54869.3160\n" ] }, { @@ -1717,14 +1786,14 @@ "output_type": "stream", "text": [ "\r", - " 43%|████▎ | 86/200 [05:09<06:50, 3.60s/it]" + " 42%|████▎ | 85/200 [05:29<07:25, 3.88s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 86 Train loss: 2650.6864\n" + "Epoch: 86 Train loss: 54861.0800\n" ] }, { @@ -1732,14 +1801,14 @@ "output_type": "stream", "text": [ "\r", - " 44%|████▎ | 87/200 [05:13<06:46, 3.60s/it]" + " 43%|████▎ | 86/200 [05:33<07:21, 3.88s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 87 Train loss: 2555.5597\n" + "Epoch: 87 Train loss: 54751.7260\n" ] }, { @@ -1747,14 +1816,14 @@ "output_type": "stream", "text": [ "\r", - " 44%|████▍ | 88/200 [05:16<06:43, 3.60s/it]" + " 44%|████▎ | 87/200 [05:37<07:17, 3.88s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 88 Train loss: 2559.2596\n" + "Epoch: 88 Train loss: 54815.0680\n" ] }, { @@ -1762,14 +1831,14 @@ "output_type": "stream", "text": [ "\r", - " 44%|████▍ | 89/200 [05:20<06:39, 3.60s/it]" + " 44%|████▍ | 88/200 [05:41<07:14, 3.88s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 89 Train loss: 2559.2467\n" + "Epoch: 89 Train loss: 54739.2640\n" ] }, { @@ -1777,14 +1846,14 @@ "output_type": "stream", "text": [ "\r", - " 45%|████▌ | 90/200 [05:24<06:36, 3.60s/it]" + " 44%|████▍ | 89/200 [05:44<07:10, 3.87s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 90 Train loss: 2520.3299\n" + "Epoch: 90 Train loss: 54757.9560\n" ] }, { @@ -1792,14 +1861,14 @@ "output_type": "stream", "text": [ "\r", - " 46%|████▌ | 91/200 [05:27<06:32, 3.60s/it]" + " 45%|████▌ | 90/200 [05:48<07:06, 3.88s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 91 Train loss: 2491.7058\n" + "Epoch: 91 Train loss: 54705.2020\n" ] }, { @@ -1807,14 +1876,14 @@ "output_type": "stream", "text": [ "\r", - " 46%|████▌ | 92/200 [05:31<06:28, 3.60s/it]" + " 46%|████▌ | 91/200 [05:52<07:02, 3.88s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 92 Train loss: 2460.3424\n" + "Epoch: 92 Train loss: 54654.3220\n" ] }, { @@ -1822,14 +1891,14 @@ "output_type": "stream", "text": [ "\r", - " 46%|████▋ | 93/200 [05:34<06:25, 3.60s/it]" + " 46%|████▌ | 92/200 [05:56<06:58, 3.88s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 93 Train loss: 2464.5741\n" + "Epoch: 93 Train loss: 54617.0460\n" ] }, { @@ -1837,14 +1906,14 @@ "output_type": "stream", "text": [ "\r", - " 47%|████▋ | 94/200 [05:38<06:21, 3.60s/it]" + " 46%|████▋ | 93/200 [06:00<06:54, 3.87s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 94 Train loss: 2425.3397\n" + "Epoch: 94 Train loss: 54623.8140\n" ] }, { @@ -1852,14 +1921,14 @@ "output_type": "stream", "text": [ "\r", - " 48%|████▊ | 95/200 [05:42<06:18, 3.60s/it]" + " 47%|████▋ | 94/200 [06:04<06:50, 3.88s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 95 Train loss: 2405.2165\n" + "Epoch: 95 Train loss: 54542.4060\n" ] }, { @@ -1867,14 +1936,14 @@ "output_type": "stream", "text": [ "\r", - " 48%|████▊ | 96/200 [05:45<06:14, 3.60s/it]" + " 48%|████▊ | 95/200 [06:08<06:46, 3.88s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 96 Train loss: 2389.1514\n" + "Epoch: 96 Train loss: 54619.6100\n" ] }, { @@ -1882,14 +1951,14 @@ "output_type": "stream", "text": [ "\r", - " 48%|████▊ | 97/200 [05:49<06:10, 3.60s/it]" + " 48%|████▊ | 96/200 [06:12<06:43, 3.88s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 97 Train loss: 2378.5552\n" + "Epoch: 97 Train loss: 54504.6980\n" ] }, { @@ -1897,14 +1966,14 @@ "output_type": "stream", "text": [ "\r", - " 49%|████▉ | 98/200 [05:52<06:07, 3.60s/it]" + " 48%|████▊ | 97/200 [06:16<06:39, 3.88s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 98 Train loss: 2372.0996\n" + "Epoch: 98 Train loss: 54569.3900\n" ] }, { @@ -1912,20 +1981,70 @@ "output_type": "stream", "text": [ "\r", - " 50%|████▉ | 99/200 [05:56<06:03, 3.60s/it]" + " 49%|████▉ | 98/200 [06:19<06:35, 3.88s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 99 Train loss: 2331.8757\n", - "Epoch: 100 Train loss: 2327.7387\n" + "Epoch: 99 Train loss: 54432.7600\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 50%|████▉ | 99/200 [06:23<06:31, 3.88s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 100 Train loss: 54470.5920\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlMAAADFCAYAAABw4XefAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJztvXmcXkWd7/+u3rvT3Vm600mnk86ekA6hgQbCJkpyI4gYB6IOEh2XjKhz8aqo96r3XocZfjNuLx1QuKPM6EwGYRxZVBSUILIEhEBCQiAJ6U4nnXTSS3rf967fH1VP0kgvz3ae85zq7/v1qtc5p55zzvP99Kl6us63vlWltNYIgiAIgiAI0ZHitwGCIAiCIAhBRhpTgiAIgiAIMSCNKUEQBEEQhBiQxpQgCIIgCEIMSGNKEARBEAQhBqQxJQiCIAiCEAPSmBIEQRAEQYiBmBpTSqlrlVKHlVJHlFJfjZdRyYRoDD6u6wPR6Aqua3RdH4jGaYvWOqoEpALVwDIgA3gNKIv2fsmYRGPwk+v6RKP/tolG0Sca3dIYTVL2jxMxSqnLgNu11tfY46/Zxtk3J7qmsLBQL1m8BFRUX5lwuru7qa+vZ+XKhdTU1NHS0v51CEPjkiUJszFWzmospabmFC0tbZNqLJhToEsXlpKakZpYQ6MkpG/5smIA9u473AP8g5vPcDE1NSenfIYQZI0rqampoaWlxWGNy6ipOUFLS+ukGoOsD2DPnn0O18UV1NQcd7yculsXx1JTU0Nzc/PUrZYYWqcfAP51zPFHgbvHOe8WYDewu7S0VOtBHRgefPBBvW3bNq31Pl1RUabD1hggzmqs1hUV546rcay+RSULdceJVn+N1lprPWrT5IT0dbc/q7vbn9XAUXefYY2uqFjneDnVuqKiwnGNHbqi4vwp62Jw9bVrrdsdr4t9uqLiQsfLqbt1cSwVFRVah9Em8jwAXWt9r9b6Iq31RXPnzoV0r7/RA3rKYTR7wo/fpjGQLAMyx/1krL6i+XPJX5SVWNPGRRGJi3PG6FXMGL1qws/deIaLMV738XFD4+S4oTEf05PydtzQN9Om8XFDYxaT/T65oXFypoPGsaTFcO0pYNGY44U2zxlKSkqora2FGUOQosFljWeZQqMiSC3iM/pm94SyMpj2zzB4iMbgM44+qYsBZDpojIZYPFOvACuVUkuVUhnATcCj8TErObj44oupqqri2LFjjI6OgmgMHGf11TA4OAgwB4f0gfvPEESjC4zVJ3UxuEwHjdEQtWdKaz2slLoVeALjk/6p1vpA3CyLhJ3/x2zzW822/NtAXsy3TUtL4+677+aaa67n+PHjAL/wXWOOdR1X3BGX257VeE2YGhWxOTTHowF+/mkAOnraAJh5w3aYszTmO5/VdwMjIyMArb49w99/wmzT+81243/G5baRP0MP+dn1ZjvaYLZ/9XugMObbJpXG/7jabHWn2X7sSUy7IDaSQ+Mw7LzF7NY0me1HfwIUxXznsfp8r4t7v222fW+a7eV3AzNivm1yPENL74/Mts7+X1zx9bjcNqk08pLdHrLbT/hjBjHOM6W1flxrvUprvVxr/Q/xMiqZuO6666isrGTdunWIxmAS0lddXQ3Q4Lc9XuD6MwTR6AJSF91gOmiMlHi7GHzgT/Se7AAgZ7btxy0PyNwLYXMY2hrNbuOg2Vb4Z038aeBUi3l26Se6TdacTh/t8YJ+6O0yu21v2Lw+YOKBDcGjBnpqzG5jpc3L98kWr6hl+NRpAFLTWgBQJMOAjHhRD6frzG7tHps3/sCU4LIfTtaY3Z7dZnt57F6p5KIH9lTZXet9W+GfNd4wAPXHze7gi2a7OKCeKUEQBEEQhOlO8D1TPfmkp5k3qbajpt909tBxSF/rp1VxZubZkcQHW+zOScwgikSjgX6I69v4CBm9wwC0YjxwRc2j8Qi1SSI0dFjPaat982cAtzxTcyHfTgJ8bMjm9TLZdA3BYy5pRVbPQestJrqJj5OTfOi2HtTBDrvNd+sRkg/ptg62tdu8dmCWXwZ5wAxYesLsPlPtryme0Q1Dz5rd5tfNdrF/1gS/MTWjifRGU/mbUs0P+Oz0ocmuCCDdUG27veaFRqD69U9YEd+GFEAqKfVm6gKdan/Ic136BwVQCyfMM+xIMxpn0odbP+AKThptHdbnPZMe3NI4CsdM10KtnW1jEa3EI3g5ORiCrgEA+u3vaVZGL+7oA0iDXhMuMZjSDEAGo34a5A2H7G9oQau/dnhGKzTYH5qhQX9NQbr5BEEQBEEQYiLAninz9kRLLv1pplWa2x1qGzb5Y5JX9CvIOgpAX5MJBs2mAyjw0ah4kkVepnnb7++zHrcs1wYRaMg+CUDa6VBeNVDsl0EekAOFZgDBzBdDeSO+WeMNqZBpuqQXnXGAD/tmTfzJAIww/Xoorwm3PFOzINP8/8h4xU5T8ule4jG9RVKRbwd//MYO6nmPf6Z4w0xItV3RLx802yt68KusimdKEARBEAQhBgLsmbLDdQuyGFxgW9671Vs/c4WsufQoE6DR3G28cIvp9tOi+NKbSWWqeXYpmb0AlDj1tg8wj9FR88wyz4ScuRR8buk0k66+aQOWz6HPR2O8IBNGTFxYsymqFDrlfcuHAfOW32TDiEpDvQDOkAttZuqOfbYT43wa8GdAj4ek7DPbk6EM/7w23lAEKVZco/Uw0odfGgPcmLJ0zSf/tGlotHYfM3kngFL/TIo/Lehj9QDkNtrRJyOpE62FGjxy8phhB0Y1heqEc/MTzaLB1ntlBxIVu1VIDXb8wOwz0zG61I1psd17obESDOS49f42IweA9NAM7zolkjXFg0G++fFcnhPKcCVkYgxd9vllh15oOnCrMQVk2dHtZ8qnf/8UpZtPEARBEAQhBoLvmcrLYKTFTC7RO2Bnes1u9tEgL1hAypCZvnYo1c7Y29PtkPMmE5VniuKsgVD3nmszoMO8tFwAOheGumj9H84bd/pMXexJszMTcxQ43zdzPEGZt/vBATs3QmY9sMA/e+JNk9HS1GvqYLE6Caz00SAPOH0hACf7zVxMa3gDiH0t0KTi1HK7Dc0z1YBT5RTg0JUADHWZ0RLpHANm+2KKeKYEQRAEQRBiIPieKWpIXWICJFPtZKh09sFc/yyKPz2k5pmAmxltNivfn9a3NwyS12OCpUZCMVP9i+I/N6ivdNF30nik8s/MRzpzwrMDy0Ljren7TijDMa8UgDYaW/5oDufp5W7FFBWaAprysj1umeteSNES40FVr9rjExmOxdkCG8wCrv1/twOALBc94RvM70v6A/Z4aA+kX+iLKeKZEgRBEARBiIHgN6b0WuhLh750jjTAkQag67DfVsWZOWR2p5DZnUJzJzR3AtT4bFMc0fmc7IeT/dAywyQyjvhtVZzJoTUbWrPhqDYJXpzqouDRo6BHcSodTqUD/JffFsWfTpNOpJl01r3hCKodVDstQAtAwUs+G+QBBS1Q0EIdUAeQs8tngzxgtAtGu2hNgdYUgCq/LYo/2f2Q3U8DJiKMmropLvCO4DemVBosKYcl5cxaALMWwOunTk59XaAYYKRgASMFC+irg7464JCfs7zHed08lU75rFzKZ+XS2AeNfUCVK/M+hEiltHgWpcWzyCiDjDKg07EZlwEuuBIuuJKsPsjqAw46FrgMsO4KWHcFM5fCzKXAXr8NijPF74DidzA8DMPDwB+L/LYo/hRdC0XXMrMdZrYDfzo+5SWBI/U8SD2PzE7I7AT2HvTboviTeSVkXklOI+Q0Ak2P+2ZK8BtTgiAIgiAIPuJAAHoXHC8BoDvP5FyRnYJ1+gHzfbEqvgxzJO1cAFIK7dQIs/zy3GjMemvxLDpNVOabmRDnh5yKq12bdbmFloxCAIo77MSr+bN8tMcjlOliPx0qHmUNE58bVE6b4fShAeeXXeDMHCUWMyVCQ2gAyFW9/pniFZlm1vqGFfa43KVZVy1p5QAM2BkSyHNplEQIE2yes9kepvtXF8UzJQiCIAiCEAMOeKby4EozGeKyZ0xOW80JZjs1DHQGqxeYt8Vj82xWfZ1PK3VoYID4Fp25LKwznqiddq7Oc5pLoTCOX+E7BeT3m6D64/YVZgUOeqbazBt+fmju1V2FsN4/czyhzAyrP2e41hzXF7q1as5cExM5PzRNySsKLvPPHE8oPM9sbUz28Z8/xeL/5Z85nlBkymmKXWORPa/AiolPDzT2Ofbk/IEZF79mM8sTaoIbnqm0tZC2luZXoflVODHagRntVuOvXXFkOLOc4cxyGp6HhudhWB3BLBI2lGBLUvBifafXcpbwWs4Sul6ArheAkafi/h1+059xIf0ZFzLyUxj5KcBzfpsUf05dC6eu5SR2fdVlP/DZIA9oXwXtq2iqhqZqIPOf/LYovtRsgppNdHXa5d0yHvXbovgzej6Mnk92F2R3QXpvpd8WecA8YB69J6D3BPS3OjbqdAxpuSYd7kzBLM57IuE2uNGYEgRBEARB8IkAd/OFhucrhrvNfD3pl5kAuxwKgca3nRc8TOBnf1s9Bw6bN6cUO9K8ti6PpRe0AnBsyPT9LU1PhE0as6ZcRvxuOTiITjXt+p41Ni/v7Ozgp+022AO0R2hKN77o7ptDeWW+WeMZG0z3SaiXj7mu9fEBGSasoC/HHucun/jcIFJmpjs/MwQkbZFvpniGdSOk2/+AebMXAfX2Q5f6bGFZydij0GCCnHHODDBFpkvvwqw3gJ02830JNUE8U4IgCIIgCDEwZWNKKbVIKfW0UuqgUuqAUurzNn+OUupJpVSV3SZ4sThlUye1o/3UjvZTPaipHtS0ZYzQWZNOZ006cMymiamtreXqq6+mrKyMtWvXctdddwHQ2trKpk2bWLlyJZWVlSReYw6QQ9ZwC72dp+ntPM3LWfByFhQVFMPQIAwNsjR9hKXpIxPeJRx9mzZtYnh4eMJ7nEURV68UQEYdWfuOkrXvKIWLoXAxkFUKtAFtFDFI0RQDCsLVCPg0p8QxTr3YxakXu1iSDUuyAbIjukPyltMxPL4VHt/KlZ+EKz8JENnEpIHQeOQHcOQHrP4QrP4QkLEk7EvjWxc94oU74IU7KLoRim4E0mcRSXxm8tdFgO3Adjpvhc5bYeB0LcYXF96ULIEopzwBPMHBq+Hg1UBKK6bHpnHyyyzB0GiozquiOq8KekegaY5JjNqUGMLxTA0DX9JalwGXAv9dKVUGfBV4Smu9EnjKHgeStLQ0vve973Hw4EFeeukl7rnnHg4ePMi3vvUtNm7cSFVVFfn5+RBQjeHo27hxIw0NwZ0TKFyNBHjiMdfLKbivUeqi1MWgMB00xhWtdUQJ+DWwCTgMFNu8YuDwVNdWVFTo6DmttT6td7zSo3e80qMxwTsRpyd/8+KU37R582a9Y8cOvWrVKl1XV6e11vq8887T3mhst0nrHpsWXXq7XnTp7RFru+cff6Tv+ccfRaWvrq5OZ2Zm6vD1jUao8yzRPruWAa1bBsL7jok0Av3ha4yCgT6tB/qi1hgJiS2nb+eDv2rXH/xVe8Qaf9at9c+6g6GRtd82KUKN973ZpO97sykqfZHXxej50tMd+ktPd0Ss7+M/+Y3++E9+E9Z3+FYX/wwv66Tf5TRmjSeDo/H+bzyj7//GM9HpPNBiUgRY26dsG0UUgK6UWgJcAOwC5mmtQxF7DZhxmB4yF4AM3RbTXQ607mcjlwLjh6TX1NSwd+9e1q9fT2NjI8XFJhgxLS0NPNA4hAm0TudsSGDhDA1AbYT3ai09arZo5kwQcD+Rvvnz50fYtZD4gP7RPfeZncs+Oul542vsY/78meD1oIuMrKnPmZSQC37yopbocjoeNywzSw48GOF1W994wOysv3nS85JB44q8FgAiXXb78lf+xeys/tqE58SvLkbPJRnRzRh92bFf2r3rJz1vMo0EZADUqG4hRRVM+HkylNNYea3uT5SXXD7h58mk8fSC6KeU6SszYQeRBViER9gB6EqpXOBh4Ata686xn2l9pkU83nW3KKV2K6V2NzX5uTjv1HR3d7NlyxbuvPPOkPvyDEopCLjGMPSNS1D0gWh0oZyC+xqlnE4bjYEupzA9NMaDsBpTSql0TEPqfq31Iza7USlVbD8v5uwI9regtb5Xa32R1vqiuXPnxmxw3/Cj9A1HP4lcWW7XmdD1sQwNDbFlyxa2bt3KjTfeCMC8efOor68/8zkeaEy3CZqp6uumqq+bmUPbmTm0PaL7ANQfTaX+aCpzeHsw+lT66uvrQ28ZbyNez7Cj36RoeejEu3joxLuA8W8yucYR6utPwZhR+2OJl8Zn6nfxTP2uqK8f3juP4b0Tv+j5VU7Ho6LtZ1S0/Szi6x4Yei8PDL13ws+TSePWBW1sXRC5N/zpmTfx9Mybxv0sGepiiNntP2Z2+48jvu43mVfwm8wrJvw8HI14XBfjRUrTuEUtqcpprJSP9Iybn4wai/fXUrw/0n4bQ02HSV4Qzmg+BfwEOKS1/v6Yjx4FPmb3P4aJpQokWmu2bdvGmjVruO22287kb968me3bTaOmpaUFAqoxHH3bt29n1qzgLm8Snsb7Adr9sTB2XC+n4L5GqYtnNSJ1MamZDhrjylRBVcCVGDfefmCfTdcBBZhRfFXAH4A5U90rHkFodz7+vL7z8eejDrR78t/vfts9d+7cqQG9bt06XV5ersvLy/Vjjz2mm5ub9YYNG/SKFSt0Xl6e9lxjnUkl+et0Sf66iLV98Qvf0F/8wje01s0R69u4caMuLy/XU+u7UGs9FL1GHX2Q5C9/+KT+5Q+fHPee4WoE9k6tMfpn2PXmCd315onoA0Fb602KUmNCyqnlbz+0Q//th3ZErPE7f1Ojv/M3NYHQmJuyVeembI1Y4/c/9bD+/qcejkpf+HUxdn13bHtI37HtoYj1vXvtHfrda+8Y957JUhf/nKjr5Dg/d8lWTmPWuH9vYDR+9pMf15/95Mej0zmgTYqAcAPQpzwhnimef9BEE+4f1HWNQdU3ahOwWzuqUWspp3oaaQyyPq2lLmrRGAjC1SgzoAuCIAiCIMRAIIamCkKsqHGC8gVBEAQhHohnShAEQRAEIQbEMxUW/TD+VBpCYOic+hRBEARBiALxTAmCIAiCIMSAeKbCIgs/lk8R4kmu3wYIgiAIjpJQz9QQ/TRyOJFfGR/eAPrCPXkQOOmdLV5xDBiY+rS+0R7e6Holgr9HctD3wih9L4yGefYo0OWlOd7QzARzSk9XRglcQQXoxZg+JSMEct7LPiJ4LJpAFupwf2oEZ5BuPkEQBEEQhBhQWicusFop1QT0YN6hk51C3mrnYq31lAsMKaW6IDDut4g1BvwZgvsawy2n00Gj1MXkQeriBEwTjU7XRUhwYwpAKbVba31RQr80CqK1Myj6wH2NsdgpGpMH18spuK9Ryql31yYS18spRG+rdPMJgiAIgiDEgDSmBEEQBEEQYsCPxtS9PnxnNERrZ1D0gfsaY7FTNCYPrpdTcF+jlFPvrk0krpdTiNLWhMdMCYIgCIIguIR08wmCIAiCIMRATI0ppdS1SqnDSqkjSqmvxuvcRKKUWqSUelopdVApdUAp9Xmbf7tS6pRSqlop1a+UqhONgdXYbPUNKKX+bYr7JKU+cF+jlNNpoVHK6VvvJRp9IgyN+2y6Lqwbaq2jSkAqUA0sAzKA14CyWM9NdAKKgQvtfh5QCZQBtwNfEY2B1/h3mDlDAq1vOmic5uV0OmiUcioag6Lxy5HeLxbP1CXAEa31Ua31IPBz4P1xODehaK3rtdav2v0u4BBQYj8uRTSOJYgaS4CWoOsD9zVO83IK7muUcvpWRKOPTKExYqIOQFdKfQC4Vmv91/b4o8B6rfWtE51bUFCwbcmSJdHamnDa2tro6OhgyZIl1NTU0NLS8ldMc40Fc+Y8WLpwMSnpwQi3C+krXVQIwN59h7uB7W4+wxJqamppaWn7DLDOTY0LrcZWqYsFBQ8GVR/Anj17HK6LpdTUnJD/GQHVOJaamhqam5vVlCfG4CL7APCvY44/Ctw9znm3YNx8TaWlpTpIPPjgg3rbtm1aa60rKir0dNVo9e0GqktLF2mtu3y0ODLO6KvXWtdrjVnB2PVn+Ow00Ch1McD6tJ42dXFallMdcI1jqaio0Nrjbr5TwKIxxwtt3lvQWt8LfAR4de7cKZe3SSpKSkqora0dmzUtNWqt79Vmev2PzJ1bBOQm0MLYOKNvfrdJkIX7z3A17muUuhh8fdOhLk7LcgrB1hgNsTSmXgFWKqWWKqUygJuARyc7N4bv8oWLL76Yqqoqjh07xujoKIjGVxJnWXw4q6+GwcFBAIX7zzAT9zVKXQwYY/VNo7oo5TSAGqMhLdoLtdbDSqlbgScwEfs/1VofmOLcx6L9vkk5+Q2zrWw32w0/iMtt09LSuPvuu7nmmms4fvw4wC9808g/m01tq9ku+t9xuWukGi+6yIu1KocZ/dmNALRm9gJQuOEeKFgd853P6ruRkZERgCZ/nuEw/LTc7A7kme1nf4GJ5YyNcZ7hj3wrpz9/n9nOGDTb9/0SyIn5tklVFx+70myHU832/c9g2gWxkRx1EXjxvWbbUWO2145rQsSM1edvXQR+vNF8z3ANAOozv4XUNTHfNqnK6R8+YbYpDWa74XdxuW1SaXzaPEfqesx263OYQYOJJ6YoYq3141rrVVrr5Vrrf5jq3Fi+yy+uu+46KisrWbduHaIxmIT0VVdXwzju6LE48gy/Ntm5jmiUuhhApmFdnPblNKgaIyVqz1Ty0A6vWY9Uw6v+muIlp4+a7bGXzDZOnqnkYA91pzoAyE/rNFkF/rxdeMcbDLX0AaCaKgFII89PgzzgBHrYeE5VqLyS7p85ntAOzV1m9+R+s31/7F6p5KEBDp02u/UHzfZa/6zxhueguQWAnnpTTnNTZ/lpkAechm7bVq2zTqMN/lnjDXVwyP7vrw397/fv/0YwxrcLgiAIgiAkKQ54pmbB8iqze+yEv6Z4Sat9G+6u9NcORoE+IDuO9yykYHY/ACcOVAOQP9ju50uGBywhXRsPRvfoCAC5g4OOaZyPUuY5csLGaTCMW96pPEgzz49ufy3xhvmwYtjsnvbXEu9YAkuNBzz3iM0aynKrmFIE+Sb+lGN1/priGQug0NbFY/5aAk40pgbgZfsDPrPdX1O8ZN+bZjt/wF87SCG+DSmALrKPmx+3zAKbNepUKwPoo6+1CYCWNDNRbm5Gn58GeUAjVDYDMGL/MaXST/zLi5+kwDHTfRKa71gxghmD4whH7X+mYX/N8A4FNSZgeb/9D3heejMw2z+T4s4wHDb/F7tNjya5tAAFE18SOEag0YjrtLP15DOEX61i6eYTBEEQBEGIAQc8U+kwt8js7gotjdMJ5PtlkDdkLjHb4y/7aoYn9I/Snm3eFPN77HPLavHRIC/IY1QZt/uMUGw2fnsZ481MyDXde8O2xz2VBtx641eQY3421Zl5C3vBpcEEI4vN9g82wP7/uPZ7mg9ZZhLJBXtsX+ZQq2PdfGmQbcMJakJ5rnnCU6HPPLT83aG8euIx3Uw0iGdKEARBEAQhBhzwTKVAvh0W2TRk8wZ9s8Yz8h8x22rX3i6A9HxG57QB0D8QmuAx9okek4tR+vvNm+LgmVcYB6rfW8gHZepe5pkQIqde9w3DJi6MMyGaI35Z4g351iN1RpZj+pgJGWa6gOM2Lqww3cF425FDAHTagRL59PtojEekmPi+ZtspVRiHyXOjxY1f8+5Rs9WhbpNuoNAva7whd5nZpr3mrx1ekDITTpgWRl+HCdKmEZjnn0nxJx9t2ouk24GZjKQ7FbcMMGK7vtrNtGEUMMc/Y7zCDpI62050bI6ifFvxUhpthkvdtJYBU/EKs2xDsXGxY783QIb5957fY/8vDhe48h//LBlmoNIsHXKgZPlminTzCYIgCIIgxIAbjanOUpM6MInaKS4IIA3zTGrFJNp8NiiOqCz0aDZ6NJuUYU3KsIaCrqmvCxjp6SY1KJNIdegZWlLTsklNy2Z2GsxOA/eCXsG4E1Pp6YGeHoBqn+2JM22l0FZKVxp0pQHs8dsiD1gOLKdtCNqGgHn7/DYo/rSfC+3ncrQDjnYAaW/6bVH86S2B3hJqB6B2AODIVFd4hhuNKUEQBEEQBJ9wowf1kuUADP39MwCkuxj0utgG1v29Pf57lyaZa2W4z8Rn9B6yWWkL/DPHI3LswuZpe0M5S/0yxTsGjCfq9C5zON+12EWAmSbOJuvRUMZy30zxhEUrAKj/4ysA5A3Ncm8cQYmZTufQPrOixPn7lsH5fhrkASUmqL7ePEaWnV4ART7a4wXzjD8o6/lQxrm+mSKeKUEQBEEQhBhwozHVmQqdqRwh1GPqYN8w1SYNY5d5cClOYzFdnYquTsXRbDiaDQz41/ftFbWDJvWkmwSvTnVJ4KgfMOl0jkkuaqTdpKo0k8CxiXTT6yC9jhqgBiD90UlPDyRdQ9A1RBPQBLDuv3w2yANsDHE9JlH0S3/t8YKeJuhpoiEbGrIB/uibKW5086Uat3SOHY7Nm8fhHP/M8YSsGwBoGfguAAUN7TDfT4Piy4oVqwHozbQN4dMZsMhHgzxgWal5dzn5kp3K48hqWOGjQR5QvK4cgLbDdgqP1iKcmx1hwaUA6OyXzPHRBbDMR3vizQV/DcBSnjXHexfCBT7a4wUXvwuAYmx/9O/WwvX+meMJl20BIJ9/NMd/XAAbfLTHC4ovAyBFPWGO9xX51l3rhmdKEARBEATBJ9zwTI2apuho6O0wK9M/W7xiwLiheq8yhwXzXZqVuJ03B7MByLGz9bLIpbXADEdSjEeqda7NWNECFPtmjxf0dZg1FVNDixHMcW+KC9pNF/t+O0n/mmWOrbE4amZ432093ysv6PTRGI8YrAPGTKLzXgdnQD9ZBZyd2OLdGxycAT3fzKB7yo7FKj/fP43imRIEQRAEQYgBNzxT55rh19mh4/27YYlfxnhEuYkpWhRayqL1hE+xKBoYIr5jpWdxTolp1+8yL4ysaE5xbkWgFXZqhOOhZ9hdBrm+meMJ2cuMV/jsD8tCv0zxjnIzbceFyi595NqPTeY6AM5vsMespvf7AAAelElEQVTPdcFV/pnjCYvMj8uZFWR+NQdu8M0abzh/DQCXho53KniHb9Z4Q4FxSS0NddQcXgKr/THFEc/UCmAFTZXQVAl0veG3QR6w2qQXMKnxmE92KLyYdEZnr0dnr2fOTpizE+CJuH+H33Rnz6c7ez7tldBeCfATv02KP0PvgaH30PkSdL4E8B9+WxR/6ldA/Qra6qCtDuBOvy2KL71XQO8VpGEbxdk/8tkgD3j53fDyuxkABgBmO6jx8Dvg8DtoI7Rexl3+2uMFRyrgSAXHj8Px48Cif/HNFEcaU4IgCIIgCP7gRjefXcZ9fok97AcIBb7m+WCPF1gdocmW2xomPDN4jNJZ/xwAp+0EtitH3JsdfKioAoD0wsdMRu4MH63xCHUUgKF1oYwy30zxjNIrAejNethmONaVmZMFwJkhLnN96jfxkk2zAMgJHRc7WE6vKAXG/JMvuHTCUwPLEvPchkPHg/PGPNTEIp4pQRAEQRCEGHDEM/UMAEffaY4y1TD5Zwa9OvLG0W+8Gac3msMiVhHyyPnWFI8bzVSfNpHn6TYgeyA1B9cmuJj9jHmGa85MnHeRb7Z4xkuPA7Dyv4UyFvtmimc8/UUA3vWpUMZa30zxhlsBOOfr9rCp17kYe/Z+CYDLttrjnu6Jzw0qr38egOWftcfpLk2nY3nRPMeLP2KPZ/nnJZ7SM6WUWqSUelopdVApdUAp9XmbP0cp9aRSqspuA7vqbm1tLVdffTVlZWWsXbuWu+4ygXqtra1s2rSJlStXUllZSVA1hqNv06ZNDA8PT3Gn5CVcjUCqr4bGgOvlFNzXKHVR6mJQmA4a44rWetKEmVXwQrufB1Ri3D3fAb5q878KfHuqe1VUVOh4gRmjH3HSRwffdq+6ujq9Z88erbXWnZ2deuXKlfrAgQP6K1/5iv7mN7+ptda6pKREB0ZjFPq++c1v6nnz5mlv9Q1rrYej1zWiTRqHcDUC9d5qNMBGmyLT2Ku17p3gnslWTuNVPpNZY/7HntT5H3syYo3Paq2fjVJfYuriW4n4OZZ9UFP2wXHvlWx18b5ekyLVeO4d9+tz77g/ao2JLKev2hSpxhnv+6Ke8b4vBkLjX97boP/y3oaINX7pxQb9pRcbov5ea/vUbaVwTnrLBfBrYBNwGCjWZxtch6e6NhkaGs+8+sSU9968ebPesWOHXrVqla6rq9Naa33eeefpoGjsn6jFMYm+uro6nZmZqROhL1pdo288okffeCSs73i7xl5dV1etgf6EaJx9uUmRNjQOPmlSVBoTW06jfY76yA6TAqDx5i8/oW/+8hORa/zTT0yKQl8i62KISPWV5ebostycsO49kcZE1cXjNkWq8Ts33aC/c9MNUWsMwv+MDRdX6A0Xh/f9fmv89kMt+tsPtUSsceePv653/vjrUX9vuI2piALQlVJLMEte7gLmaa3r7UcNjJn/LMjU1NSwd+9e1q9fT2NjI8XFZrmPtLQ0cEDjRPrmz58f6K6FsUymEUfiBF0vp+C+RqmLUheDwnTQGCthF2alVC7wMPAFrXWnUurMZ1prrZTSE1x3C3ALQGlpaWzWxoGL0yb+keru7mbLli3ceeed5Oe/dW04qzdBGmMLFMxkGMh4W34Y+sYlXvp2tr4Z9bUAj526EIDrJ4n3nVhjNpNIjPsznNdu1qhrjPC6F0dM5PZlk5yTPOU0Oqr6NgGwcpJzkkXjzSkHAHggwuueyvokABsn+Nzvuhgr7edOPXgiWTSW9hyM6rqDazdMeU6ylFNojuqq6sVTD9BKFo3vGn4uqut+k/FBAK6M2YLJCcszpZRKxzSk7tdaP2KzG5VSxfbzYuD0eNdqre/VWl+ktb5o7ty5452SFAwNDbFlyxa2bt3KjTfeCMC8efOor68/8zkB1jiVvvr6+tBbxtsIgj4ITyNjpiQZiysag15OwX2NUhelLopG9whnNJ/CrHtxSGv9/TEfPQp8zO5/DBNLlfSkdb99QTutNdu2bWPNmjXcdtttZ/I3b97M9u3bAWhpaYGEaUwlpoEufW/1SoWjb/v27cyaNSuMm2sm+A2ckkvrzuHSunOiuhagqPlNiprH926FqxFIyPLwjbqfRh35CuadL9bT+WL9uJ8lXzmNjq6j9XQdDYbGOx8Z5c5HRiO+rvkXrTT/ovVt+fGti3Gg36YIqXspl7qXxl9YMtnq4o7/XMGO/1wR8XVVP+yj6od9436WbOX02KFCjh2KfDHT/odMGo9k0/j4v/Xx+L+N/zwmo+ffD9Hz74c8sOjPmCqoCuMd08B+YJ9N1wEFwFNAFfAHYM5U94pnoF082blzpwb0unXrdHl5uS4vL9ePPfaYbm5u1hs2bNArVqzQeXl5Oqgaw9G3ceNGXV5ernUA9WkdvkZgr3ZYY5DLqdbua5S6KHXxz5NoTG48G80XS5oOf1DXNQZZn9ZaA7u1wxqlnE4fjUHWp7XURS0aA4Eno/kEQRAEQRCEtyKNKUEQBEEQhBhwYp4PQZiahMS6CoIgCNMQ8UwJgiAIgiDEgHimhGlC/tSnCIIgCEIUiGdKiIh+eqnUr0Kv35ZERveuEbp3hTezvGaIIcafBymp6QLCnhJpFIh8zhbfaSfWBQKEQDEK9PhtROQMMMG84NMZt/8g0pgSBEEQBEGIAaV14lqLSqkmzGtGdAsJJZZC3mrnYq31lHPiK6W6gMOeWRVfItYY8GcI7msMt5xOB41SF5MHqYsTME00Ol0XIcGNKQCl1G6t9dSrZPpMtHYGRR+4rzEWO0Vj8uB6OQX3NUo59e7aROJ6OYXobZVuPkEQBEEQhBiQxpQgCIIgCEIM+NGYuteH74yGaO0Mij5wX2MsdorG5MH1cgrua5Ry6t21icT1cgpR2prwmClBEARBEASXkG4+QRAEQRCEGJDGlCAIgiAIQgzE1JhSSl2rlDqslDqilPpqvM5NJEqpRUqpp5VSB5VSB5RSn7f5tyulTimlqpVS/UqpOtEYWI3NVt+AUurfprhPUuoD9zVKOZ0WGqWcvvVeotEnwtC4z6brwrqh1jqqBKQC1cAyIAN4DSiL9dxEJ6AYuNDu5wGVQBlwO/AV0Rh4jX+HmYAt0Pqmg8ZpXk6ng0Ypp6IxKBq/HOn9YvFMXQIc0Vof1VoPAj8H3h+HcxOK1rpea/2q3e8CDgEl9uNSRONYgqixBGgJuj5wX+M0L6fgvkYpp29FNPrIFBojJurRfEqpDwDXaq3/2h5/FFivtb71z867BfhfQP6MGTMKzznnnGhtTThtbW10dHSwZMkCampO0tLS9leEo3H1OaB8MTlizmqcR01NHS0t7W/TaPXdAsyeMWPGsmDqKwJgz55D3cB2N8vpEmpqamhpafkMsG5KjavOCUzU5NjnaMpph9TFGTOWBbWcAuzZs2c61MXwymkgNZZSU3PCSY1n0dTUHKe5uXnqX5EYXGQfAP51zPFHgbsnO7eiokIHiQcffFBv27ZNa611RUWFFo18IMj6tNYa6JoGz/BZZzWOSl3UUheTFvmf4YbGsVjbPe3mOwUsGnO80OaFc24gKCkpoba2dmyWaAwY4+jLwv1nuBpXNZ59P5S6GDCmaV2UchpAjdEQS2PqFWClUmqpUioDuAl4dLJzY/guX7j44oupqqri2LFjjI6Ogmh8JXGWxYex+gYHB8H8O3b9GWbivkapiwFjmtZFKacB1BgNadFeqLUeVkrdCjyBidj/qdb6wBTnPhbt903K039jtqrfbN/1L9ak2EhLS+Puu+/mmmuu4fjx4wC/8E3jE18224wcs736K5gBCLERqcaLLvJo4e+9dsSs+ZGF9d+Py23H6hsZGQFo8u0Z/v5Gsy20f8OLvh6X247zDH/kj8Ym+H/vNruFq832Q3cB82K+c/LUxV74pX2OrDKbG34QlzsnTV185QZrUKnZXnBXXG6bVHXxqf9httnnm+3ln4zLbZOnnAK/3mK2+eea7dV/F5fbJpXGXR8x244ys313fH5ToyGm8FOt9eNa61Va6+Va63+Y6txYvssvrrvuOiorK1m3bh2iMZiE9FVXV8MU3SOOPMOvTXauIxqlLgaQaVgXp305DarGSInaM5U8tEF3p9ltDTWOh4mHZyp5aIfMPrPbetLmDRAPz1Ry0AnHWgAYqjf60te3AAU+2hRvukHZd5eGE/6a4hkdjPaZepdyrMbmjfhmjTf0QWuH3X3B5vVjwn8c4fCw2fY8Y7YX+GaJd+T3mO3x523Gh4Fsv6zxgG4YzTW7Qwdt3gnMrAYO0dJrtj2v+msHgRkYLQiCIAiCkJy44ZlqqgdguLEBgDR6MDG4rqCgzoyeGOloBSC1rw2yC/00Ko4MQX8TACOtxmuTrltAueSZyoWh42b3VMgzNYiZFNgVUjn65gAAqtx4apb3t0LWAj+NijM91FYZz82MZUbjnL79kH2Jn0bFlxFbTlOtB44GYL5f1njDC0fMdmXoX2ADsNQvazxghP6TRuNAjunVmEk7rnmmBk/WADCaYjzgWbQBs32xxYHGVCv0tgOQktJt84b8M8cTToNpLzKaabrDUrOjm2w1OWmBajN4IGWWfXZqlo/2eEE3vGa7o0vsQAmnGlLAYB8zMk1BnZF62uRlpftokBekMX/wKADpGdaxn73EP3PizhC80WZ2V4dCCvJ9s8YzOs3/DJptNxH9E54aTNLJajwGQNayxTYv1z9zPCLjTfubuiGkzb8mjXTzCYIgCIIgxIADnikFLeZNUQ3ZwEmqicdw7OShj/6MPwGQNRQKOu+d+PTAkc5QhnmGGTkhF20tUOSbRfEnBVSl2S220wbQjVNvixkw3GYHEnSvtZl9/tnjCd20tJmu9oIeszxGulMa0yHDeqRK7NQPdAI5fhnkAf0wut/szrjS5i30zRpvaGCw33iJM4ZD/wsH/DPHE3rRfdUAqJ6LbV4nfg3MEs+UIAiCIAhCDDjgmZpLV75pcecNhPq9HXrbB2AOw01mMsuOfLOd6ZLG4TRaaQRgdo/xuGVQ7KdFHjAKNhSF9lG749AzBDjdxWnrwKgoDIl1KagXGOqjxTimmK/qbKZjq2WEHBipoZgpx4LPAV632/WH7I4r08yEyKbPPr6MC0OxxKsnPDuYdFNnxi1RMmQrJSW+WeNAY2om/bVGRrUdfHK+cxVjkAMtXQDMazDdYDNdGq2Y1sdAu/kFb+2eC8B8p+YJA8jmFVvfL9hlGlNpf+mjOV5QNJPnbO/J3HwT9Frqwk/MWNJz2W2jCZYeM918OU45+Ic5VGP21rxgJ5h6t2/GeEQWv7XTTF3/zDvMznv8s8Yb0nnSrmN5+cHzAFjgVDkFKOJF+6/+Ayf876Z17a8rCIIgCIKQUBx4bcxnxqCZJmDhjFCea4F2Ocy1ntr5xV02z4FHd4YcZmgzhL5gRmgWYtdmzh5llX0bTlvv2jBsS7/iQtvNN3deaI4il2aVBuhhlS2a2Ws6/TXFE9JYFZp1Ze2gr5Z4Rw/nWK8N72rx1RLv6OFiWxcXXNrsryme0cxFoX8Ty/z/TRXPlCAIgiAIQgw44N6oJafXuG1SzzQNHVonC0Cfpq/K7GYVh16pXJn9HKCPtEHreisKTfng0rQIACl0vmz2Zl7vzwy9npPVz/AzZrf5chPztsi597W5DD5h9vQGU0bVJGcHj0ZafmP2ij7l0goEY2ml9fd295a5vlriHV1U/9TsLb7awQEEAMym6j6zt+Rd/j9H137pBEEQBEEQEooDnqk5NM4wS4+MKLNEwAJeB5b4Z1K8qRuh3TozulJMbFEeDTgzJLu/naY+08E/Mzf0nt+CWxOvnqDRxjAsWulAtRuPN6uosQ7FjUuHJz83qLS/SLWtdu9c7tJknZbRF6i1+oryHX3Xrn6UtpCzZsEcX03xjINPsdeGK2640LXR7Zah3zESWnXsEv+9qA78qucyb6FpaTR22PWWamc7084AIEPTZtcerbtsDQCrXepcyEpl+Jjp3mt+5wYACp1rTGXyhh07cP7wJwAnKt9bWbyYUbu04sv91wPg0PK/hoGZFNjxLf35HwUcCypImUthaMnIdZ/z1RTPqKyjP1T5Fn3YV1M8443T5IeiCebc6KspnlHJ2TWNi7b5aQkg3XyCIAiCIAgx4cDL8XG6R81s2TOHzSrZLBqd5PwA0nCAGXbh79VF6TbT/0nK4sZzr5BabgIIC2eHuodW+mePF5x6kaV2qbO02Y6VzxCHX2dGudm95Pzuyc8NKgefZs47zW5WsUMT54Z49lekXmT381ybnsRy6DGKLrf7C9wcDNJ3+lGKNtqD+S4NVhpD1ePMv8LuF/gfViCeKUEQBEEQhBhwwDO1mNycXQBU2bWIVg4WQsYklwSN4vPJfdPstt1q3vhnMwKuLLmSv4EZv/8MAK2fzgdgDumTXRE8SsqZ8wez21tiIkNzfDTHC6qXlJLzjNn/Y58pmxv8M8cbZleQ/6DZrfyuCcxc5aM5caf0Ehb+zO7ft8ZXU+KPnUj22EKW/+I1s/9fF/hnjieYSUiz28/hv933BgCt/2EiF50LtR9ZzeIzZfUqX00BJxpTwOhmAFJ+/UtzfM9rQJl/9sSZzn1P0nOd+efU/otaAGa/5ziwzEer4kfNm/fSvsH0Y87/qf2R+/+GcaV4AvCL/8nAh8xuzlPVZsexuNDsP/6EfSvM/kdeO2J2NvlnjxecPvj/6LrB7Jcf32N2FruzsFvHS3eS+hGzn7vrSbOz/tP+GRRXZgLwLI9x3mdDL2uhhY5daTiaUW2/O/QQF3y6FID52AnuHBsO8trBv2ex/U2l0U4cNu+9vtkj3XyCIAiCIAgx4MCr/zAtKablXf9+k7Oc5T7aE0eefR2AjJIZ6IZcAHo/YSPRh2cG/+m9+BQASy5Io/dpM95cfdzqC7w4y9H9ZvuhCs75Z+s5vdGxd5jqpwFYcGMJl1snRvr7h3w0yAOqdwBQdPNiiu63eVcV+2dPvDn9AgAzP6zgMZu33qkOTHj9uwC88w7gnottpiseKcvpOwF4z98A/9lmM93ySHH45wCUf2EZfLLV5M1b56NBBsd+1QVBEARBEBLLlI0ppdQipdTTSqmDSqkDSqnP2/w5SqknlVJVduvTGNPTnHjpFCdeOsWyIVg2BJGuW1dbW8vVV19NWVkZa9eu5a677gKgtbWVTZs2sXLlSiorK0mYxhGbrloIVy2k92gKuwbS2DWQRtnzdZQ9Xwdp7WHfLhx9mzZtYng4QcNLB2y6rAguK6Kp8hzua8nlvpZcsh+oIvuBKuBERLcMVyOJjtpftsakPfP5Vip8KxX4Ua1JEeJvOR21aRyWX23SyzP4bQb8NgMW/zCFxT9MATrHuSBUwN9O0tXFEMtTTXr5fL5bsILvFqyA+1NNioCkq4shijJN+uONPJB7KQ/kXgoPHDUpQpK2LhY2QmEj+++9hUcvuJ5HL7geTtSZFCFJW06LmqGomcpHN3Df+m3ct34b/O4FkyIkaTWuHoDVAwzvuIZ752/l3vlbYcebJvlIOJ6pYeBLWusy4FLgvyulyoCvAk9prVcCT9njQJKWlsb3vvc9Dh48yEsvvcQ999zDwYMH+da3vsXGjRupqqoiPz8fAqoxHH0bN26koaHBb1OjJlyNQGBX/XS9nIL7GqUuSl0MCtNBY1zRWkeUgF9jxugcBoptXjFweKprKyoqdLT02wRElc7cIAw2b96sd+zYoVetWqXr6uq01lqfd9552huN1rB9R/VffHa9/ovPro9YW2neObo075ywv3E8fXV1dTozM1PHX5/hyM//GPWzu/2zt+nbP3tbRN83kUag3yuNulnrjCx0RlYU5VO/blNsGr0rp5YjJ/Vnbr5Zf+bmmyPW2PPcQ7rnuYeSXuNz3787+t+ZCPGjLr76s4cTpm8yjV7WxWi0vfefPqff+0+fi5tGr8vp//ziFyLXmTZbkzY7MBq/9vFrElpWx8PaPmXbKKIoX6XUEuACYBcwT2tdbz9qwOOF1GKda3ik9ncApK6YfBhzTU0Ne/fuZf369TQ2NlJcbIJM09LSwBONjQAMlC/lmpG/AOBX7IroDq3l4S+4OpG++fPne9q10D73XdFfvDKy2bQn04iXke0FcEm/mXvoeSLtxjs3orMTX04No8tLyD0QWRdsiI5zzSrI4c6v5ZfG1rkfAm716vZn8KsuZucmbk6OxNdF061cxiIORlgHWw99Kqpv9KucpvRcC9wZ2UUZX47qu/zSePLwFuCJCK96hxemTEnYAehKqVzgYeALWuu3BEJofeZNYLzrblFK7VZK7W5qaorJWK/p7u5my5Yt3HnnnSH35RmUUhBwjWHoG5eg6APR6EI5Bfc1SjmdNhoDXU5hemiMB2E1ppRS6ZiG1P1a60dsdqNSqth+XgycHu9arfW9WuuLtNYXzZ07N2pDD5xu4sDp6B/Is0cu5NkjF074+dDQEFu2bGHr1q3ceKN5c5s3bx719fVnPscTjaVAKcNNR/hB9u/4QfbvIrweup8/Tvfzx+Fws0njMJW++vr60FvG24jHM5y3YHdU1wG0/jKV1l+mTha3DISnERMD+DbiUk674fnFtTy/OPLgck7VmTQF/pVTQwqal9/ZwMvvjDymJ/35fNKfz5/yPL81zl06XtB8/PC7Li65eOpzYsW/upgP5NOUErn3La1nP2k9+8M+3+9yemVZReQXjZw0KUz81rh+w6IortppU2IJZzSfAn4CHNJaf3/MR48CH7P7H8PEUgUSrTXbtm1jzZo13HbbbWfyN2/ezPbt2wFoaWmBgGoMR9/27duZNWuWXybGTLgagfCHQSYZrpdTcF+j1EWpi0FhOmiMK1MFVQFXYtx4+4F9Nl2Hmbf+KaAK+AMwZ6p7xRKArqtNIspgtIMPP6cPPvzcuLfeuXOnBvS6det0eXm5Li8v14899phubm7WGzZs0CtWrNB5eXnaa40fvnSz/vClm2MIuOuwaShifRs3btTl5eXaK33N+9qj1nXT5+brmz43f9L7h6sR2OuVRq21zgSdGYXG4crderhyd8waE1FOb7xqkb7xqkURa/zTb3+l//TbXyW9xl2PtHoW9JoMdfHUs9H/joZDMtRFiHwgz+ZLP6g3X/rBuGn0upz+37/9U8QaUyjRKZQERuNH3/MjT8tqOIQbgD7lCfFMMTWmfCbcP6jrGoOsT2utgd3aYY1STqePxiDr01rqohaNgSBcjTIDuiAIgiAIQgxIY0oQhBgZZoJYYkEQhGmBNKYEQRAEQRBiwLsJDAVBmCbIz4ggCNMb8UwJgiAIgiDEgDSmBEEQBEEQYiDBjalRILJ11pKCFsKOrx1hkA5qvLTGG6qAgalPG2aAJo54bk7cOWiTAMAQ/dQH8Q9yEOgP79RRBukJYl2M4PdGcAENDPptRORovw1ILsQzJQiCIAiCEANK68Q1L5VSTUAPMP4CcslFIW+1c7HWesoFhpRSXcBhz6yKLxFrDPgzBPc1hltOp4NGqYvJg9TFCZgmGp2ui5DgxhSAUmq31vqihH5pFERrZ1D0gfsaY7FTNCYPrpdTcF+jlFPvrk0krpdTiN5W6eYTBEEQBEGIAWlMCYIgCIIgxIAfjal7ffjOaIjWzqDoA/c1xmKnaEweXC+n4L5GKafeXZtIXC+nEKWtCY+ZEgRBEARBcAnp5hMEQRAEQYiBhDWmlFLXKqUOK6WOKKW+mqjvnQql1CKl1NNKqYNKqQNKqc/b/NuVUqeUUvtsui6Me4lGn4iXxmTVB+5rlHIqGv/sPk7rs9eIRp+Ip0YAtNaeJyAVqAaWARnAa0BZIr47DNuKgQvtfh5QCZQBtwNfFo3TR2My65sOGqWcisbpok80uqMxlBLlmboEOKK1Pqq1HgR+Drw/Qd89KVrreq31q3a/CzgElERxK9HoI3HSmLT6wH2NUk4jwnWNrusD0egrcdQIJK6brwSoHXN8khiM9gql1BLgAmCXzbpVKbVfKfVTpdTsKS4XjUlCDBoDoQ/c1yjldNprdF0fiMakIUaNgASgn0EplQs8DHxBa90J/DOwHDgfqAe+56N5cUE0isYg4Lo+EI04oNF1fSAaiUBjohpTp4BFY44X2rykQCmVjvlj3q+1fgRAa92otR7RWo8C/4JxV06GaPSZOGhMan3gvkYpp6LR4ro+EI2+EyeNQOIaU68AK5VSS5VSGcBNwKMJ+u5JUUop4CfAIa3198fkF4857QbgjSluJRp9JE4ak1YfuK9RyukZRKP7+kA0+kocNRoijViPNgHXYaLlq4H/najvDcOuKwEN7Af22XQdcB/wus1/FCgWje5rTFZ900GjlFPROJ30iUZ3NGqtZQZ0QRAEQRCEWJAAdEEQBEEQhBiQxpQgCIIgCEIMSGNKEARBEAQhBqQxJQiCIAiCEAPSmBIEQRAEQYgBaUwJgiAIgiDEgDSmBEEQBEEQYkAaU4IgCIIgCDHw/wOSUPRlRlKJdQAAAABJRU5ErkJggg==\n", "text/plain": [ "
" ] @@ -1937,14 +2056,30 @@ "name": "stderr", "output_type": "stream", "text": [ - " 50%|█████ | 101/200 [06:05<05:57, 3.61s/it]" + "\r", + " 50%|█████ | 100/200 [06:29<06:29, 3.89s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 101 Train loss: 54403.0380\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 50%|█████ | 101/200 [06:33<06:25, 3.89s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 101 Train loss: 2308.0462\n" + "Epoch: 102 Train loss: 54435.0420\n" ] }, { @@ -1952,14 +2087,14 @@ "output_type": "stream", "text": [ "\r", - " 51%|█████ | 102/200 [06:08<05:54, 3.61s/it]" + " 51%|█████ | 102/200 [06:36<06:21, 3.89s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 102 Train loss: 2324.2892\n" + "Epoch: 103 Train loss: 54357.4960\n" ] }, { @@ -1967,14 +2102,14 @@ "output_type": "stream", "text": [ "\r", - " 52%|█████▏ | 103/200 [06:12<05:50, 3.61s/it]" + " 52%|█████▏ | 103/200 [06:40<06:17, 3.89s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 103 Train loss: 2284.1214\n" + "Epoch: 104 Train loss: 54368.0540\n" ] }, { @@ -1982,14 +2117,14 @@ "output_type": "stream", "text": [ "\r", - " 52%|█████▏ | 104/200 [06:15<05:46, 3.61s/it]" + " 52%|█████▏ | 104/200 [06:44<06:13, 3.89s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 104 Train loss: 2265.7720\n" + "Epoch: 105 Train loss: 54305.8840\n" ] }, { @@ -1997,14 +2132,14 @@ "output_type": "stream", "text": [ "\r", - " 52%|█████▎ | 105/200 [06:19<05:43, 3.61s/it]" + " 52%|█████▎ | 105/200 [06:48<06:09, 3.89s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 105 Train loss: 2280.9683\n" + "Epoch: 106 Train loss: 54326.0220\n" ] }, { @@ -2012,14 +2147,14 @@ "output_type": "stream", "text": [ "\r", - " 53%|█████▎ | 106/200 [06:23<05:39, 3.61s/it]" + " 53%|█████▎ | 106/200 [06:52<06:05, 3.89s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 106 Train loss: 2278.7626\n" + "Epoch: 107 Train loss: 54248.3700\n" ] }, { @@ -2027,14 +2162,14 @@ "output_type": "stream", "text": [ "\r", - " 54%|█████▎ | 107/200 [06:26<05:36, 3.61s/it]" + " 54%|█████▎ | 107/200 [06:55<06:01, 3.89s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 107 Train loss: 2257.5211\n" + "Epoch: 108 Train loss: 54299.8040\n" ] }, { @@ -2042,14 +2177,14 @@ "output_type": "stream", "text": [ "\r", - " 54%|█████▍ | 108/200 [06:30<05:32, 3.61s/it]" + " 54%|█████▍ | 108/200 [06:59<05:57, 3.89s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 108 Train loss: 2234.3032\n" + "Epoch: 109 Train loss: 54227.2680\n" ] }, { @@ -2057,14 +2192,14 @@ "output_type": "stream", "text": [ "\r", - " 55%|█████▍ | 109/200 [06:33<05:28, 3.61s/it]" + " 55%|█████▍ | 109/200 [07:03<05:53, 3.89s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 109 Train loss: 2229.8583\n" + "Epoch: 110 Train loss: 54208.4380\n" ] }, { @@ -2072,14 +2207,14 @@ "output_type": "stream", "text": [ "\r", - " 55%|█████▌ | 110/200 [06:37<05:25, 3.61s/it]" + " 55%|█████▌ | 110/200 [07:07<05:49, 3.89s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 110 Train loss: 2219.9134\n" + "Epoch: 111 Train loss: 54137.3380\n" ] }, { @@ -2087,14 +2222,14 @@ "output_type": "stream", "text": [ "\r", - " 56%|█████▌ | 111/200 [06:41<05:21, 3.61s/it]" + " 56%|█████▌ | 111/200 [07:11<05:45, 3.89s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 111 Train loss: 2224.8225\n" + "Epoch: 112 Train loss: 54148.8340\n" ] }, { @@ -2102,14 +2237,14 @@ "output_type": "stream", "text": [ "\r", - " 56%|█████▌ | 112/200 [06:44<05:17, 3.61s/it]" + " 56%|█████▌ | 112/200 [07:15<05:41, 3.89s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 112 Train loss: 2214.2873\n" + "Epoch: 113 Train loss: 54160.9420\n" ] }, { @@ -2117,14 +2252,14 @@ "output_type": "stream", "text": [ "\r", - " 56%|█████▋ | 113/200 [06:48<05:14, 3.61s/it]" + " 56%|█████▋ | 113/200 [07:19<05:37, 3.88s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 113 Train loss: 2215.9229\n" + "Epoch: 114 Train loss: 54132.4100\n" ] }, { @@ -2132,14 +2267,14 @@ "output_type": "stream", "text": [ "\r", - " 57%|█████▋ | 114/200 [06:51<05:10, 3.61s/it]" + " 57%|█████▋ | 114/200 [07:22<05:34, 3.88s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 114 Train loss: 2185.8746\n" + "Epoch: 115 Train loss: 54045.9820\n" ] }, { @@ -2147,14 +2282,14 @@ "output_type": "stream", "text": [ "\r", - " 57%|█████▊ | 115/200 [06:55<05:07, 3.61s/it]" + " 57%|█████▊ | 115/200 [07:26<05:30, 3.88s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 115 Train loss: 2155.6337\n" + "Epoch: 116 Train loss: 54099.1520\n" ] }, { @@ -2162,14 +2297,14 @@ "output_type": "stream", "text": [ "\r", - " 58%|█████▊ | 116/200 [06:59<05:03, 3.61s/it]" + " 58%|█████▊ | 116/200 [07:30<05:26, 3.88s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 116 Train loss: 2166.5751\n" + "Epoch: 117 Train loss: 54069.4480\n" ] }, { @@ -2177,14 +2312,14 @@ "output_type": "stream", "text": [ "\r", - " 58%|█████▊ | 117/200 [07:02<04:59, 3.61s/it]" + " 58%|█████▊ | 117/200 [07:34<05:22, 3.88s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 117 Train loss: 2183.6833\n" + "Epoch: 118 Train loss: 54081.5580\n" ] }, { @@ -2192,14 +2327,14 @@ "output_type": "stream", "text": [ "\r", - " 59%|█████▉ | 118/200 [07:06<04:56, 3.61s/it]" + " 59%|█████▉ | 118/200 [07:38<05:18, 3.88s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 118 Train loss: 2178.7413\n" + "Epoch: 119 Train loss: 54045.7140\n" ] }, { @@ -2207,14 +2342,14 @@ "output_type": "stream", "text": [ "\r", - " 60%|█████▉ | 119/200 [07:09<04:52, 3.61s/it]" + " 60%|█████▉ | 119/200 [07:41<05:14, 3.88s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 119 Train loss: 2176.9099\n" + "Epoch: 120 Train loss: 54002.5400\n" ] }, { @@ -2222,14 +2357,14 @@ "output_type": "stream", "text": [ "\r", - " 60%|██████ | 120/200 [07:13<04:48, 3.61s/it]" + " 60%|██████ | 120/200 [07:45<05:10, 3.88s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 120 Train loss: 2140.1265\n" + "Epoch: 121 Train loss: 53965.1260\n" ] }, { @@ -2237,14 +2372,14 @@ "output_type": "stream", "text": [ "\r", - " 60%|██████ | 121/200 [07:17<04:45, 3.61s/it]" + " 60%|██████ | 121/200 [07:49<05:06, 3.88s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 121 Train loss: 2156.4029\n" + "Epoch: 122 Train loss: 53992.2380\n" ] }, { @@ -2252,14 +2387,14 @@ "output_type": "stream", "text": [ "\r", - " 61%|██████ | 122/200 [07:20<04:41, 3.61s/it]" + " 61%|██████ | 122/200 [07:53<05:02, 3.88s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 122 Train loss: 2173.6097\n" + "Epoch: 123 Train loss: 53972.8280\n" ] }, { @@ -2267,14 +2402,14 @@ "output_type": "stream", "text": [ "\r", - " 62%|██████▏ | 123/200 [07:24<04:38, 3.61s/it]" + " 62%|██████▏ | 123/200 [07:57<04:58, 3.88s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 123 Train loss: 2193.6018\n" + "Epoch: 124 Train loss: 53969.1620\n" ] }, { @@ -2282,14 +2417,14 @@ "output_type": "stream", "text": [ "\r", - " 62%|██████▏ | 124/200 [07:27<04:34, 3.61s/it]" + " 62%|██████▏ | 124/200 [08:01<04:54, 3.88s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 124 Train loss: 2173.5100\n" + "Epoch: 125 Train loss: 53927.5200\n" ] }, { @@ -2297,14 +2432,14 @@ "output_type": "stream", "text": [ "\r", - " 62%|██████▎ | 125/200 [07:31<04:30, 3.61s/it]" + " 62%|██████▎ | 125/200 [08:04<04:50, 3.88s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 125 Train loss: 2156.6492\n" + "Epoch: 126 Train loss: 53964.3320\n" ] }, { @@ -2312,14 +2447,14 @@ "output_type": "stream", "text": [ "\r", - " 63%|██████▎ | 126/200 [07:34<04:27, 3.61s/it]" + " 63%|██████▎ | 126/200 [08:08<04:47, 3.88s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 126 Train loss: 2154.5458\n" + "Epoch: 127 Train loss: 53869.5820\n" ] }, { @@ -2327,14 +2462,14 @@ "output_type": "stream", "text": [ "\r", - " 64%|██████▎ | 127/200 [07:38<04:23, 3.61s/it]" + " 64%|██████▎ | 127/200 [08:12<04:43, 3.88s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 127 Train loss: 2150.1409\n" + "Epoch: 128 Train loss: 53871.5780\n" ] }, { @@ -2342,14 +2477,14 @@ "output_type": "stream", "text": [ "\r", - " 64%|██████▍ | 128/200 [07:42<04:19, 3.61s/it]" + " 64%|██████▍ | 128/200 [08:16<04:39, 3.88s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 128 Train loss: 2116.7759\n" + "Epoch: 129 Train loss: 53859.7800\n" ] }, { @@ -2357,14 +2492,14 @@ "output_type": "stream", "text": [ "\r", - " 64%|██████▍ | 129/200 [07:45<04:16, 3.61s/it]" + " 64%|██████▍ | 129/200 [08:20<04:35, 3.88s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 129 Train loss: 2135.7731\n" + "Epoch: 130 Train loss: 53908.0260\n" ] }, { @@ -2372,14 +2507,14 @@ "output_type": "stream", "text": [ "\r", - " 65%|██████▌ | 130/200 [07:49<04:12, 3.61s/it]" + " 65%|██████▌ | 130/200 [08:24<04:31, 3.88s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 130 Train loss: 2134.5957\n" + "Epoch: 131 Train loss: 53837.9960\n" ] }, { @@ -2387,14 +2522,14 @@ "output_type": "stream", "text": [ "\r", - " 66%|██████▌ | 131/200 [07:52<04:09, 3.61s/it]" + " 66%|██████▌ | 131/200 [08:27<04:27, 3.88s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 131 Train loss: 2127.2941\n" + "Epoch: 132 Train loss: 53871.7580\n" ] }, { @@ -2402,14 +2537,14 @@ "output_type": "stream", "text": [ "\r", - " 66%|██████▌ | 132/200 [07:56<04:05, 3.61s/it]" + " 66%|██████▌ | 132/200 [08:31<04:23, 3.88s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 132 Train loss: 2134.8713\n" + "Epoch: 133 Train loss: 53799.4480\n" ] }, { @@ -2417,14 +2552,14 @@ "output_type": "stream", "text": [ "\r", - " 66%|██████▋ | 133/200 [08:00<04:01, 3.61s/it]" + " 66%|██████▋ | 133/200 [08:35<04:19, 3.88s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 133 Train loss: 2120.6945\n" + "Epoch: 134 Train loss: 53817.8300\n" ] }, { @@ -2432,14 +2567,14 @@ "output_type": "stream", "text": [ "\r", - " 67%|██████▋ | 134/200 [08:03<03:58, 3.61s/it]" + " 67%|██████▋ | 134/200 [08:39<04:15, 3.88s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 134 Train loss: 2106.6445\n" + "Epoch: 135 Train loss: 53753.9780\n" ] }, { @@ -2447,14 +2582,14 @@ "output_type": "stream", "text": [ "\r", - " 68%|██████▊ | 135/200 [08:07<03:54, 3.61s/it]" + " 68%|██████▊ | 135/200 [08:43<04:11, 3.88s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 135 Train loss: 2097.3347\n" + "Epoch: 136 Train loss: 53785.4380\n" ] }, { @@ -2462,14 +2597,14 @@ "output_type": "stream", "text": [ "\r", - " 68%|██████▊ | 136/200 [08:10<03:51, 3.61s/it]" + " 68%|██████▊ | 136/200 [08:47<04:08, 3.88s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 136 Train loss: 2101.1914\n" + "Epoch: 137 Train loss: 53714.4720\n" ] }, { @@ -2477,14 +2612,14 @@ "output_type": "stream", "text": [ "\r", - " 68%|██████▊ | 137/200 [08:14<03:47, 3.61s/it]" + " 68%|██████▊ | 137/200 [08:50<04:04, 3.88s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 137 Train loss: 2117.9972\n" + "Epoch: 138 Train loss: 53829.2060\n" ] }, { @@ -2492,14 +2627,14 @@ "output_type": "stream", "text": [ "\r", - " 69%|██████▉ | 138/200 [08:18<03:43, 3.61s/it]" + " 69%|██████▉ | 138/200 [08:54<04:00, 3.88s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 138 Train loss: 2132.0983\n" + "Epoch: 139 Train loss: 53734.8520\n" ] }, { @@ -2507,14 +2642,14 @@ "output_type": "stream", "text": [ "\r", - " 70%|██████▉ | 139/200 [08:21<03:40, 3.61s/it]" + " 70%|██████▉ | 139/200 [08:58<03:56, 3.87s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 139 Train loss: 2101.7289\n" + "Epoch: 140 Train loss: 53774.9560\n" ] }, { @@ -2522,14 +2657,14 @@ "output_type": "stream", "text": [ "\r", - " 70%|███████ | 140/200 [08:25<03:36, 3.61s/it]" + " 70%|███████ | 140/200 [09:02<03:52, 3.87s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 140 Train loss: 2107.9268\n" + "Epoch: 141 Train loss: 53710.4300\n" ] }, { @@ -2537,14 +2672,14 @@ "output_type": "stream", "text": [ "\r", - " 70%|███████ | 141/200 [08:29<03:33, 3.61s/it]" + " 70%|███████ | 141/200 [09:06<03:48, 3.87s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 141 Train loss: 2086.3469\n" + "Epoch: 142 Train loss: 53724.4580\n" ] }, { @@ -2552,14 +2687,14 @@ "output_type": "stream", "text": [ "\r", - " 71%|███████ | 142/200 [08:32<03:29, 3.61s/it]" + " 71%|███████ | 142/200 [09:09<03:44, 3.87s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 142 Train loss: 2075.3563\n" + "Epoch: 143 Train loss: 53684.8880\n" ] }, { @@ -2567,14 +2702,14 @@ "output_type": "stream", "text": [ "\r", - " 72%|███████▏ | 143/200 [08:36<03:25, 3.61s/it]" + " 72%|███████▏ | 143/200 [09:13<03:40, 3.87s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 143 Train loss: 2090.5236\n" + "Epoch: 144 Train loss: 53695.5900\n" ] }, { @@ -2582,14 +2717,14 @@ "output_type": "stream", "text": [ "\r", - " 72%|███████▏ | 144/200 [08:39<03:22, 3.61s/it]" + " 72%|███████▏ | 144/200 [09:17<03:36, 3.87s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 144 Train loss: 2110.3560\n" + "Epoch: 145 Train loss: 53645.0780\n" ] }, { @@ -2597,14 +2732,14 @@ "output_type": "stream", "text": [ "\r", - " 72%|███████▎ | 145/200 [08:43<03:18, 3.61s/it]" + " 72%|███████▎ | 145/200 [09:21<03:32, 3.87s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 145 Train loss: 2131.0744\n" + "Epoch: 146 Train loss: 53627.6320\n" ] }, { @@ -2612,14 +2747,14 @@ "output_type": "stream", "text": [ "\r", - " 73%|███████▎ | 146/200 [08:47<03:15, 3.61s/it]" + " 73%|███████▎ | 146/200 [09:25<03:29, 3.87s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 146 Train loss: 2099.7526\n" + "Epoch: 147 Train loss: 53627.0840\n" ] }, { @@ -2627,14 +2762,14 @@ "output_type": "stream", "text": [ "\r", - " 74%|███████▎ | 147/200 [08:50<03:11, 3.61s/it]" + " 74%|███████▎ | 147/200 [09:29<03:25, 3.87s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 147 Train loss: 2102.8599\n" + "Epoch: 148 Train loss: 53624.9380\n" ] }, { @@ -2642,14 +2777,14 @@ "output_type": "stream", "text": [ "\r", - " 74%|███████▍ | 148/200 [08:54<03:07, 3.61s/it]" + " 74%|███████▍ | 148/200 [09:32<03:21, 3.87s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 148 Train loss: 2086.2113\n" + "Epoch: 149 Train loss: 53569.0120\n" ] }, { @@ -2657,20 +2792,55 @@ "output_type": "stream", "text": [ "\r", - " 74%|███████▍ | 149/200 [08:58<03:04, 3.61s/it]" + " 74%|███████▍ | 149/200 [09:36<03:17, 3.87s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 149 Train loss: 2083.9986\n", - "Epoch: 150 Train loss: 2059.0031\n" + "Epoch: 150 Train loss: 53564.5840\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -2682,14 +2852,30 @@ "name": "stderr", "output_type": "stream", "text": [ - " 76%|███████▌ | 151/200 [09:07<02:57, 3.62s/it]" + "\r", + " 75%|███████▌ | 150/200 [09:41<03:13, 3.88s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 151 Train loss: 53580.5680\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 76%|███████▌ | 151/200 [09:45<03:10, 3.88s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 151 Train loss: 2065.1667\n" + "Epoch: 152 Train loss: 53582.3500\n" ] }, { @@ -2697,14 +2883,14 @@ "output_type": "stream", "text": [ "\r", - " 76%|███████▌ | 152/200 [09:10<02:53, 3.62s/it]" + " 76%|███████▌ | 152/200 [09:49<03:06, 3.88s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 152 Train loss: 2061.5811\n" + "Epoch: 153 Train loss: 53538.7780\n" ] }, { @@ -2712,14 +2898,14 @@ "output_type": "stream", "text": [ "\r", - " 76%|███████▋ | 153/200 [09:14<02:50, 3.62s/it]" + " 76%|███████▋ | 153/200 [09:53<03:02, 3.88s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 153 Train loss: 2064.1517\n" + "Epoch: 154 Train loss: 53602.6540\n" ] }, { @@ -2727,14 +2913,14 @@ "output_type": "stream", "text": [ "\r", - " 77%|███████▋ | 154/200 [09:17<02:46, 3.62s/it]" + " 77%|███████▋ | 154/200 [09:57<02:58, 3.88s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 154 Train loss: 2077.5969\n" + "Epoch: 155 Train loss: 53534.8760\n" ] }, { @@ -2742,14 +2928,14 @@ "output_type": "stream", "text": [ "\r", - " 78%|███████▊ | 155/200 [09:21<02:43, 3.62s/it]" + " 78%|███████▊ | 155/200 [10:00<02:54, 3.88s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 155 Train loss: 2072.4356\n" + "Epoch: 156 Train loss: 53510.2260\n" ] }, { @@ -2757,14 +2943,14 @@ "output_type": "stream", "text": [ "\r", - " 78%|███████▊ | 156/200 [09:25<02:39, 3.62s/it]" + " 78%|███████▊ | 156/200 [10:04<02:50, 3.88s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 156 Train loss: 2047.8531\n" + "Epoch: 157 Train loss: 53473.8100\n" ] }, { @@ -2772,14 +2958,14 @@ "output_type": "stream", "text": [ "\r", - " 78%|███████▊ | 157/200 [09:28<02:35, 3.62s/it]" + " 78%|███████▊ | 157/200 [10:08<02:46, 3.88s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 157 Train loss: 2061.1302\n" + "Epoch: 158 Train loss: 53535.6280\n" ] }, { @@ -2787,14 +2973,14 @@ "output_type": "stream", "text": [ "\r", - " 79%|███████▉ | 158/200 [09:32<02:32, 3.62s/it]" + " 79%|███████▉ | 158/200 [10:12<02:42, 3.88s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 158 Train loss: 2069.8052\n" + "Epoch: 159 Train loss: 53473.0280\n" ] }, { @@ -2802,14 +2988,14 @@ "output_type": "stream", "text": [ "\r", - " 80%|███████▉ | 159/200 [09:36<02:28, 3.62s/it]" + " 80%|███████▉ | 159/200 [10:16<02:38, 3.88s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 159 Train loss: 2069.3980\n" + "Epoch: 160 Train loss: 53514.6540\n" ] }, { @@ -2817,14 +3003,14 @@ "output_type": "stream", "text": [ "\r", - " 80%|████████ | 160/200 [09:39<02:24, 3.62s/it]" + " 80%|████████ | 160/200 [10:19<02:34, 3.87s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 160 Train loss: 2065.0577\n" + "Epoch: 161 Train loss: 53455.0380\n" ] }, { @@ -2832,14 +3018,14 @@ "output_type": "stream", "text": [ "\r", - " 80%|████████ | 161/200 [09:43<02:21, 3.62s/it]" + " 80%|████████ | 161/200 [10:23<02:31, 3.88s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 161 Train loss: 2066.5313\n" + "Epoch: 162 Train loss: 53475.0180\n" ] }, { @@ -2847,14 +3033,14 @@ "output_type": "stream", "text": [ "\r", - " 81%|████████ | 162/200 [09:46<02:17, 3.62s/it]" + " 81%|████████ | 162/200 [10:27<02:27, 3.88s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 162 Train loss: 2059.9744\n" + "Epoch: 163 Train loss: 53475.7480\n" ] }, { @@ -2862,14 +3048,14 @@ "output_type": "stream", "text": [ "\r", - " 82%|████████▏ | 163/200 [09:50<02:14, 3.62s/it]" + " 82%|████████▏ | 163/200 [10:31<02:23, 3.88s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 163 Train loss: 2054.1571\n" + "Epoch: 164 Train loss: 53454.6420\n" ] }, { @@ -2877,14 +3063,14 @@ "output_type": "stream", "text": [ "\r", - " 82%|████████▏ | 164/200 [09:54<02:10, 3.62s/it]" + " 82%|████████▏ | 164/200 [10:35<02:19, 3.88s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 164 Train loss: 2056.8596\n" + "Epoch: 165 Train loss: 53427.2280\n" ] }, { @@ -2892,14 +3078,14 @@ "output_type": "stream", "text": [ "\r", - " 82%|████████▎ | 165/200 [09:57<02:06, 3.62s/it]" + " 82%|████████▎ | 165/200 [10:39<02:15, 3.88s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 165 Train loss: 2045.7509\n" + "Epoch: 166 Train loss: 53426.8360\n" ] }, { @@ -2907,14 +3093,14 @@ "output_type": "stream", "text": [ "\r", - " 83%|████████▎ | 166/200 [10:01<02:03, 3.62s/it]" + " 83%|████████▎ | 166/200 [10:43<02:11, 3.88s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 166 Train loss: 2044.3063\n" + "Epoch: 167 Train loss: 53390.6420\n" ] }, { @@ -2922,14 +3108,14 @@ "output_type": "stream", "text": [ "\r", - " 84%|████████▎ | 167/200 [10:04<01:59, 3.62s/it]" + " 84%|████████▎ | 167/200 [10:47<02:07, 3.88s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 167 Train loss: 2059.9163\n" + "Epoch: 168 Train loss: 53409.6440\n" ] }, { @@ -2937,14 +3123,14 @@ "output_type": "stream", "text": [ "\r", - " 84%|████████▍ | 168/200 [10:08<01:55, 3.62s/it]" + " 84%|████████▍ | 168/200 [10:51<02:04, 3.88s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 168 Train loss: 2055.8316\n" + "Epoch: 169 Train loss: 53358.5380\n" ] }, { @@ -2952,14 +3138,14 @@ "output_type": "stream", "text": [ "\r", - " 84%|████████▍ | 169/200 [10:12<01:52, 3.62s/it]" + " 84%|████████▍ | 169/200 [10:55<02:00, 3.88s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 169 Train loss: 2054.1673\n" + "Epoch: 170 Train loss: 53430.7460\n" ] }, { @@ -2967,14 +3153,14 @@ "output_type": "stream", "text": [ "\r", - " 85%|████████▌ | 170/200 [10:15<01:48, 3.62s/it]" + " 85%|████████▌ | 170/200 [10:59<01:56, 3.88s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 170 Train loss: 2057.5113\n" + "Epoch: 171 Train loss: 53373.2400\n" ] }, { @@ -2982,14 +3168,14 @@ "output_type": "stream", "text": [ "\r", - " 86%|████████▌ | 171/200 [10:19<01:45, 3.62s/it]" + " 86%|████████▌ | 171/200 [11:03<01:52, 3.88s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 171 Train loss: 2039.2451\n" + "Epoch: 172 Train loss: 53368.7840\n" ] }, { @@ -2997,14 +3183,14 @@ "output_type": "stream", "text": [ "\r", - " 86%|████████▌ | 172/200 [10:22<01:41, 3.62s/it]" + " 86%|████████▌ | 172/200 [11:06<01:48, 3.88s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 172 Train loss: 2048.7624\n" + "Epoch: 173 Train loss: 53353.5260\n" ] }, { @@ -3012,14 +3198,14 @@ "output_type": "stream", "text": [ "\r", - " 86%|████████▋ | 173/200 [10:26<01:37, 3.62s/it]" + " 86%|████████▋ | 173/200 [11:10<01:44, 3.88s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 173 Train loss: 2038.8059\n" + "Epoch: 174 Train loss: 53360.5540\n" ] }, { @@ -3027,14 +3213,14 @@ "output_type": "stream", "text": [ "\r", - " 87%|████████▋ | 174/200 [10:30<01:34, 3.62s/it]" + " 87%|████████▋ | 174/200 [11:14<01:40, 3.88s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 174 Train loss: 2045.0179\n" + "Epoch: 175 Train loss: 53351.1160\n" ] }, { @@ -3042,14 +3228,14 @@ "output_type": "stream", "text": [ "\r", - " 88%|████████▊ | 175/200 [10:33<01:30, 3.62s/it]" + " 88%|████████▊ | 175/200 [11:18<01:36, 3.88s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 175 Train loss: 2051.1847\n" + "Epoch: 176 Train loss: 53340.8240\n" ] }, { @@ -3057,14 +3243,14 @@ "output_type": "stream", "text": [ "\r", - " 88%|████████▊ | 176/200 [10:37<01:26, 3.62s/it]" + " 88%|████████▊ | 176/200 [11:22<01:33, 3.88s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 176 Train loss: 2047.7569\n" + "Epoch: 177 Train loss: 53299.8320\n" ] }, { @@ -3072,14 +3258,14 @@ "output_type": "stream", "text": [ "\r", - " 88%|████████▊ | 177/200 [10:41<01:23, 3.62s/it]" + " 88%|████████▊ | 177/200 [11:26<01:29, 3.88s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 177 Train loss: 2054.5523\n" + "Epoch: 178 Train loss: 53322.5840\n" ] }, { @@ -3087,14 +3273,14 @@ "output_type": "stream", "text": [ "\r", - " 89%|████████▉ | 178/200 [10:44<01:19, 3.62s/it]" + " 89%|████████▉ | 178/200 [11:30<01:25, 3.88s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 178 Train loss: 2054.5020\n" + "Epoch: 179 Train loss: 53275.7780\n" ] }, { @@ -3102,14 +3288,14 @@ "output_type": "stream", "text": [ "\r", - " 90%|████████▉ | 179/200 [10:48<01:16, 3.62s/it]" + " 90%|████████▉ | 179/200 [11:34<01:21, 3.88s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 179 Train loss: 2039.3899\n" + "Epoch: 180 Train loss: 53316.4840\n" ] }, { @@ -3117,14 +3303,14 @@ "output_type": "stream", "text": [ "\r", - " 90%|█████████ | 180/200 [10:51<01:12, 3.62s/it]" + " 90%|█████████ | 180/200 [11:38<01:17, 3.88s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 180 Train loss: 2031.6774\n" + "Epoch: 181 Train loss: 53294.6960\n" ] }, { @@ -3132,14 +3318,14 @@ "output_type": "stream", "text": [ "\r", - " 90%|█████████ | 181/200 [10:55<01:08, 3.62s/it]" + " 90%|█████████ | 181/200 [11:42<01:13, 3.88s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 181 Train loss: 2032.9211\n" + "Epoch: 182 Train loss: 53332.1500\n" ] }, { @@ -3147,14 +3333,14 @@ "output_type": "stream", "text": [ "\r", - " 91%|█████████ | 182/200 [10:59<01:05, 3.62s/it]" + " 91%|█████████ | 182/200 [11:46<01:09, 3.88s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 182 Train loss: 2044.1339\n" + "Epoch: 183 Train loss: 53249.3300\n" ] }, { @@ -3162,14 +3348,14 @@ "output_type": "stream", "text": [ "\r", - " 92%|█████████▏| 183/200 [11:02<01:01, 3.62s/it]" + " 92%|█████████▏| 183/200 [11:49<01:05, 3.88s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 183 Train loss: 2031.1374\n" + "Epoch: 184 Train loss: 53328.4840\n" ] }, { @@ -3177,14 +3363,14 @@ "output_type": "stream", "text": [ "\r", - " 92%|█████████▏| 184/200 [11:06<00:57, 3.62s/it]" + " 92%|█████████▏| 184/200 [11:53<01:02, 3.88s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 184 Train loss: 2026.4737\n" + "Epoch: 185 Train loss: 53218.7080\n" ] }, { @@ -3192,14 +3378,14 @@ "output_type": "stream", "text": [ "\r", - " 92%|█████████▎| 185/200 [11:10<00:54, 3.62s/it]" + " 92%|█████████▎| 185/200 [11:57<00:58, 3.88s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 185 Train loss: 2011.9869\n" + "Epoch: 186 Train loss: 53264.6480\n" ] }, { @@ -3207,14 +3393,14 @@ "output_type": "stream", "text": [ "\r", - " 93%|█████████▎| 186/200 [11:13<00:50, 3.62s/it]" + " 93%|█████████▎| 186/200 [12:01<00:54, 3.88s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 186 Train loss: 2016.1472\n" + "Epoch: 187 Train loss: 53213.9380\n" ] }, { @@ -3222,14 +3408,14 @@ "output_type": "stream", "text": [ "\r", - " 94%|█████████▎| 187/200 [11:17<00:47, 3.62s/it]" + " 94%|█████████▎| 187/200 [12:05<00:50, 3.88s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 187 Train loss: 2029.9464\n" + "Epoch: 188 Train loss: 53233.1180\n" ] }, { @@ -3237,14 +3423,14 @@ "output_type": "stream", "text": [ "\r", - " 94%|█████████▍| 188/200 [11:20<00:43, 3.62s/it]" + " 94%|█████████▍| 188/200 [12:09<00:46, 3.88s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 188 Train loss: 2050.0365\n" + "Epoch: 189 Train loss: 53181.2920\n" ] }, { @@ -3252,14 +3438,14 @@ "output_type": "stream", "text": [ "\r", - " 94%|█████████▍| 189/200 [11:24<00:39, 3.62s/it]" + " 94%|█████████▍| 189/200 [12:13<00:42, 3.88s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 189 Train loss: 2049.2701\n" + "Epoch: 190 Train loss: 53215.2880\n" ] }, { @@ -3267,14 +3453,14 @@ "output_type": "stream", "text": [ "\r", - " 95%|█████████▌| 190/200 [11:28<00:36, 3.62s/it]" + " 95%|█████████▌| 190/200 [12:17<00:38, 3.88s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 190 Train loss: 2027.0438\n" + "Epoch: 191 Train loss: 53185.2100\n" ] }, { @@ -3282,14 +3468,14 @@ "output_type": "stream", "text": [ "\r", - " 96%|█████████▌| 191/200 [11:31<00:32, 3.62s/it]" + " 96%|█████████▌| 191/200 [12:21<00:34, 3.88s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 191 Train loss: 2032.3673\n" + "Epoch: 192 Train loss: 53215.6580\n" ] }, { @@ -3297,14 +3483,14 @@ "output_type": "stream", "text": [ "\r", - " 96%|█████████▌| 192/200 [11:35<00:28, 3.62s/it]" + " 96%|█████████▌| 192/200 [12:24<00:31, 3.88s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 192 Train loss: 2024.0881\n" + "Epoch: 193 Train loss: 53168.9000\n" ] }, { @@ -3312,14 +3498,14 @@ "output_type": "stream", "text": [ "\r", - " 96%|█████████▋| 193/200 [11:38<00:25, 3.62s/it]" + " 96%|█████████▋| 193/200 [12:28<00:27, 3.88s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 193 Train loss: 2026.0871\n" + "Epoch: 194 Train loss: 53181.8680\n" ] }, { @@ -3327,14 +3513,14 @@ "output_type": "stream", "text": [ "\r", - " 97%|█████████▋| 194/200 [11:42<00:21, 3.62s/it]" + " 97%|█████████▋| 194/200 [12:32<00:23, 3.88s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 194 Train loss: 2024.8037\n" + "Epoch: 195 Train loss: 53125.8080\n" ] }, { @@ -3342,14 +3528,14 @@ "output_type": "stream", "text": [ "\r", - " 98%|█████████▊| 195/200 [11:46<00:18, 3.62s/it]" + " 98%|█████████▊| 195/200 [12:36<00:19, 3.88s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 195 Train loss: 2015.4725\n" + "Epoch: 196 Train loss: 53162.7740\n" ] }, { @@ -3357,14 +3543,14 @@ "output_type": "stream", "text": [ "\r", - " 98%|█████████▊| 196/200 [11:49<00:14, 3.62s/it]" + " 98%|█████████▊| 196/200 [12:40<00:15, 3.88s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 196 Train loss: 2007.3981\n" + "Epoch: 197 Train loss: 53161.7220\n" ] }, { @@ -3372,14 +3558,14 @@ "output_type": "stream", "text": [ "\r", - " 98%|█████████▊| 197/200 [11:53<00:10, 3.62s/it]" + " 98%|█████████▊| 197/200 [12:44<00:11, 3.88s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 197 Train loss: 2016.8807\n" + "Epoch: 198 Train loss: 53189.5240\n" ] }, { @@ -3387,14 +3573,14 @@ "output_type": "stream", "text": [ "\r", - " 99%|█████████▉| 198/200 [11:57<00:07, 3.62s/it]" + " 99%|█████████▉| 198/200 [12:47<00:07, 3.88s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 198 Train loss: 2011.6728\n" + "Epoch: 199 Train loss: 53112.2320\n" ] }, { @@ -3402,20 +3588,55 @@ "output_type": "stream", "text": [ "\r", - "100%|█████████▉| 199/200 [12:00<00:03, 3.62s/it]" + "100%|█████████▉| 199/200 [12:51<00:03, 3.88s/it]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch: 199 Train loss: 2007.1013\n", - "Epoch: 200 Train loss: 2017.4889\n" + "Epoch: 200 Train loss: 53137.6600\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -3427,7 +3648,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 200/200 [12:06<00:00, 3.63s/it]\n" + "100%|██████████| 200/200 [12:56<00:00, 3.88s/it]\n" ] } ], @@ -3435,8 +3656,7 @@ "epochs = 200\n", "for epoch in tqdm(range(1, epochs + 1)):\n", " train_loss = data_loop(epoch, train_loader, dmm, device, train_mode=True)\n", - " # test_loss = data_loop(epoch, test_loader, dmm, device)\n", - " sample = plot_video_from_latent(batch_size)#[:, None][1,:] # 128, 30, 2352\n", + " sample = plot_video_from_latent(batch_size)\n", " if epoch % 50 == 0:\n", " plt.figure(figsize=(10,3))\n", " for i in range(30):\n", @@ -3447,14 +3667,21 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 13, "metadata": { "scrolled": false }, "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "torch.Size([30, 3, 28, 28])\n" + ] + }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAA6gAAAHkCAYAAAAzRAIWAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJzs3Xu0PNlV2Pd9qh/39Xv/ZjQazUgjCcsCJJ6RiQMxscFk8XAQi1cgXl6yA4g42LyxZDDBy4kNYdkYY2cBisBWYowgxAsRguNFsFjYCZaRBEGg52j0mpnfPH+v++pHVZ388bvTdfau29VdXdX3nu7+ftaaNXVudVfVr/Y9p7pun13bee8FAAAAAIDzlpz3AQAAAAAAIMINKgAAAAAgEtygAgAAAACiwA0qAAAAACAK3KACAAAAAKLADSoAAAAAIArcoAIAAAAAosANKgAAAAAgCku7QXXOfblz7kPOuUedc29e1n4AAAAAAOvBee/b36hzHRH5sIh8mYg8LiK/JyLf7L1//5TXt38QAAAAAIBYPOe9v3/Wi5b1DeoXiMij3vvHvPcjEXm7iLx+SfsCAAAAAMTtE/O8aFk3qA+JyKeC9uMnP5twzr3ROfdu59y7l3QMAAAAAIAV0j2vHXvv3yIibxFhii8AAAAAYHnfoD4hIi8N2g+f/AwAAAAAgFMt6wb190TkVc65Vzjn+iLyTSLya0vaFwAAAABgDSxliq/3PnXO/TUR+dci0hGRn/fe//Ei28rzvHK9qzqORXbYihp7Dl9amul8NmVqm5zDJJl+jN7GzlXtacae/dQ1a610xmqdQy18YndV3ERM7Grvc3qElvDQ8GiVT9uCsTMnzVX1uaWe4GLb6xbH1mJVYmLnljVezn8Maxc71WjrnImcT+zWO1ZVWu2DwYmrGi/vvXRZJ3n+Dy2xh7nNzyHVavS5s4jbKc05V0Wjuludz3g5r6XloHrvf0NEfmNZ2wcAAAAArJez+YoOAAAAAIAZuEEFAAAAAETh3MrMLMrVmPteeqWZs768+eM15nUvbT54nd1M3++sc1i90yb/Hje1aVN1/UpkAkx3VjkCdfpOq7Gr2mzw+7SKUVy0X9XbyfLGhXqK46iKo0icsaw+jcs6x2fV5+Y/hlXrg7NPyzrFbkasVjwPfHn5wnZHMYyZ7tTFU18ZYR90S/ocMmOvZ7SfKtM/e5ZeGeF1b3nPU5i559a3yDeoAAAAAIAocIMKAAAAAIgCN6gAAAAAgCisXA4q2tBgrniMKQLzl61aETGcZNRH3KKmak4Tq5VhB/RNjt3qX9wgIgQSmI1vUAEAAAAAUeAGFQAAAAAQhein+DabzdPiI6B9PlnMc72lLB2p9uDgzmT55tNPqnWuq1979forJstbexfUuiTR4Um6nWBdR7TqE6Vmt5XnTFW+d/HXLoev83x9+xhwE7s8K+IxPLqj1g33ddvLcLK8e+VhtS7p9VW70+1Nll2i/w5k41r61wTHXH5i+Pmf/yZqxc7236zog2l6rNYd37mt27efmiwPRwdq3dUHXqna3d3Lqt3rbk2Wk67pg52K2Jl/2/k97n056sVOvVE182yo2oc3n5ksH93W4+Xg1k3VvvrIn1Tt7SsPTpZ7/W21zvY7H57/Gf+WWiWZIrdw3E6Rp0Xsjm4/q9YdPvdJ1T7av6Xa9z3ymsnyztUXq3Wdrh4/nStiVzU+WusUN5GGsQvem6W6zx3dfl61D59/XLWH42LMvP6ST1frti9dV+0kKa51Scd+56HjwXi5wHbyTLXHA309G996erKcJqlat3f1EdXuhGOkOeFhnxOx4TGxsge5Tv2uxdIxNnajo7uT5eNnP6bXmevi1Qc/c7Lc3b2o1pXHuaJd/rWriF3kceMbVAAAAABAFLhBBQAAAABEgRtUAAAAAEAUos9BtfOpa02ZrjV53OYq6rnj+bhoj9OBWpea9tFRkXuTp0dqXT/XfxNwWbDfTO/T++n5G75r8geS6tyPqRua8dJo1Mjn8Pl4shzGTURkbHJxwlzG49s6ZypzOl+4F+RA+rHO9QhSlO+9dxTsJ8hHFRHpbe2otutE3w0XVycPJ9fnNDPneDAo8jey0aFaN9zfV+2RFAFJUn3+Jdf52y7XwfNBTnlujj+xA1ApFzzckGmvQj9b2PR84cyOl2OdP5yNivX5rF8Xb2IXrjJxtCfcJWsdgAaCk156voIZL8fF9Swd6jja05+k5vyHsbNxLo0TQTvyPKl21Xm+ghm3TADGw2KMHNvx8lA/X2FsPu8kw+Ka5MxnlsrYNfnAtsHjZdjvRsf6WpYe6+crjMyzMVJXxL1rrm1y2dbgC59vYU/w/LFb51DVu23Qr05H+vN+enxXtYd3i8+Yo6G+Lqp7gZkHsvgZ18+jiRvfoAIAAAAAosANKgAAAAAgCtygAgAAAACisMbJbzXnkpfy0Ew+aJDXKKl+beL1fX4/qHPpgpqKIiJppt8b5vjkma7jV05NrMorPaP8gRZr6tXabeVKm/9WxC43+W/ZyOTaBHlpW30dq/xY56Dm+fTtus6umB8U+xCdF+JN7pCzCawVNQBjzxmwZv+2FK+wNWq9yUl1vugQScf0lZ7OldsaFrkg49zEMdP5WCJ7utkJYmc7YY2cqlWPXb18OPva8Hfa1gHWOcGd4Bx3xjP6htex1C+2df0anHG/4jmQtWpFT22I/a0NY9c1faNj6igmzvTnIHazz+iC57zRQysiMDNs0/M97XMzJHiGhe1zXVPfecvEbpwU2/K57XNV9UtX7Hy3qs7zFvS4lqfBczNsbrHpZ65rrn1h3qMbq3W25nRHgs84a1Z3tpnF6rOX+pzhzPNHkqCdJKamemaea+LHYcNsePU/XcyDb1ABAAAAAFHgBhUAAAAAEAVuUAEAAAAAUVjrHNTZgrnktiyVresXJlp0dU5hInoeugvyPbId/TeA9FjPM5ewfqmpZepMXoir+HNCeUZ6DHPUmxzD4rmuXtXQ0yet0zf5M0GNt8zUScz7Os7jQZF32rc1Fp2pzxjWqS3Fzfxu2Zwe+/J1FqZU2fNg4tHdKs5xbmqbph1zkreKXJt0oPOFfTqjn4W7LeV6VLXXLHK1uqDtD8U5TTq2Vqy57ITjXk/HNbMpqLaOdPA7smZn/3zYPN6OrTsbtG1cTa5canNQw1iWckNN261xv6pQKwXVrrOxC/JMEzH5/Oazhu+Z2A3Dz0YzruMthSeGTyyN1Er7np5T2LE5p5keE70p6+2zoh9mmc4Xts91qDyrG5LXeKrFUlBLfc7mevuO6Xfdot/ZsTUd62djqNhtUChCfIMKAAAAAIgCN6gAAAAAgCis4BTfiu/i684KVVNXTHkD89W9Dx7Z7syUl9yWxwinDg/0Y7+79tHSUkzJ6HRmfI+vjslOC20yB2D+qR1nVWSmXjUb/WL1+G5zTv3YlBxxweP0zbSnfKinZ3R6O8FrzT57dppocAyJmSZnp5T6+ae32elWjUppVFp8il15SliFcCa0OU+5LXERdFEvul+JmWI9HhbTesNpNSIi3s4wNb8jLvz9SWb9Da/GuYm9dIktW1HnvRUlC+zvqP2nd4K4Z6mJa88cRbdierbdcJMqM2ozKzD1rVHsgn+PHV/s1G0VV72ZbGinqJmp9cG4NmuG76LOL9Vl8f0sOl6WrvmlMj/Fem9fW7rW6eui88F10ZnSbFXBK/2z20rzia/P1YpbqTSPua4EU0NdaaqtNjafN9PhQbAds1dvr5NTG83Efm0z6sXOqOiDpY9ydn3QzsdH+sXm2pfnYVmuZQ2YcZfl4htUAAAAAEAUuEEFAAAAAESBG1QAAAAAQBRWMAe1xmOyZ04zD/JpbJ6geWWYllYqh+F1/moSzutOtvUhZXreeSfYlhNbQsG0g/Xls9BgjnqdJ5HPv9VG6Sf2pZWhtPPmk/BR3ual3sQ57QbrzD67ff3aIKcqMTGvil1i801K7SXlF5yT6ZnSM15tcxVNmRkXlHdyuX6ceymPtFP0Oz80uR65efR7qcxMELvS3/BWOzaVanW6GW9WpXoq8rNFRMISQeYx/TIyZblyU9KrIte1Saxs5uXGKOXxTi+nZa+Z4nTschM7n4Wxm57betr6ec2+Lq66inzPUlm6MFY6Nh1bIsisz4NnNfjU1HqqOqbSNb/J+Y87dvWGyxn58cF5suVHbPmmrul34/DDqclr1H3utB3Pu269NLrUVZyn0md288yZjlpvx8s7+pgyc+1bhshDzjeoAAAAAIAocIMKAAAAAIgCN6gAAAAAgCisYA6qTRRsMIla1X+bkXUUJCiW56vbnwQ5bH6o1oxNPkdYQ7Wc2zp1szNzhWpZVu2jM5vfbmMX1kacUbM2D+KRmnWDW/q9abHdfE/H0cYu0QU+9fGVamvOf6IiK1PVLptDVX5BsWROROLNe9O7k+Xx4Fity00Oaqm2rGos3s/KY0jswWuWmVO9rXCViZ0L88B1DtVoZGpreptTtSTRx8qwx7twnb8Zv+9BO0lsQWE9Jqam5rScRexWLW6NVNcX9mEuvb0GmTxw7/WYOBoWn1vCeowip13rKg6ihuXV9I6RjV3Ftc3koCYmdi7Iyx8d6fEzG+vPnxI+O8M+C6OG1bu2aU2ubIrN0Z/1HJkkeK6JWTcem88p46IuaukzSpOP+xWt2PANKgAAAAAgCtygAgAAAACisHpTfKtKl7Q4I600+yEvXmAf0Z55+8j2ou079hSbqaHh1/x2unJ5HkWw2FYJhSVqUGamEXWa9E47Jh5ZMO0sN6/NTNkENY00Kc2nmtpsq4RC8/fWEMbu3GaB2LIzQT8zcfQdHatMtopGMN1XpDxdxv77fDjdqsk/fsWmPVltTfgtT2k3Wwpil4su7eTHZjp25RTU1T7fbWrtslhZwqtnXqvbPh2rdu5nlSvZTG3FqvwZpoiVN59ZXNdMGzXTtV1Q4iI3pZ3O7bq+zsJrji15aD9D9nQ7D19vysrkuZ7iG1761rgC0ExtJrPoDdvxUscy6RVjZKlMV6qn0tup9Qsf0swfxItvUAEAAAAAUeAGFQAAAAAQBW5QAQAAAABRWL0c1Kr50zYHw1akqbUf+3joIAfV5rCZ/I5OmN+R60dHj0c6RyAdFTkCmdPrErE5PtWHPLcG26l3DtvL33PhnmfGNSzxYmLTMXlQYbKo+XNNOnxe/yC/MFncNrke0jGPhg/262y+ag3nlsbYUuzcjGBV/j7Zx+2HuYwmrzExOVVZNpgsD4Z31Lr02Dx63/b1cL81TsOKp5yW2T4YjHv1cnaml1QQEUmC8dObUiWDgS6bkI90TqqKXZ1YlX6wZsEL+6C5XjWLXVC6xOSg5uaCOxjoEkHpsMipKucSL3pEEknsljNe1qsWNL2ARGLGuE6ic71z0f1qcFzEbjQweYyl871g6a0YwtZE1WcUWTx2pfHRfobpmjz9INd7eKyft7B1qMfPRbMty11sxYNXEbuFK3SdbClkyzt1utvFK8261JSZGQfjZ2UpvJmHtLqx4htUAAAAAEAUuEEFAAAAAESBG1QAAAAAQBRWLwe1QRJqs5zUIEfA1KWyd/lhTbFc9vRm8uf0MQR1OJ1Jr0p6Vbke9eaVT89Oqef8ZrO3Uy3OdU1dKl/kc+Smnu3Y69htHQU5VKbGn0nhEQljN7O+rVm9Xok6pt0gwaMi/63T2VLtblLkesiRqT3sTOxMfcZS7ceqQ6porR2VK2fUyXN0pg8GOVVdr/Or5NjmnOrcb7dowd4Vzsuprc1cuYo+2De1NP1Q9zMvRduJrYlK7O6ZEatamwpra5rPLF0du17H9LvgWRk+H6hVzpvnL9Q6pqmNNVCR11hrM+b5CvZa191R7f520T4yj1fIsn3V9qqmrYl59UHVeO0qqsgDb7TZ6bHs9bfVujzTe8rTMCd1/hrS6xQpvkEFAAAAAESBG1QAAAAAQBRWcIpvHW3WnQm3Uz1tMQtLkBwfqHXDoX6U9N5xMQWj/PR2c4ALTz2s997oNZqyNn3adG5i4+/q6dh3x8V0w53hZb0V86cedYi1pvTO8YZV1tbj3e12ElsqppgSM8h1mZn8SE97Suzf6eqc/nXqV000mMkdli7xJhTH2U3VzoZmDluNv7ESqhe0MxXRmfIXYspfjDNTIui4mCrqzDTvyv1sctxaGy91M7FpSl2dIjHKimthdqjHy1InrYhPedUGBbOtUk+27EzXprcUU0XTXJeZGd/R/cypmaL2KGxJqToHuUaWVD5IRKcHdnp6qnaWjVQ7PbxVvM/O8K0aPtcobnyDCgAAAACIAjeoAAAAAIAocIMKAAAAAIjCmuegWi09Btxu1eTTuE7R7ly+pNblt3U+xyAtjsnbx7fbxMZ6B7X4eyu3u5zNNlMnAc7mWRTn2PV0bofsXVfN5KkidoORLqFwqUnZhDhP6hlZ8PHupbwcPZT19q4ULx3quA7HpvyFs2UTpsdjkyNVbfGxNcwf7m3p0k5yoLeb56ZEkM3Tr95TjddukAVz5Wzed3/XxG6ox8QsC0oGEbcFLVoOw+bC6c8s/b2Lqp3kxdaOh7bPzT9e4oT9PNYggdjmD/cvFte6JNV54Mf7Omc/D0o9JaJzIGftd3O1d9+grnUX9L1BT3Qe+OCwiJ39jFIdmfWJG9+gAgAAAACiwA0qAAAAACAK3KACAAAAAKIQfQ7qUmsxuen5HNVNW4NR53Ns9YvT+lw+UOue2r+h2i/ZLrbsutXbrVI+TdU1rhbWJFn3jLjwl2ZGTlVYl2p3W3eHp7YOVfvj6WOT5VcPTN3Nrq0NN/1vPxtbX2yWUv0xzatY6rU9kz/c3S5ycZ4d6T7nntO5Ho+U+llVYT+CN5caeY1JkA/X291W6257XQd1bPKHq8ZIQrUA2wcrYuc6eozrbumctruZrsl4/bjIqZpVB5XYzWHGeBle+6r6nIhIf2dXtY/SooZtfvMZs98a32sQyFO5qvMy8zOL+bx5ochBzS/p6+DBU/ra5/NUpiFSc1L3DcasHP6g7/S2dc5+vqXjevjc01O3W9ps5drVxTeoAAAAAIAocIMKAAAAAIgCN6gAAAAAgChEn4O6rFTKsjq1NO1bzXt7Rf7bVk/X0twe6Hnmg2xU7HFk/l6w0+Qfu0l1UCvMCmsQO7+tc6j25AHVvnL3ycnycGzqnqYmp8qUVK0+horXYj6JqYO6dXWyvDPU+VXDgc4tlsz0u6rYob6ZfbA4/52erg23LbquXz46mL6tUj+iYzVWGTu9stO/oNp9r8fEbBTkEzMGni+TR5r0dT5czxXt0dEdtc6Waw/HS8LYgpkfRU3ucbcYI3d6L1brbh3+sWpnQU3bnr4sog11cvgT/UFja+c+1d5/8iOT5TzVnzeTDfmMwjeoAAAAAIAocIMKAAAAAIhC/FN8z8yMx0PXkGbFHJi93ctqXXJZt6/uFV/r57ZUiX20dMWjyUszpmq8t5YVKDOj1Jqprc//lQceUu3HX/zxyfKLLr1Ev7kzf0kgZre1z5uzur1bzF/auqynje72dKmSzOn3VkeS6NXm50+f2DKP3k/M9OtShYv5qzVQ8WIRNWLX7ekSQYnX07PTvChdYjdbLikVrCNuC6lzqe52demt7SvXJsuDu59Q61LRc3zDD5Hl0ZHxsr566WZhyaa9h1+k3/m+oWoPhkWKxLZJYSJS7auMnLmY7b7oQdXO/qgoUTlKdRy7otMpKjNdVhjfoAIAAAAAosANKgAAAAAgCgvfoDrnXuqce6dz7v3OuT92zn3Xyc+vOed+0zn3kZP/X521LQAAAAAAmuSgpiLyfd779zrnLorIe5xzvykif1lEfst7/2POuTeLyJtF5E2L7uTM5sU3yq00OWyuyOfIEl0W4cFruuxMEuTtJPYgclPKhDzH2mrl4XTMvP7+kWq/+uFXTpb7e1fUOpc0+AUiWa4xZ/7W5lyRJ3XfdZ1LfOfw46qd2PNfhY5Vmzc5vlWd0iU6v+2CyR/Ox7bGRcW2CFZjtWLndGz2LujxdLgfXAvrhIYwngH9WePylfsny3ee/rBa59L5+yCxOwvFSd69qK91bkfXkvHHzwSNV4p+sQkOieCNVWcT69bORV0iKO0En2mG+3pDF/V9RMVmV7rPLfwNqvf+hvf+vSfL+yLyARF5SEReLyJvO3nZ20Tka5oeJAAAAABg/bXyFF/n3MtF5PNE5F0i8oD3/sbJqqdEzKPCive8UUTe2Mb+AQAAAACrr/FDkpxzF0TkfxeR7/be3w3Xee+9TJkU5L1/i/f+dd771zU9BgAAAADA6mv0Dapzrif3bk5/wXv/L09+/LRz7kHv/Q3n3IMi8sz0Lcyzjybvnl+dDML9gzuq/VNv/XnV/skf/7HJ8pbJqXrkoc9X7ftfW8w7f/x9H1Drjro6PH/7B//+ZPnrvvxPq3Wd7oz81JbyCVahDKqvyCm8vf+8av/jt/7SZPnH//u/qdZ1cl0v8/LeS4vl196n1skNna/6ov/scybLP/sD/0Ct+7SX6fyB6tpxK5xA0FBVHP/wA3+s2l/w+frvXIkv+t1rPv0/Uuu+5Gv+kmp/7V/7LNV+5tlnJ8uf/Vm6v/7u//tv9H6CPBFHns7pTBi/+uu+WrV//Vd/fbK809dj3uu/QvfJvUvvVu23ffE3TJZtyv7bfvGXVfsvfn2RbUKs5mRi91M/+xOT5e/+b39Ardsydby/7qu+U7Vf+RmfPln+om/W+anjkR5rv/Evv2Gy/C/e+la1zm3wmLiogwP13YHcd7+pgZnq8/9Zr37tZPkbvvWH1Lpv+Zz/VLU/8fhHJ8uXr15U62586gnV7vSK/k0fnGLGMxH+3Bf+GdX+nXf9P5Plra2eWvfffOvfU+0n/kXxeefXfufL1Lp0PFDt//Nf/avJ8n/+5/Vrid3pqj6ziIi86L6iTu3zN59T6y7u7aj2d333z0yWf+grvl+t+7f/36+rtvh0svjU40+pVdcf0J9VVyl2TZ7i60Tk50TkA977nwhW/ZqIvHB1eYOIvGPxwwMAAAAAbIom36B+kYj8JRF5n3PuD05+9oMi8mMi8svOuW8RkU+IyDc2O0QAAAAAwCZY+AbVe//vZPr8wy9ddLvlHZn2kr6drn4ctNbt9FX7eHBLb6tTvLuT6y0noqf8Zs8V0yqyI/2Ftr+gw9MdFtM3XHI+X9OvzuSA0/U7e6p9ePT4ZNme0iTX06a7wbTR9An9GzIa6NjlTxXTNXpj/fsy26qf5eXLzZQ0cWZ+ZxCe7ChVq3bNdLddM5U7D/pomuo+uErTY2KVpcPpK0sDr37tlf6xaveC1w/Mm/eCcl9oybg4x7aMjzftw5FOe7iaHE6Wd8xrR6a9mzV+PAYUPW55U1bGdrvDg9Fk+cLhoVp3paP74MeC8kK5uWZSnmQJkullfrJUR/Lg9k3V3usWbS/6uui9jtVoPBLUM+s+IhXzuSUwNiXU8jtFOtrF3i3zav1aH+75nO4NloGrAAAAAAAgCtygAgAAAACiwA0qAAAAACAKjcrMnIkIp1OnAz13//9+5/tU+/YztyfLz5l55Z+68U6zteIf2OnovxdcufZi1R74jwdv06UzZiIXRERExgOd0/bz//RfT5b3bx/oF5tHht8+eKxoPPWYWmdzE2/tF48Qv3v47eYoPnfGUVJmZpbff/+Tqj0e2nya4hz+waPvUev+4Cd02wpjeTi6oVfyJ705Tc/i/9Tzt/UPgpcej3Qc3/6rP15jn7qvDPpHU16HRe2nxTm2FRVGY53X+I7f+FnTnn8/R53peXaoLxvq2OSpbmeZbn/okx+cLP/1H/6v595POtb5qW5G9TucpjqT8dmRzg0N++E41ePnW//5jy58FIOUHNS2+SnLIiLHJq5/95987/wbDlNQd6a/bNXwcQsAAAAAEAVuUAEAAAAAUeAGFQAAAAAQhehzUG2ey7JSKavqnlqdns7X6JVqEtXZ8vT13ut8yQs3difLztSsOrNUxRVPidzq6fO9berBtcVnRe243Q9f1Cs/e9a7V/wkn4Fet7qOXxNh/mou22qdO6O6zKsvPDH6pDmT6t0evZ/OIXVQ29YZnU1uaC8ndm3yPd3OWx0xC5lJOj23zymrbEYxzW37oXhJ+unu7BehlmxZw2fwK9FJo7+tmxvfoAIAAAAAosANKgAAAAAgCs6f0XSByoNwpYlzE97bKZjnNUfEn7rYYCutmj31uaXzZqdcJ9O3G8Pv1mwVcZ0x1abS9BmOp4Ti7H+nbVkcazViN6dSnoBdL9PXr1js1ipuIjK7063WnMGNit2sfjf/yihsbOzWeLwUWcPYLaqyv55P/9yoPteE6q9xjKUz+t17vPevm7UNvkEFAAAAAESBG1QAAAAAQBS4QQUAAAAARGEFnkccx3xqdRzTU2bLljRNvjy9+4zOUyzhaI07dfH0l4bBrJGgGklOwMaadf5Lq+PL59hcnP+VRd9ZXVWxY7xcT8Ruda1p7PgGFQAAAAAQBW5QAQAAAABR4AYVAAAAABCFFchBnVlY6xzUOAaTr+rq5C7G+E/f6NpTVQGIIThoB7EEgPkwXgJoH9+gAgAAAACiwA0qAAAAACAK3KACAAAAAKIQfQ6qTXlcvXI/M4trLv7W8xDjMQEAAABYC3yDCgAAAACIAjeoAAAAAIAoRD/F1/IbXeZktVTGyszVrjNzuFb1HW+btuzP9O3GYcZ5qvgHlP898/8Lw9iVCiM1iF0tFf+e8nmY/uKlxjU4EOf1UZnmwr/jrsaYZ/ucW72ciMXN+P13UxtLVOOXb+VjN+vfWvXPqdXX5z6iZprETjXO6IDtOQzHppnv1W+uOv+NxtPgXJSG7JbGy3vbXvBat2p9rgnGy9W14uPlvPgGFQAAAAAQBW5QAQAAAABR4AYVAAAAABCF6HNQk4R76FVF7FYXsVtNxG11EbvVRexWF7FbTcRt/RFhAAAAAEAUuEEFAAAAAESBG1QAAAAAQBS4QQUAAAAARIEbVAAAAABAFLhBBQAAAABEIfoyM977ZW791MUZr4ySK/2g9JOW6DPh3PS/cSw3dmpPFcdwRofQwNnFLtxF9T6WFztf2ZxzVTTUWaTPBcdxRoexIMbLacf8aElnAAAgAElEQVRwRofQwHmMl/d2M30/xG4+ZzNemn2e27Wucq/mGM7hEGZwUxun/mA5xxBFnyvt+dTFU5rnYnaozj928+IbVAAAAABAFLhBBQAAAABEgRtUAAAAAEAUos9BXS536uKprwzmu5/XPPMYcgLObj91TD8mZ3M9ln0opx5D7R+sMVfZVKv8+cfOKqdVnEXsYvz9qD6msN9FMV6WfsB4eeoaF0du3HnkKq6GVbvWEbvT6fOi+t055TUSu3mF9w3mGQPnFrv572VWCd+gAgAAAACiwA0qAAAAACAK3KACAAAAAKKw4TmoK+ZccqjQ2EbnnALnhH5XXwyJ3iKEalURtwWFJ+68Er8JXn32nMWQtL8++AYVAAAAABAFblABAAAAAFHY7Cm+LZWO8Xmm2sODW5Pl45uf1OuOD1T76kOvmSz3L1xR61yi/37g/fzTQM6nHMZZaa8UQhi74eFttW7w/KdUe3i8P1m++vBr1Lre3mXVdq6Ina85DcSt81TulkrH+Gys2oP9m7p968nJcqnPPfzpqt3bu6raYb8L4yhy2u9a8YP1f0x/MF621OdEREZBvzt69uNq3eDojmpff+RzVbsXjJl1YmWt93ip+QbBU+Plge5zw1uP6/bhXdW+8tLXTpZ7e8u61q1b3Nq51vksVe2Bid3o9lO6fVzE7vJDdrw0sXOdYj81rnX0uTnfa8fL4POliMjwTnCtu/O8Wnf5kdeqdm/v2mTZJR21rs4xblLsGn1mqbg3GN19Uq+79ZxqX3rksybLvQvX1LpmsVudWPENKgAAAAAgCtygAgAAAACiwA0qAAAAACAKG52DWmsueTDHOxsfq1Xpsc61Gd0p5pmnw5Fa51KdCyI+n/8Aa0wdt1PSV2ja+Uy10jnMi7PRkWqPB0Xshnd1Xk46HOptjYPYNUnCmyHc9DrFTWTxPiciMh4UuaTpsc4XHt7VuYppWuSoJjZWvvqkLnrKG3TXlVDvV754cT7W/cj2wTCnKhvp3OIkNePjkvrdeo+XNc6ZHS/HA90eBn1wX+fCZanOt3L20rakIXOtx8uWrnXhdU5EJN2fPl6KiEgeBG/GeLmode5zInXzTqvGy0PdPtaxy4LPlF7seFl1Upt8wFz8rdFrkHOapzp2ubnWZcG9Qj7W9wJe9Pi5tM+YKzRg8g0qAAAAACAK3KACAAAAAKLADSoAAAAAIAobloO6WE7AvWY4t1/P23a9Ld3eCtpHeju5yTn1PpyHbpMy5jnOTbFg7Eo5viZ23SJWSadf9VJVP6qUL2ARuxOL57/Z+m/h+Xe9bbUu6epcORkUeTs+t7UEdb6VW1Zy3MprUuw0fK/pDB192UmCtuvq+m5ia5tW5enQ55ozfdDWzHPd/qnL995rN2audZLaF6CRqs8oovqO6+rx0nX0czRcrmtFiw/zGmfEjX7XnBou9ZgXfka5t9r2u6AWt/18OetzyoLWOgW11ovteGm+8zNjZDhm5vZziR0vXRC7Fk9wxZU5OnyDCgAAAACIAjeoAAAAAIAobNgU3wbC6YV2ilpu2sFtv3N6ylqW2ce5r9IX7udo0dmGdoqaiV0niF3SNVNrnH5t7ospFz6vKA+EQpPZs3aKdac3We7ketpZ0tMvToLXpkM9fc3bWU+lR63TD5sLxstEj4GJ123XCaYiJroP5s5ML7T9LvLH5K8c2+cSe20r4uE6Zmw1cc7NFH3JqqZjE8d7GgyYpfGyiF3HfEZJu+bFpt9lQT/z2TpP6IxEcEpnjpcmds4XscttWa68aso+cWysNF6a2OUmdklwXTTXLm9jF/Q7t6Gx4htUAAAAAEAUuEEFAAAAAESBG1QAAAAAQBTWOwfVlq2o9ebpc77tfHD7aGkfrPe5yTlNdU5VXvkY8Dbnna9YruuyYmdzUoPYefO+PB+qdpYWpUzybGS2M/8x1LOC+T9B7GrFzcZGbE5wHizbPmdyqNKijILtg+WyCTaRZJ6DnYP5HY4+X7JRn6tQ0eds26e6X/mRLh+Uex275Z3RTRovQ6XaWqaZTF2XjXXpkjzVsfNh/13aOd2g8bL0b7P9KshhK/U5k/9mno0Rts+uPNCqxc6WL2uyrem5iaWyM+a5JuGYmOemzy2pzEzZio2Xhl84ePbfOqNMV5DrbXP0s0yPnxS/4xtUAAAAAEAkuEEFAAAAAESh8Q2qc67jnPt959yvn7Rf4Zx7l3PuUefcLznn+s0PEwAAAACw7trIQf0uEfmAiFw6af+PIvIPvfdvd879jIh8i4j8dAv7OV/hXPLEzivXOQGdoAajmLqb3uSgSlbMQ1/uzP3VywtoRanEpfmbTBC7jolVKc9xWOTH5anJLV5a+syGxk1E7L89zN+w9Rk7HRPXIE8nG5q8xuyM8nI2OnRBTpU5Ed7kUCWdTvBak0t8XrHb1OCV8sCnxy4pjZem5ve5xG5D4yZySo57OF7aPmc++pk6qH4c5KCauJXPcFvnfINjF5qVg9oxsQzW50ObS8x4eaZKsbN1ULtTX5oPTOzys8r9jlejb1Cdcw+LyFeJyFtP2k5EvkREfuXkJW8Tka9psg8AAAAAwGZoOsX3J0Xkb4jIC4/nuy4it72fPFbscRF56LQ3Oufe6Jx7t3Pu3Q2PAQAAAACwBha+QXXO/QURecZ7/55F3u+9f4v3/nXe+9ctegwAAAAAgPXRJAf1i0Tkq51zXyki23IvB/UficgV51z35FvUh0XkieaHuajqGkWLb9Vs1+RvJEmQg+r1a9OhqRWXFfPM20xjjL3k4tmxdfyq8hp7ap03r02zoA7qWOcH2DpaxK4F9kQEfcmZPucS+yy2Ih6pqc+YmVqbDQvYFccwx0/itpzxsiqX+F676He5yZXLMlMH1eR+h/2uSb9Z+T5X6ivLj10yY7ws10Ut+l1pvCR297QWNxO5WeOl2W86OipWZeZaV7WfOse36nGzfcPWRW1rL85+vtSx80G92zQ3tTSzdvIYy2XeVz54ypK6YOnzphozzSnMiF3Jwt+geu//pvf+Ye/9y0Xkm0Tk33jv/6KIvFNEvv7kZW8QkXc0PkoAAAAAwNpbRh3UN4nI9zrnHpV7Oak/t4R9AAAAAADWTBtlZsR7/9si8tsny4+JyBe0sd3GnPmuvrU5F7akhZk+0wumYHTts6SH+pD8kr7GX7nphWfETvENYud6PbNOTzf0wfTC3MSx0SHN8ZOVEh5+m9Nlgmlq3ptH7ZvYSfgoflPayeemRFB5T/Mf02Jvi9PSxstSrSfd6haxS0rlLvQU36VNe1r54GmtdcGKkhdh3O6tsuOluda1VDZhnWPX6iT78HOJ/YxiYudNmS6fhdOx2ytVYifF4jS2z5l215YIKvqdH5vSTm3FjlDNqTp2LoydGS/zob03IHbL+AYVAAAAAIDauEEFAAAAAESBG1QAAAAAQBRayUGNl803nJ5j1STXo/QY8E5xWp35G8B4uK/a6bClXMYVenT0XOzc/SBCzR4DPr1sQqdjHr1vcgTGwaP308GRWtfo0fvrFrvgX1/V505pzr3dpNTnbJmZ4rXj4V21ZnxsHuc+9Z3zHNI6xc6Ol2Z10PEajZdSUZbL5MaNRjpWY9Ne/CDWKW6nCP59zrdX/iIsm5B0TN63GS9HA93v0pHOJ25wEO1sJ0b2utdS7MqfUUzsvF4/PLg9WbbjZSMbHLtQrTiWSpXofiZJ8XlzfHRTrcpGpqTawtY4biKytM8spbKGYQ6q7oPp8I5q5+NZz8qY+yBa2s7Z4xtUAAAAAEAUuEEFAAAAAESBG1QAAAAAQBTWPAfVsjWK/LQ19fIcK/Lhup1ttS4f6z35LJxnPv9OV3dW+aKCHAFpL6cqjF3S3VKren0dOz8u6lJl6aHZUD7/Luc/ujUwvc/ZZq04mnqZVbHLx+b3Jde5cI7YzcdV9MFa46XJqQry4XomjrZmbT7Wud+MmXOoyOcXWfxa50weY6+r88Btie9c1UUlbnNp61kMM3JQbb9TZb5zm4NK7OZSkW9bL7fY5jFOj50tz+6zxfO+3TrnC1eyn1lMs9azGKbnoHbNczOykf4ckueL5Q+vU9z4BhUAAAAAEAVuUAEAAAAAUdiwKb5W+FW4n7qmvHbGVoPHgCdb+mv8UWYevT8sHgvuZkyIcVMbG2bGlLV65YOCaYvm8e3d/q5qZ76YbpgNDvRWfI2AbHLsqqbZ13qce/Wj9zu9ncny2Ovp2OnxLbMjYlffjGmjdTYVxK5j+tw4y1S7Tr8rrSF2J6aXX6szbdSOl8mWjt0o0/0uC8rO2FJDlUe4RlPWmmsn1aUcO53OMvZFrFJTpqsqduU+R+xOVVGSZlYcnU1v2SqudSPR42M2sqlINcZLnK5BCa8wdmHcRETGmS5BmY/CdJYa9wZrhG9QAQAAAABR4AYVAAAAABAFblABAAAAAFHY8BzUUHuPlg7nmW/tXlbr+sc69yM9Kp7F72vkwc7KV90sTTKGg62Y3I7e3kXV3sqLPJ3RgX70vhedK+dEPwre7Gmh41tPLeWBd3S/6u9dmiz3RnqYGx3px7d7px/vvpnZHg01yakK3tvb2VPrtrzuk+NjXTYhjJ0T/Ttg98uYOU2QU2VOka9ISnWmdEl/54Juj/TG0kHR78p9jr+V11bR50Sq+53NQe3vXNLtYRGP9EjXLiF2SxDGclYiuIl7b6sYM/vHel0+NHVnzKdINFQeMOd+fRg3EZHekYndKIidfUDHhsSOkQUAAAAAEAVuUAEAAAAAUeAGFQAAAAAQBXJQ5xXWPrL1x0rTw4v7/t6uzmNMt/Xc8f3bz06WXzIr+42aYvNRsbIqYmdyqnrbOqcq3ym6y+GzT1RtdtrhoMqME1WV11jKh9stYjfu65yp8XNP6fdW1YYjdoupNV4Wr+2aWpq+owNwcOtZ0apiR/CasudQ5aSadd1tnVM17up+d/f5ot89OCuHitjVV6oPXijlEpvX9s3zFoLHLcjdm8+odQ/a2sNhk7g1Vtnn7r1CtbrbxZg57unnK+yb8fK+qvgQu8ZK15xSXnhwrTPPW7CxO7j93GT5+oaOl3yDCgAAAACIAjeoAAAAAIAoMMV3IXYqzfTHu7tOX63r96+odnb3yeJ9vrrMBtowPXblmdq6VMz2hQcmy4dPPKrW+UxPZ6usMoPFhNNGZ5RUcJ2tyfL21v1q3eFzj+n35qbf6QoMaKzOeKk7Tm/3qmof39TTsxesKIUFTS8KVb7WbW3r2GUHxXTDGTNO0bJZJbtKn1O275ssj+8+rd9rY9fw2FBtZiWTIHb9Lf350t95Ur+WKjNnq6LjucT0uS1d6kn2g363mVVm+AYVAAAAABAHblABAAAAAFHgBhUAAAAAEAVyUJfMJTqhbeu6zoe7/dGPTZZzr/MYbSpcmKNKCYWWVCZV6XO89+KHJstPvPe2WjfOhqrdkeLR7+RbtW9W6mHY73bvf5Fad/DEH6h2lqeqnUiRv0rslqAqIc6UC9q59pBqHzz9QdXOfDZZ7prLWSmnn+A1VzFe2mvd9lVzrftYkfvtzbXOla52aNXMJFTd77avFWPm4XMfUOtysZ9TiN1yVQcvLLG2ffG6Wnfn6feZdwafITclkfFcTY+dS0xpvJ3Lqn1w9+OnvOv0ra4rvkEFAAAAAESBG1QAAAAAQBS4QQUAAAAARIEc1KXTs8cvXH1YtZ86fmfRyHQunHR1nSQsQY06ijsXXzxZzk2NVBne1e09XQOwcp+bklDQolkpVeFPLlx9qVrzqWysX5qOdHtrb/qOiV1zlX1Or9y9/GLVHh4fq7ZLgzGzuyVYshqx27um+91T7w+udbmpG23SGHneQstmXuemx+7xoyO1ztnPKUHtYvK+l2FW8Ir1u1dfptY8++F/b14a9DvH91PLVxU7c627pu8Nbj7+h5NlWzt8Uz548BsKAAAAAIgCN6gAAAAAgChwgwoAAAAAiAI5qAuweRbe5NP0t4pcqDzL1LqXXNd1qr7j+39usvz1L/8cte7JZz6m2t1ukahzfKRzsTpd+7eGzZijXpuNXbB87aqOze07t1R7b6eI65vf9M/Vuh/6su9T7X/3h/9HsEv9O/DMk0+q9rUX6Tqd5O2cTvc7Hcft7V3VHo+KurTXL19U6773zf+ran/rZ3+Fan/wE++dLCeJ3s/h3QPV7m8HeY/E7VSl8dK0t/rFOcxMftuDV6+p9vf88C+o9n/5J75gsvyJGx9S6+yYODgsxsxOz9ZuJHanKceuuNb1evoZCbm5Dr70Pl0H9Xv/u1+cLH/1S/6kWvfMzSdUuxvEbjDQNaaThL+rzyWInTfjZbdrY6evUWG/+/4ffrta97UPv0a1n3r+k5PlTkfHZjgYqHbSoWbqLLbP2c+Q3Z55/kXglQ/oPMbv/EF9rftzlx6YLB8c6Vruvb6+HRgG/Y7PJPOxsRuN9Ni1vb0z9b2f8VI9Jn7Hm946Wf4zu7pG6mB4qLe7sz1ZPjo0OeMrHDtGegAAAABAFLhBBQAAAABEgSm+bTDfoNvpNKHBQE/XuHhwZ7J8qaO/mn9S7HTUYkflr+1X92v8M1VRnyTzpvyIkY6LKWzZ7WfVuku95/VmXR42zDEwzak5fU69ZFNeJzIe6qmHW3dvqvbl3r7ZVh4sm1gxvbAxO3Tl6nxrx0M95Xfvtp52f6kTTnWy01FtvwvapXXTjhbTVF3nRESOBzp2l+8WUwovJ3rq59Ola13RzwhNG+xZzE991QsGQb+7eFdPBbWfU25IOJWYzyVNNTljB0e6ZNr14POliMilpFh/YPuv59rWVDl280dz/1BPB77/uPhccsHpsVSPniJ+TWO3nv8qAAAAAMDK4QYVAAAAABAFblABAAAAAFFw9rHI53IQzk09iBiOzyo/Blznc/T6vamvbSJ8vP441fmSif1bwxmlflQ9wjrG2JXSLoIfXDLlSA729aO823JrX+erXt67qtpn8VjwWfuIMXbqmMzx9bZ02YQsnZ6TWodL9Hmyj43vJEUa/1k9zn31+lx1mZmwbIItVdKELUcyTov8q/J4SexOUyozE1zruqYsRZuHH8YuTXX+1XmVTVi12IkaLnW/6nRt7No5fjte2tgl7uy/E1m5a505nMycw25/epmZJjqmBNB4XHzGpM/NyRzTcKBzgrd3t2UZ+kGptsFAl6CMMXYi8h7v/etmbYNvUAEAAAAAUeAGFQAAAAAQBW5QAQAAAABRoA5qG8xt/rJmxqs6qHYn/KlhPlV1UNtLf6uUZNRBbcqb/IZlpaPY7TpbPxMz2dDYU7i88bJix+eUl7PqwnJ7y8wAs/0bzZTGy6XtSe+n9DmFsM5k6wufVYnLcg1b1FW61p1R7PI1HS+5rQEAAAAARIEbVAAAAABAFJjiuwD7+OSO01M2fYulErBcYSyPDg7O8UgwSxgrO6HFPoof8bDjpTPRy7N2SgKhfVXXOp9HWOYBhSB0ielzfEaJl+1z3c5ySgKhfTZ221tbqk3s6uEbVAAAAABAFLhBBQAAAABEgRtUAAAAAEAUuEEFAAAAAESBG1QAAAAAQBS4QQUAAAAARIEbVAAAAABAFLhBBQAAAABEgRtUAAAAAEAUuEEFAAAAAESBG1QAAAAAQBS4QQUAAAAARIEbVAAAAABAFLhBBQAAAABEoXveBzCL9161nXPndCSR8aZ9VqfF7rfqpcTunlnnLPLYbWzcROKIHX2uHeGpibHPmRe7MztINEXsVtd5DAsAZuMbVAAAAABAFLhBBQAAAABEodENqnPuinPuV5xzH3TOfcA595845645537TOfeRk/9fbetgAQAAAADry9mcpVpvdu5tIvJvvfdvdc71RWRXRH5QRG5673/MOfdmEbnqvX/TjO0sfhAAAAAAgNi9x3v/ulkvWvgG1Tl3WUT+QERe6YONOOc+JCJ/1nt/wzn3oIj8tvf+1TO2xQ0qAAAAAKyvuW5Qm0zxfYWIPCsi/9Q59/vOubc65/ZE5AHv/Y2T1zwlIg+c9mbn3Budc+92zr27wTEAAAAAANZEkxvUroh8voj8tPf+80TkUETeHL7g5JvVU78d9d6/xXv/unnuogEAAAAA66/JDerjIvK49/5dJ+1fkXs3rE+fTO2Vk/8/0+wQAQAAAACbYOEbVO/9UyLyKefcC/mlXyoi7xeRXxORN5z87A0i8o5GRwgAAAAA2Ajdhu//6yLyCydP8H1MRP6K3Lvp/WXn3LeIyCdE5Bsb7gMAAAAAsAEalZlp7SAqnuJ7fsfnpzbP/4yJuPo/WM5xuOn7iSJ208N4ZuqHZvmxq4qbyHnFTu8zgqGppDqW9LniOM7pMCpUh4rY3TuGczqEGsqncJNiN30/KxE71Vhm3IqT4Vz1RMGziV31PmKPXbnLLSt2+kRUxc773PzkbI5JH8OSdtmiGGMnZ/AUXwAAAAAAWsMNKgAAAAAgCtygAgAAAACi0PQhSWvMzNMO0mRtxuxZTUN34TGdTdrNipp+npxJGlhW7M4u12ad6PNUSk0/hzzws8vfWHUVsTu38dL+gNidrjgvVX3ulObSMH5OM/1cMF6qHZ/TfqepPh7Gy6lH0dJrm1isz53SXJo4xsv298s3qAAAAACAKHCDCgAAAACIAjeoAAAAAIAokIM6t3B+9TkVP4otrQJYKvsLfw79jvy3BcUwXhK7+iLocyLEbhEx1GQkbIshdisqlvHyfHa7bHyDCgAAAACIAjeoAAAAAIAoMMX3BU3Kj/hcNUeHtyfLwztPqHXD28+p9qWXfdZkuXfhmlrnnP77gffzH5XbpClSLcUujJuIyOjODdUe3r05Wb700teodd29K3q7YexqxE1kc2NX6yzlmWoOTeyGt58slu8+r9ZdftlrVbuq39HnpmhzvDy6WyybPjc6uqPal17yGard3blYNBgv59ModsWr09GhWjW6pWM3To9U+8L9r5osd7Z2zIb1+Sd2LzCxWnQGoXljOjpW7fGdZ1Q7c6PJ8u6Vl6l1SW/LbLw4/+Xjm37A5bCtbxzr/D6f8mbVLMXudtHvUknVut2rj6h2px/Gzva50o6nHtJ6x66lPneKPCvikx/f1euc/kzT27k6WXZJ9a2aPsbqA9axiztufIMKAAAAAIgCN6gAAAAAgChwgwoAAAAAiMJm56AumP/ms5FqZyOda5MFeVP5WOcEONH5V0t7KrWdOL9OeToNcqjy8UC1s+HBZDndv6XXjXWcxY2nbrfVsxv++9YpbtIsFyeMXRg3EZH04JZ5bRE7520fXJJ17nOyeOwykzOVDfdVexT0u3Sg+6dPTZ9rMyGoartrFLsmfS4b6mtbGsRubPpcOhyaN5vY5cG1zx5Sk9O91uPl4i8eHxexSo91jv7Y5OxnmX5vJ8h585fMQbQVuzZ/ByJUq98Frw1z8kVE0kPdz8YHN1U7C7pVp2M+0l+piF2jPmfaaxS7Jn0uHejx0vaz8aCIpfP6pHW39lS7t3W5aLT5VWJbvwNngG9QAQAAAABR4AYVAAAAABAFblABAAAAAFHY6BzUReu/2ft61+nrdrdo+1znnOamBqC4Ij8u8ung0Vg8blKqlei6QV2wrq7vZutU6U2ZOKJ9pb4SxM7EKuxzIiI++C3xJi/Nl2LXTl7jGqfl1BfErlSn0o6XQduLzi0u1aSTTNC24BznM/pGmOPmeua1x6ZtY5dPXbfhvSWwWN6iiIg3Ob/h+fY2N7GzrZou07lzEvYzk8PfVuzW7zegndjZMS7vdvRruzp2PngGine2hqd9bsb0OqgbrVa+cNGv8rHOu09TXRs6Kz23JMjt9ibOpoatD6+ha/yMhCp8gwoAAAAAiAI3qAAAAACAKGz0FN9agm/UXWKmiXo9BcMlLlg20zNSM0Uta2d6obV+02cWZP7hNh5J8Dj9pKtfnJi/36RB7Hy+rPpAmDDTWMLYdUwcs47pk1KszzPd52zs3Ob2jjPhEn2ZKccuGC9FryvFjvFyTu2cJ9fR03g7eTENLeuZ/jkycU3NlF81fXj1z/BS1ApbdZpJJ5xKn5jpv+Za51M9fua+KNPFtW5ODWIXpqR0Ojp9xTtd7s6bfufHRTvPdZkuVYOmRes3Xs7P58HnQDNNNxEzXpp7g/COKx/ba5uJczhebtIJDvANKgAAAAAgCtygAgAAAACiwA0qAAAAACAKG5WD6us8SroknARucthKuXLFfX+e6nnlWaof5+43dG75bPZx6Ytux8TGPp47zBc2JWhKj3vPikeK+9Kj9wnkRBCsZtlLFbEzeeC2nQe5cvlY5+WUYwcRKZc+aLKtMFYVucQnP5gs5qYsQp7a2NnH9kNEGsZOPWBBrzFlK8LYOfP3bZ+bPEdz7cvzoM1wObHw5xIbq8T0s2C7ickl9ua9earLZUiQZxde9+65WPNA57VamY3NPk/a2AXPwkj0djtdHbuheW+WF/FxqX5vbvIa18vivy/VsfOVzfBzoi0xaR63ID7VsRuNgnxh0+ecyfX24XgpOxXHu774BhUAAAAAEAVuUAEAAAAAUeAGFQAAAAAQhY3KQW2NzWMs5YIEeTo2N25o8nRMnb+2xJ29cY5KsQti1elWvtYPg9pwS4rbWpiert3eht30erb32sVrw7iJELuzEeZ2m35kaxF3i9jZcSsfmDzGbDn5w4yXJ+yJsPnDary0ucS6mZf6XXDtW610w0jZa5lphv2sY8dLW7vd1LAdFjVsfX5WOfsb9EtQCl1wvTI1vcV8Lumaa13qijzHfLyv1vnSeNnOOd6gSJ3yj53+3JLSmGjyhzvh82nMhrOxzkn1aRC7DR0v+QYVAAAAABAFblABAAAAAFHYqCm+dnbnskqXuKT4Wt/uIst0mZk8a6dsQnkWwqrPAbDH3+pc0WIvwXlKkp5dqZppXsSuPHVm8TkY6x27FuMWbtb2uVIZhWJ95k2pkhaniaqjWPW4tTdA2g2b3diUiF7YUNNRNoMAACAASURBVOuy/Fi1/bidsgnr1+faMqssVzDF1+kSC+JN7LJD3R6FsWO8bF3F9GxnUyCcudaZcKTDg8lyPhqY1+ZmP2Za47yHGE3cwn/8WR3T9P3Y8TExU3ydM+1gW+lY97nUxK4fxM4tGrd7b577vatnxr9NVeWypZ3MVHrzucSFt1y5map99LxqZ6Milj25Vu8Yq165QrHjG1QAAAAAQBS4QQUAAAAARIEbVAAAAABAFDYqB3V57KOmi3nn9vHtpUfv5y2VvFidaeULaS+rsaJEUNfmoOq4hvlvPm8nd/i0Q1on7WYSVz3e3eR6BPk1PrV9rsWyCWscu9aU8hhN7IJ+V3pMv4ld3la/I27zMf0sjF3SM7lwJnY+1bHKsyIfzqY310qLInZTTM/1tp9DXF/HrlTaJBgjs8zk8FfudRVF8C8I8xrt50lblmvL5H53gjebZ5pkY/3Mk4VFcIpKzu0X0U1ZPqWf2fJOW8G1bmTeKzZ24Xip/7GbMl7yDSoAAAAAIArcoAIAAAAAosANKgAAAAAgChuWg2pzNIJ53WY+e61cuVJaYzDv3OTGpaM7ej8qZ6DJZPEVnmg+j7Cmm5mP3yivUdVBtTlVOnbjo7uT5XQ0XHyXc/xkbdh6pW3FzmzXxk6C2nGj47tqVdYgdqccSIvbikupBmYQuyZ9zomNXVA32tT4Gx0fqHY60DlVPjiSepFYs7jZfhacl9bK2YrOa0w6W2qdN3UVxwNdk3GsYtnsN2idLKlqdGW9xqSzbV6qY5cO94vlQx3HRke5QjUYZ1nW8xVKa0zOfqe7ZV5RjJnZWNeNTo/3VduHdVBl/jqoUfa5GH6X7LMwvH6mTGJyUDvdoN/l+jcmHelr2zj43OJN7eGVj92c+AYVAAAAABAFblABAAAAAFHgBhUAAAAAEIUNy0G13KmLInVz5Uz+T5D/1u3omlVZqreUZ2Gdv/kLO5XywzZJKd/KqJUrF+S2JjrntNvVeTp5EDufNqgvRuyKpiyaB277nI1dkafjxzp/I89s7ObPHqLfnSyac1Yrz9Hk7STBGNnr6T7nUxO7sc5JVTueEZrNil1FrBptNqit2dXXtl7fjJdjc60Ln79gcqqkIqdq7ePWVr8qbzjYhf6o17Gx2zL9blyMp1mqn5tRjl3FEaxz6M7o+QrOPF8hMZ9L+ju7k+XDXMc1HernL4jKkTR130uHsb7Bq3i8QjMmXzgx5zgJrm+9IG4iIoNct9OjW8Xxmfq29tk2oXWKG9+gAgAAAACiwA0qAAAAACAKGz7Ft0LF9I1ZswHUo/i3dtS60Vg/9jsfhtMNq7+aX58v7pdswZI0pce529jlReyykZk6U7XduV+5icJp9ovXeirFrl/EbpTrKb3ZQPfByqn08x/ChqmYqi31preFZbk6W3qaU+ZN2YShnm5oS9ZMP8INVjWtXkQqZtlXbzYxJRT6e3qzmS7nlB4GY+aMHW1u7CpK4UmDqYj2d8BMEez0db/Ls6K0TGqHy8xM8Q1+DTaqhJq1rFJPNiWia9JZekXs8rEuCZQepHpbYcrERn/6n97P2ppWLyLlKb/B1Ppu/4Ja51P9mXJ0t5iO7Ydmiq+eyW3MnyoYO75BBQAAAABEgRtUAAAAAEAUuEEFAAAAAERho2eh1xLmF8yapB7kDPS2dF5O/0jPB8/HQZkZm4NXmju+unPJz02d54mbXI/uto7dzrDoLtnRwLy5Mru1Yh0KNi9Er/WVsdMv7u0U+R1bI50rlx7pvMaGhTcg0ihnX5LivWHcRES2Ml1SYbSvY+elyKlyFaVKELLj0WK//zbv28Zuu6fHz+M7RTKjF50b52aUvNhcFWNig7ImNnbdnUuqvbVdxPLotnluhtf5cB0p+uj6ZL+1q50ed7Itk/vd3S1it72r43hw+znVzvLic0siOu94sy2pLJeJfBKWoLR97vJ11b795GOT5TTV5dW6ot+r97M+vY5vUAEAAAAAUeAGFQAAAAAQBW5QAQAAAABRIAd1AW5GXmPY6mzref7D3ki1wxyBa7Pmjq/P1PJzUxU7m2vQNfnD+W6R+7H//NNq3f1VwSFurQhjV85H1Se5E8TO7+i/w+3feka1H6iMHcFbSFiL2Kyqil3X1EF1F3X76PknFzoGVKiIlR0Vdehsn9Ox6l4xOVWP/X6xnczUZ7SfRIjdbKW6m0ZVHviM5y10L90/WT564n1qXTbWeeCdrYvTj2GjuVMXT2lqs3KLK2LXv/wStW7wxHtVOxsUuYy93WvzH9MmmdWvqtSInb032LqoY5eOfneyPLyjP29uX9WvXVd8gwoAAAAAiAI3qAAAAACAKDDFtw0VzxB3iX58fr+vp9L4gxtLOijMpap8kHmc+/beiyfLw+c/qV/L8/XP1KzqQS4phrb+zn1q3fj2U+bNduMNDw6VKmNn+tzWpQdV++iJj+g3Z8Gb+XPrEtgyJ8G00VK/0QHoX9Wxy/Z/c7Kcj3SqS2fL7jfcOB1yIeHU7ZrTRreuFte6fP+WWpcd3NHvvfCihQ8Rp6go2SVSHbut6w/o15qSauM7z0+Wt6+9bPFjxOnsVG4TLN00Zbqu6s8pkhWfYY6f/qhadfmRz6vc77rgkg4AAAAAiAI3qAAAAACAKHCDCgAAAACIAjmorZiehOpMTlV/57JqH+1/qniXzaNb03nlq0MHYPu+hybLdz72u2qdl9y8k7/9nKug8+wEcRMRObzxh6qdm9glxO4c6T63++Ajqv3kf9D5cGle5DL2pK83xYB6rnbu1/1ueDCeLA8Ob6p1vYu6JE0YOsLWgornZJxm63qRVzo+1P3q1o1PqPbOi181dbOErgU1YrdlSjvlx/qZJ89+9AOT5Yuv+Fyz2QblVXCiVhKq0tu9qNs7xfj5zIc+rNY98Dqdw+/CJP41uu7xSQwAAAAAEAVuUAEAAAAAUWh0g+qc+x7n3B875/7IOfeLzrlt59wrnHPvcs496pz7Jedcf/aWAAAAAACbbuEcVOfcQyLynSLymd77Y+fcL4vIN4nIV4rIP/Tev9059zMi8i0i8tOtHG20qhI69Lo9U3vq7vs/OFl2ZHBEbefqSyfLg4GuLyZZptsJ6d2x2A3iJiIyODrSL8hS3Q5jR5c8V1t7uq5fqV+NDoIXX1CrCN356m5dUe2dq/dPlrPjR82rXyVTEcgz1+1dmixffOhhtW54+G794vxLiuXEfOdB7JqbkS8cSro65/Tyy1+h2odHv1c00m/Ub+6asZVE8OZqxM6ZYtDXXvHqyfIzn/gttS47OlTt7sXivevU5ZpO8e2KyI5zrisiuyJyQ0S+RER+5WT920TkaxruAwAAAACwARa+QfXePyEif19EPin3bkzviMh7ROS29/6FryQeF5GHTnu/c+6Nzrl3O+fefdp6AAAAAMBmaTLF96qIvF5EXiEit0XkfxORL5/3/d77t4jIW062VeOL8PPnzWOc7XTP3V09zSL0mS97tWp/+/f9zGT5C3cvqXWDoZ6KuL2zM1k+OtRf8TumYCwkjGW3o7tD7nX5kSu7u5Plv/33/i+17qte/Bmq/fSt4lH8zvwZKB2NVTvp6FJEmCKIlR0wumZ6Up4Xsbt+QT++/W/9D7+m2n/hJa9R7adufnyynJh+NR7px7sTu/rsU/AvXSxKbx0c7qt12z0d1zf/jber9nf8x982Wf4PH9Z90pv+e+vZZyfLl69d0wfB+DmXMHY/8aM/qtZ9/w/9kGoniT6n3/7NP1Ks+3VdNuF//tWvU+3xaDBZ/qt/6zvUun/yd/6xanPtm832uadvPKHaDz2s0yDCkiNf9cVfq9Z90Z/6r1T7735l0ZcOD+6qdQ+8Rm/3yfcF10XiNhd7rRsOB6p9ca9IbcjMmPenXvuFqv0N/8UPTpa/+K/oqdu3bj+j2jvXiuvmwbN31Lpy6IjlqeyJCjriaz7tlWrVBz+uyzddv16kt3zfN/0dte7bfvLr9Xs/9DvFLsw0+48+9jHVftlDxXeGsffBJlN8/7yIfMx7/6z3fiwi/1JEvkhErpxM+RUReVhEnpi2AQAAAAAAXtDkBvWTIvKnnXO77t5t+JeKyPtF5J0i8sLt/RtE5B3NDhEAAAAAsAma5KC+S+49DOm9IvK+k229RUTeJCLf65x7VESui8jPtXCcAAAAAIA116gWhvf+R0TkR8yPHxORL2iy3VXjasy/3z8YqvZ9R0XO1Z7TpUp0poFI84cuo4qf8Uzw0biIz4Wbz6l1l7s6J/jpcFvexC3yef/RCs+bSaqqit1wrMvIXLj1vGpf7ujYPaV3ag9ixkGirsyPp65LMx3X/NbTqn2lX/RDLzr/qkQlgxPHpnZ8df61fVbDjVtFts+r79PXOi9j0w6Wn5n++4HF7HR1SYvS6BnE7lO39LUu6es8ceeLzzSl7dzK7E9Qkx2puonudz68LJoh8Ok7OndUtovnmnS9fsaJzVN2w6rPQ4yfTeVi+4Z9tk0x7j3ubqt1PdG53nnwS5DkejvbtvTTClndIwcAAAAArBVuUAEAAAAAUeAGFQAAAAAQBWfzRM7lICrqoMZwfJY9puGxzhbd2duVZehvFXkjg2Nde/W86hlV7TfG2FnhMXY6iVm3nH3muc49cLZQ6hmY9fsSe+zs8XVMPdLWjt+cpzxLzeq4Yhd73ETKx3jhYjFeHh2WM+/bsn9U5GNd2Na1cc8qL3ydYvcP/tFPqHU/8D3fv5R9vvHb/qpq/8zP/k+qfVbXvlWOnT2+5569qdoveuC+pez3/ksPqPbTt29MlmOIm8jqxW400DnZO3vbU1/bxE63GJcPRwdqXQyxiz1uInLKszIKn/bqR9S6j33kU0s5hEc/8VHVfuVLXzFZXmYcZ2z7Pd77183aBt+gAgAAAACiwA0qAAAAACAK3KACAAAAAKLQqA4q7rFlLpe2n3PId9skZ5fRQA2xts2qYYt4ZdnZ9IckK8ZP+9tCj6yvv382Hx/SEbU029Y/o+Fy2BnOfhFqsWUtl5WKOU6oP9yYzcMMgnV0vJxn1VjJKJ39okhxxwMAAAAAiAI3qAAAAACAKFBmBo2s/GPAN9SqP3p/k9HnVhexW13Ebh6zzsPZT6bnWjcnex7c1MaZoc/NKTwXpVMWX+yEMjMAAAAAgFXCDSoAAAAAIArcoAIAAAAAokCZGQAAADREwaaVNSNXFxFb09jxDSoAAAAAIArcoAIAAAAAosANKgAAAAAgCtygAgAAAACiwA0qAAAAACAK3KACAAAAAKLADSoAAAAAIArcoAIAAAAAosANKgAAAAAgCtygAgAAAACi0D3vAwAQHy9+suzEneORoI4wbiLEbpV4b2LniN2qIHYn/Iz1Z3VaZh1H+NIgdhsbN5HqcxZ53EQ2LHZ+erN0FiKM3bz4BhUAAAAAEAVuUAEAAAAAUeAGFQAAAAAQhehzUDdqXvmaIXarK3H87WoVEbfVlSTEblURu9VF7FYTcVt/RBgAAAAAEAVuUAEAAAAAUeAGFQAAAAAQBW5QAQAAAABR4AYVAAAAABAFblABAAAAAFGIvsyMz3P9g1ZLl/hTF2e8MkqlszL7BwvSZ8JVlLVYXuz0MfjYg9NAq6V6ghPlZjyiXcVuWX1OiN1czEmqih3j5Xw2ebyc0Vw56iwtabwUOa9+N3+wViGObmrj1B8srsa1DkCc6LkAAAAAgChwgwoAAAAAiAI3qAAAAACAKESfg9puDlVp46cunvrKIKchhlyP8mlZ5nlacD9Li53ebmk3kcXKmn1alnTe6sTjXGIXf35q9WlZ57iJrPJ4KWJPzeaOl+Xm9NziGGJ3bte6KPpddezUKjNgEjsAq4xvUAEAAAAAUeAGFQAAAAAQhfin+GKCSSv1lWb/nstRGPYgmI50jzkvxA5NEJl5hWcqil6GFUWfA9AWvkEFAAAAAESBG1QAAAAAQBS4QQUAAAAARGGzc1DbKoVgHu+eZ+PJcnp4W63LfKraWxfumywn3Z7ZsM7o8FMb5R+cXxma5fNN6o/YMgo+nyyn42O1bnz3pmrnrnjtzqUH1Lqk15+6H5ck01a9cBBTD9etWY5jo9jpDalmlg5Ve7xfxC53+rXbF+9T7aRjYhdyFX3wlOPQb12v2C1rvAxjl+7r8TJPMtXeunC/aqsx0/Zte/4rBlDGy7k3NlkMr3MiIunhHdXOxMRu7/pkOenajx7Tz3f58E3sVGN94ibScuwCea4/h+THh7odXOt62xfVOpd0zNaKcz4jVOoH69znADTHN6gAAAAAgChwgwoAAAAAiAI3qAAAAACAKGx0Dmqt7I4gF2R8fKBWjQ/vqvbo6Lmikeu8im5/S29299r0A2qSktHmtlZOkCuX5WrN8Z3nVXt4UOQqZiMdR3E6J7jX3ykaF/R2baKUC//2Y/OI1ixPamlyfY6HR/uT5bHJ7R4d67bPi3PeD+MmIn73umpLZ6M7y9xqjZdB7IYHOjdxfKRjlQ6Ktrd9rrett7trE03rHFQFfgXuMWPV2OQmjoM80+GRHktdpt/b3d7V2965GuzH7HdTz3ebSrE7KpYPbql1w2Mdu05i+t3Ohclyt7+n1pVzUBfE7wCACnyDCgAAAACIAjeoAAAAAIAocIMKAAAAAIjCZuWg1qkplusabtloMFkej3ReTup1DUbxxX2/t/XGxOYuhusr6jGKSJ0kjbVL76iMnV7n0+KcpkMTq2yg2nkSvNfr8++8jpXPi7p/to5cYmMX1t50G/x3oJl9LswXtn1O16VNg36Xiz3/eijLfRAr0+e8H5u2zr9au/qli6oxXtpxLhwv00zHMXM6ziLF+Xcm79ibOHtTRzp8b5NRbqPHy+Cc56bPjYY6Lz/Li7g6b2sEm3rgdvxUsbM1v63FrnXrHTeRyvHSXOuGx0W+cGb6oMv1NSn3ZlvBtc6bz0LizcdGN7VRae36HIBWbfAnZwAAAABATLhBBQAAAABEYaOm+FZOnjFTa+wUznC6UseUQvDOPHa9U9z3Z3aak5liGpZBYcrLdJWxM7Omw9jlJq6djpmKm4wmi1nfxDy3U+GCqU522lNltJpEdgV/K4JzPnOSaBA72+e86TtJUArBu5F+bdecl6AZTs2+1za/MNYKnOKzUGe8tNMAw9h1Ejv9Xccu7xXjZ26n+NrYZXYKcLDZjY6br2hVvlR8FoyXJo6J2GtdkM7S0X/fTu107FynvnCtm2bB8TLT/ShLTdpDMBU39+a7CDNelsbedBiunHVUANA6vkEFAAAAAESBG1QAAAAAQBS4QQUAAAAARGEFclAXz1bxsx7Zrtbr1zqTV9rpBnlUJiejk+rTOHLhS01uVqb3k2VFrkdXLlQfbyPn8TD+JcWutM7kKnaKeHT7O/oI7FuDXJvR2JTDGOt84W6Qe5yZ/J9yR3JTlms6t2StxX9fqvPfbA5h8eoksbncOncx6QQ5bKZ0z9BsNw9j5/R28lTnxjm3pH5nf0/PJElyieOlVIyXie4BnV6xX1uOREzfGQf9Lhvr2CQm3z83eY1d2as84sWt2nhZtdKWNrPXuqIvJV3dVzo25ze41ukolvuVZDp2WfD8hbOJm8iqx87m4YexLH1GMdc6xfS5QWbzg3Wudx58d5Gb13akYj+NkJkMoMA3qAAAAACAKMy8QXXO/bxz7hnn3B8FP7vmnPtN59xHTv5/9eTnzjn3U865R51zf+ic+/xlHjwAAAAAYH3M8w3qPxORLzc/e7OI/Jb3/lUi8lsnbRGRrxCRV53890YR+el2DhMAAAAAsO5m5qB673/HOfdy8+PXi8ifPVl+m4j8toi86eTn/4u/l8z0751zV5xzD3rvb7R1wO2anmfkEpP/ENQRc11z2ro616YT1GvMzd8AbJ6OT3Xux//f3t3HyHWVdxz/PTO7M2t7Hb+CCbZJDDJtA0IhTVGUVghEWwJUDVUrFFSVlBeFSkZqRUsL9AVQJRS1gkqtCpLbJqEVL43apOSP0AZRWlrRQJwohTg0jkMS4veY+H29O2+nf+xk73nO7Lzu7M7d2e9HinLPnDtzz85zz7lzPeeZ4w2eg9H6zBHkcyxbSkm33L4oVoUk3yqJnUU5VxNFX9dIukc9il1I1pxrMay/dURpOHFe1HKmTlr04qGlD/ocq0IUu3ra5yyJXbwGYN3nFsfrPjYPnDSqY5N7N84pVMlJ0fKnWjxe+jimfbBYjMdLv29I8sC79ruhWfngrVjKcvrC0bXOkutV63iZxaqY5EDWw2iudcvzOv1ZrthZmoMav3DBv9+FdC3cKFYt42XVx66W5Ik3qn1c6wZ8z3PxGQVAbg2ag7ojuuk8IWlHc3unpOei/Y40H2thZreZ2QEzOzBgGwAAAAAAY2TJv+IbQghmLb+N2svz9kvaL0mDPB8AAAAAMF4GvUE9+eLUXTO7UtKp5uNHJe2O9tvVfGxwy/nL453m4STTlRRNFbWQTD0s+J/mt2iaWkiWpKnPXnLl2tyltvtaMW1fH398DmbLLFvo0rh1ml6VLEdSSKbxFqKlTCz4ulD3SwTVZi4ubFcrF11dOY1dfNw+//AukydXtw6xM2vf5ySpEC1lkva5QjIZJETLY9Rn/BTfuM9JrUs5WBgsduM/Za33vyeeup1O1bZ0vIzG07TP1S+3Hy8lqRT1u/Q4fcVu3EIV6zJeuunYyb8Vdxwv0+nYjWQJtct+jKzOZuWW8TJNqekjIOMVu/Ri1mmSWzIdO9nVotgVJqZ8nWb8zknsalHsqrPnXd3k9NbkuFEA+gnGWMUNwLANOsX3Pkm3NrdvlfTV6PH3NH/N9wZJ5/KbfwoAAAAAyJOu36Ca2Zc1/4NI283siKRPSLpd0t1m9n5Jz0p6V3P3+yW9XdJhSTOS3rsMbQYAAAAAjKFefsX33W2q3rLIvkHSvqU2CgAAAACw9iz5R5KW23KmoHZ8tSQXxxTnVKU/vZ/kpJayeptNl7/wP9ler2T5cUHtj9nN+Oe/xdJ8pQ67JrlNaZ5pYTLK0yknuXKzSU5bI8uPqyfLX7TmDnVoUzfjHLqUtS20xi7OqZpM+mDZL6MQxy4o6XPVZPmLZI2IgXPachC3FVuqJNW6zky02XmZGdfvZn0cW8bLWrJkUNTvlpb+loPgrZSW4TNa6ilZuiQdL+PYFcpJHOd8udZI8onja90S+tx4x673a1ta1bpMV5yDmva5JK5V3+/qiq91SZ8bWuzGKW4Ahm3QHFQAAAAAAIaKG1QAAAAAQC5wgwoAAAAAyIXc56CObo2z9MDRWnHyuTWFJFeuMJGtFRevxyhJ9UrFlSsz57J9Gz7fSkWfF9JRDheDy0PsLP03mCS3uFjM8t+KyVpxSmJXi9awrVz0a8M1knyrgnqPXev7NPpYLl/s+smrTte1zPpHoejrihNlVw61bN/anF/zrzJzwZWHF7s8xG3wNrTmtC3l2ZlC2qYkz7FejGKXrhs95/Pf0n4X4tgxXrZ75S71UR5vlxzIYjGLXSHpc2nsGjV/ratePh/tWnV1hX4+iqz62PXTs/p54WTNb8viEYrtP6NIUqj7zx6hlsWnlqxnG5LY9fUxMoexA5BPfIMKAAAAAMgFblABAAAAALmQ+ym+S5k2t7Qpa+mLxcvMJFNpkqlOxcls2tnE1Hrfhpqfhladzab4plOiipPr2jenS3PzIQexS6YUWTI1tKAsdhMlH6vShg2uPHMymxZVnT3r21dLpj2V+oldHqM5nNgNq89JkhXi6di+z01MJrFbn5VnT6d9Lo2d73cqJVO9Ozeyj31zbpgDZhw7S5YuSaYXFqO+Ulrn43g5GS9rc2d8E+tRv5vsHLf8RyoH07Nb+pzfM77WpX1uMo1dw3+8mLuU9btGstSTkrG3TetyrJ9WDqmjpbFKX9aiZWbk+8bEpJ+OPbnOX+vmzmSxqlzyfS5dpqu46mMHII/4BhUAAAAAkAvcoAIAAAAAcoEbVAAAAABALqyCHNQlSHM0gs/1GDyvsdCpqMJEljdVSnIRQ/WcK1fPRT8FfznJy1mXttAW3RxLaeyiaIWlJTb6UpTXWJj0uXETEz63plHNlkmoXUjOpbkkB3V9XN956YaxE+drD6vPSa6jtfS5NHZRflyj6pdJqJz1Syo0ZpMc1A6xG+9VEtK/NYnd4AOmLxWSPPAoJzXNaww1P17WzvklgVy/m+owXi5SHCvpibm0QTJ63fbXuuKkzwOfLE3759b88k612dmF7cbMrN93w9q91sVL+4SlJX4nxaycLstVSGNX9jmoqmdjZjVZpqtx6ZLfd8PmDm1o31oA6IRvUAEAAAAAucANKgAAAAAgF7hBBQAAAADkwnjnoKaGujBq/LrpuqhRTpXLz5DKV2x35TMnn17YrlQuuLpSeElynLaFNWBoq2smL5vFLs4dlqTS9CZXntqYlc+ePu7qqnWf51gKW6NjJMfskio3Vlasz6Wx2xxtX+Hqzj5/xJWrVd/vymFbdJzkuGspdmnuaJwHPsTXLRSz2E1s8H2ufMU2Vz574mlXrtayfjepLX0dd5wt02jZcbycTGO32V/rXjjyxML2XLIW8VTYkRwn+gvGvc/F6bbJ3zq02CXjZXHCf/QL69PYZZ89zh496OpmZ15w5anw8ug4aS502o4e2goA4htUAAAAAEBOcIMKAAAAAMgFblABAAAAALmwtnJQl7SmYe/rcBaK2dta2uDz30obX+bK9R99Z2H78pljrm76ZXuSVyaBQ5Ksr8D1vpZjnAsnSaU0pyqK3dxzj7i62Qs+L2fD9le0P9B4L6aZGE6fk/qL3WTU70obXurqKj/6X1eevehjN73j6vYHWkuhS8Xr2/bzvC5r4cbrok6u2+jqpq640pWrz3zblefOnVrYXr9tdz+tGm+DxqqPPmdF//Fhcn0Su2l/rWvUHlzYvvT8j1zdpl17k1eP/u18LfW5lvW/O+n8QcTHLnnddLxs6XdZ7Oy5ye2U1AAADdRJREFUA67u4qmnXHnTVT8VHSX5zmMtxQ7AUPENKgAAAAAgF7hBBQAAAADkwhqb4rsU8ZSpzlPW/NOKrji13S+boFBe2Jw5+ayv+okb/UvxzwkDaL9UhtQldgXfPcrbs5/eb8z5XWef99OzdfW17ZqAng2+zIlFsStv832uXqu78uVk2RntuS7bbulzBLNv/Sw1lAxypW1+qZJQ8X3y8olszNyy56c7Hxc9WMJ4mVzrytu2JvXZNNILx550VY3XvdmV3dDLUiVtdH4j+loWKu13m7PYWckvd3fp2GFXblSrC9vFkp86TOwADIpbHgAAAABALnCDCgAAAADIBW5QAQAAAAC5QA7qINK1MrqtOxMpT2925cnpnQvbp5962tXtvvGyP2xpOjqkP2Z/S6+sYUuI3dSmLC+nXPb5VScPP+HKL7/+F6JDlpJDErvll72n6zb5WJXX73DlE0/6ZRN2XV/JXqUw5eqI3SAGz2ssbfDjZWm9XzLo5KGs3115Q9XVpf3O9XXi1psljJeT6/wSa+uvyJYBOv3ko66uUT3vyoWJLPeYNMYBxbHrI26SNFHesLC9Yatf7u7SMz5/uDZzcmG7WPL7EjsAg+IbVAAAAABALnCDCgAAAADIBW5QAQAAAAC5QA7qEPS1zN/EOld+ydWvXth+/vA3XV3l7AuuPPXSabWV5piQY9VGf7k4seJk9v5v2fUqV/fUY1915fqlmYXtiY1JLlxLk4hdT+K3pY8wFkq+32x9uc+T+uGJe125dinL/Z7c5HNQW5DXuKwKE/7937rnJ135+WN3LmzXL150dRNX+Nzj+JQhUsvPJsquvO3qbMw8dugBVzd76nlXnr4qXru4Sx4s/a6rfj6jSJIVs/VMN+26ytUdO1hz5QtHsrWIy5v8vi2LtzNeAugR36ACAAAAAHKBG1QAAAAAQC5YumzCSBph1rYReWhfd8myCVHxjW/4GVf37UceceVt21+2sP3Bd37E1f3nwe+48ncfumdhu5a8Lw988z9c+c033ujKy7UcRqfXXQ2xi9vYaDRc3Y7tW1z5zPlsCuGr977W1X3gV//Ele/8l88sbB869JCrK0z5Kb9nTp125ampbBr4KOIm5T92afvS2F21M+tXx0/7qfKvjKbVS9L7bv6oK//D/Z9b2H7qKd9fi+v8lNOTR44ubE9Pb3R19Ll22o+XO1+63dWd+PEZV96dTK3/8K9/emH7rq/td3WPHfx3f9hC9u+xx44fd1Xbt2xzZWLXTtbGtLl/sO/DrvzZ/X/lylu2Zcs7vfcdH3B13z961JX/67+/tLA9W/HLB33kk5925U9//PcWtlvf3uHFcfXHLpO29/GH/dIxr78xu76Vpta7unfc+POuvPkV2Wece+75M1f3wpmzrnzlK/cubD936AeurjV0w4kdS4EBufNwCOH6bjvxDSoAAAAAIBe4QQUAAAAA5AI3qAAAAACAXGCZmaHo8CPu1kiqfO7H7OUsv+Zow+dbTQZfrkcvlWbtblzC8imYV0hzVdK3NIrd+Qtzrmp23Ywrl3RuYbuevM5EPT1usa92olVL7GJJn7twqeLK50uXXHlC5xe209hNJg8Uid0A2o+XjZZcPl++ODPrymfKWV54Ol42Gv448b/GlkTcBtN+rae6+TFQ8te+uZlszHx6xi8rU6z7JYJqUT+z5JxY3zin9sg3HERt0l/PFLKLVL3il5U5dNrnb1+3OYv77GxycUsvopUOsSNXFECEb1ABAAAAALnADSoAAAAAIBe4QQUAAAAA5AI5qMPQYQ20i8HnbzSSXS9cyNbAvPNv/3TgJsxO8m8NS5Uspam5JIcqjt2xY4dc3R/98a09H6cy69f1a4Q0bwf9SmM3E72njaTTnTzxQ1e+/fZ9PR8nTbGq1LN81nVaL/QgHS+jYq3YedcXfnzElT/1qff1ftgoJ7Uq+txAOlzrQtGv71xP8rUvXPzxwvY//ePnB25CRZMDPxeLW6+yK8c5wNWaz9F/9OFvdyx3MlXYMEDrAKxF3NUAAAAAAHKBG1QAAAAAQC4wxXcIQsvyJNn0mNnK9Iq0oVytdN8JHaVhrNWWp3s0LJleGBqL74ieWfJPbbVKafEdl6hR8LGzdG4xumoZL6M5vpVqWcslRMexeq3DnmjHxS6Z7luxjX7nDquvLUW5QuyGrVj241qIx1NmwwMYAb5BBQAAAADkAjeoAAAAAIBc4AYVAAAAAJALFjr8bPyKNcKsbSPy0L7lFRbdlNSaFBm/F2l+T+sDK8Ja8sky4xe7Dn9Pp9il70MOYtcpbtK4xa7L39ISux7rFn9g2a2tPpfq9Pd1GC9bqhkvl9+A46XEtS5X2i8LJWnVX+sArLiHQwjXd9uJb1ABAAAAALnADSoAAAAAIBe4QQUAAAAA5ALroI6cLbq5+K7kUoxWh/e/pSp/OVRrV5f3m9itIn28/4yXIzbgeNlSTxxHyzoWO9cROwCD4RtUAAAAAEAucIMKAAAAAMgFblABAAAAALlADiqwLMi9Wb2IHbCy6HPjgTgCGA6+QQUAAAAA5AI3qAAAAACAXOAGFQAAAACQC9ygAgAAAABygRtUAAAAAEAucIMKAAAAAMiF3C8zE0JwZWv5FfMx/lnz5G+PS5b+3enbENS5fuA29bFrGru4LglkLqMY2hfT87Dj39rtOOl7ET0hdAlzJy2nQOg9eOnf06kVrX1ySNL3PzqOdTu/w6KbbXbt46ROuTb5V15S7FyTBo+bLVtwcqilv6Z9Mg7WCrRnvhG979qtf0axHFXzzV+EOu7c8txo/07j5WLP7bRz3O+G1+e6tiJ5bod9x+xa12nnfq516Rg+qmsdgHziG1QAAAAAQC50vUE1szvM7JSZPRY99udm9n9m9j0zu9fMNkd1HzOzw2b2hJm9dbkaDgAAAAAYL718g3qXpJuSx74u6bUhhNdJOiTpY5JkZtdIukXSa5rP+ZyZFYfWWgAAAADA2OqagxpC+JaZXZ089kBUfFDSrzW3b5b0lRDCnKSnzeywpDdI+p9BG1goMAt5tSJ2qxexW52I2+pF7FYvYgcAwzWMUfV9kr7W3N4p6bmo7kjzsRZmdpuZHTCzA0NoAwAAAABglVvSr/ia2R9Kqkn6Yr/PDSHsl7S/+Tr85BoAAAAArHED36Ca2W9K+iVJbwnZb6wflbQ72m1X8zEAAAAAADoaaIqvmd0k6fcl/XIIYSaquk/SLWZWNrM9kvZK+u7SmwkAAAAAGHddv0E1sy9LepOk7WZ2RNInNP+rvWVJX28uBP9gCOG3QggHzexuSY9rfurvvhBCfbkaDwAAAAAYH5bNzh1hI8hBBQAAAIBx9nAI4fpuOy3pR5KG6LSkZyVtb24D44pzHOOM8xvjjPMb445zHMvtql52ysU3qC8yswO93FUDqxXnOMYZ5zfGGec3xh3nOPKC1aUBAAAAALnADSoAAAAAIBfydoO6f9QNAJYZ5zjGGec3xhnnN8Yd5zhyIVc5qAAAAACAtStv36ACAAAAANYoblABAAAAALmQmxtUM7vJzJ4ws8Nm9tFRtwdYKjN7xsy+b2aPmtmB5mNbzezrZvZk8/9bRt1OoFdmdoeZnTKzx6LHFj2nbd5fNsf075nZdaNrOdBdm/P7k2Z2tDmOP2pmb4/qPtY8v58ws7eOptVAb8xst5l908weN7ODZvbbzccZw5E7ubhBNbOipL+W9DZJ10h6t5ldM9pWAUPx5hDCtdG6Yh+V9I0Qwl5J32iWgdXiLkk3JY+1O6ffJmlv87/bJH1+hdoIDOoutZ7fkvQXzXH82hDC/ZLU/Ixyi6TXNJ/zueZnGSCvapJ+N4RwjaQbJO1rnseM4cidXNygSnqDpMMhhB+GECqSviLp5hG3CVgON0v6QnP7C5LeOcK2AH0JIXxL0gvJw+3O6Zsl/X2Y96CkzWZ25cq0FOhfm/O7nZslfSWEMBdCeFrSYc1/lgFyKYRwPITwSHP7gqQfSNopxnDkUF5uUHdKei4qH2k+BqxmQdIDZvawmd3WfGxHCOF4c/uEpB2jaRowNO3OacZ1jIsPNac43hGlZXB+Y9Uys6slvV7Sd8QYjhzKyw0qMI5+LoRwneanyewzszfGlWF+jSfWecLY4JzGGPq8pFdJulbScUmfGW1zgKUxs2lJ/yzpd0II5+M6xnDkRV5uUI9K2h2VdzUfA1atEMLR5v9PSbpX89O/Tr44Rab5/1OjayEwFO3OacZ1rHohhJMhhHoIoSHpb5RN4+X8xqpjZpOavzn9YgjhnubDjOHInbzcoD4kaa+Z7TGzkuZ/eOC+EbcJGJiZbTCzjS9uS/pFSY9p/ry+tbnbrZK+OpoWAkPT7py+T9J7mr8EeYOkc9E0MmBVSHLufkXz47g0f37fYmZlM9uj+R+S+e5Ktw/olZmZpL+T9IMQwmejKsZw5M7EqBsgSSGEmpl9SNK/SSpKuiOEcHDEzQKWYoeke+evB5qQ9KUQwr+a2UOS7jaz90t6VtK7RthGoC9m9mVJb5K03cyOSPqEpNu1+Dl9v6S3a/7HY2YkvXfFGwz0oc35/SYzu1bz0x6fkfRBSQohHDSzuyU9rvlfR90XQqiPot1Aj35W0m9I+r6ZPdp87ONiDEcO2fx0cwAAAAAARisvU3wBAAAAAGscN6gAAAAAgFzgBhUAAAAAkAvcoAIAAAAAcoEbVAAAAABALnCDCgAAAADIBW5QAQAAAAC58P9oQVhTBI4olAAAAABJRU5ErkJggg==\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -3464,19 +3691,26 @@ } ], "source": [ - "imshow(sample[0].cpu().detach())" + "imshow(postprocess(sample[0].cpu().detach()))" ] }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 14, "metadata": { "scrolled": false }, "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "torch.Size([30, 3, 28, 28])\n" + ] + }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -3522,9 +3756,16 @@ } ], "source": [ - "imshow(_data[\"episode_frames\"][0])\n", + "imshow(postprocess(_data[\"episode_frames\"][0]))\n", "print(_data[\"actions\"][0])" ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { diff --git a/tutorial/English/utils.py b/tutorial/English/utils.py index 1fe8fbb7..619971bd 100644 --- a/tutorial/English/utils.py +++ b/tutorial/English/utils.py @@ -23,21 +23,65 @@ def __init__(self, pickle_path="cartpole_28.pickle"): # episode_frames: np.array([episode_num, one_episode_length, height, width, Channels]) (10000, 30, 28, 28, 3) # actions: np.array([episode_num, one_episode_length]) (10000, 30) # HWC → CHW - episode_frames = episode_frames.transpose(0, 1, 4, 2, 3) + episode_frames = episode_frames.transpose(0, 1, 4, 2, 3) / 1.0 + # print(episode_frames.dtype) actions = actions[:, :, np.newaxis] self.episode_frames = torch.from_numpy(episode_frames.astype(np.float32)) self.actions = torch.from_numpy(actions.astype(np.float32)) + + self.mean = torch.zeros_like(self.episode_frames[0]) + self.std = torch.zeros_like(self.episode_frames[0]) + + self.mean[:, 0, :, :] = 182.6091 + self.mean[:, 1, :, :] = 182.6091 + self.mean[:, 2, :, :] = 182.6091 + + self.std[:, 0, :, :] = 45.5565 + self.std[:, 1, :, :] = 47.6260 + self.std[:, 2, :, :] = 50.7284 def __len__(self): return len(self.episode_frames) def __getitem__(self, idx): return { - "episode_frames": self.episode_frames[idx] / 255, + "episode_frames": (self.episode_frames[idx] - self.mean) / self.std, "actions": self.actions[idx] } + + def _calculate_mean_std(self): + print(self.episode_frames.shape) + std = torch.std(self.episode_frames, dim=(0, 1, 3, 4)) + mean = torch.mean(self.episode_frames, dim=(0, 1, 3, 4)) + print("mean: ", mean) + print(mean.shape) + print("std: ", std) + print(std.shape) + # mean: tensor([182.6091, 182.6091, 182.6091]) + # torch.Size([3]) + # std: tensor([45.5565, 47.6260, 50.7284]) + # torch.Size([3]) + + +def postprocess(image): + image_ = image.detach().clone() + # print(image_.shape) + mean = torch.ones_like(image_) + std = torch.ones_like(image_) + mean[:, 0, :, :] = 182.6091 + mean[:, 1, :, :] = 182.6091 + mean[:, 2, :, :] = 182.6091 + + std[:, 0, :, :] = 45.5565 + std[:, 1, :, :] = 47.6260 + std[:, 2, :, :] = 50.7284 + + image_ = image_ * std + mean + image_ = torch.clamp(image_, min=0.0, max=255.0) / 255. + return image_ if __name__ == "__main__": - pass + data_set = DMMDataset() + data_set._calculate_mean_std() diff --git a/tutorial/Japanese/04-DeepMarkovModel.ipynb b/tutorial/Japanese/04-DeepMarkovModel.ipynb new file mode 100644 index 00000000..f996fe59 --- /dev/null +++ b/tutorial/Japanese/04-DeepMarkovModel.ipynb @@ -0,0 +1,3775 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Action Conditional Deep Markov Model using cartpole dataset" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/ubuntu/anaconda3/lib/python3.6/site-packages/matplotlib/__init__.py:1067: UserWarning: Duplicate key in file \"/home/ubuntu/.config/matplotlib/matplotlibrc\", line #2\n", + " (fname, cnt))\n", + "/home/ubuntu/anaconda3/lib/python3.6/site-packages/matplotlib/__init__.py:1067: UserWarning: Duplicate key in file \"/home/ubuntu/.config/matplotlib/matplotlibrc\", line #3\n", + " (fname, cnt))\n" + ] + } + ], + "source": [ + "from tqdm import tqdm\n", + "\n", + "import torch\n", + "from torch import optim\n", + "import torch.nn as nn\n", + "import torch.nn.functional as F\n", + "from torchvision import transforms, datasets\n", + "from tensorboardX import SummaryWriter\n", + "import numpy as np\n", + "\n", + "from utils import DMMDataset, imshow, postprocess\n", + "from torch.utils.data import DataLoader\n", + "import matplotlib.pyplot as plt\n", + "%matplotlib inline\n", + "\n", + "seed = 1\n", + "torch.manual_seed(seed)\n", + "if torch.cuda.is_available():\n", + " device = \"cuda\"\n", + "else:\n", + " device = \"cpu\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## データセットの準備\n", + "prepare_cartpole_dataset.pyを実行するか以下のリンクからデータセットをダウンロードしてください. \n", + "https://drive.google.com/drive/folders/1w_97RLFS--CpdUCNw1C-3yPLhceZxkO2?usp=sharing" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "torch.Size([30, 3, 28, 28])\n" + ] + } + ], + "source": [ + "batch_size = 256\n", + "train_loader = DataLoader(DMMDataset(), batch_size=batch_size, shuffle=True, drop_last=True)\n", + "# test_loader = DataLoader(DMMTestDataset(), batch_size=batch_size, shuffle=False, drop_last=True)\n", + "\n", + "_x = iter(train_loader).next()\n", + "print(_x['episode_frames'][0][0:30].shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "torch.Size([30, 3, 28, 28])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tensor([[0.],\n", + " [0.],\n", + " [1.],\n", + " [1.],\n", + " [1.],\n", + " [0.],\n", + " [0.],\n", + " [1.],\n", + " [0.],\n", + " [0.],\n", + " [1.],\n", + " [1.],\n", + " [0.],\n", + " [1.],\n", + " [1.],\n", + " [0.],\n", + " [1.],\n", + " [0.],\n", + " [0.],\n", + " [1.],\n", + " [1.],\n", + " [1.],\n", + " [1.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [0.]])\n" + ] + } + ], + "source": [ + "imshow(postprocess(_x['episode_frames'][0][0:30]))\n", + "\n", + "# 0: Push cart to the left\n", + "# 1:Push cart to the right\n", + "print(_x['actions'][0][0:30])\n", + "\n", + "# for more details about actions: https://github.com/openai/gym/blob/38a1f630dc9815a567aaf299ae5844c8f8b9a6fa/gym/envs/classic_control/cartpole.py#L37\n", + "# for more details about CartPole-v1: https://gym.openai.com/envs/CartPole-v1/" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "from pixyz.utils import print_latex\n", + "from pixyz.distributions import Bernoulli, Normal, Deterministic\n", + "\n", + "\n", + "h_dim = 32\n", + "hidden_dim = 32\n", + "z_dim = 16\n", + "t_max = 30\n", + "u_dim = 1" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Deep Markov Model\n", + "* 原著論文: Structured Inference Networks for Nonlinear State Space Models (https://arxiv.org/abs/1609.09869)\n", + "* 著者実装: https://github.com/clinicalml/dmm\n", + "\n", + "\n", + "Prior(Transition model): $p_{\\theta}(z_{t} | z_{t-1}, u) = \\cal{N}(\\mu = f_{prior_\\mu}(z_{t-1}, u), \\sigma^2 = f_{prior_\\sigma^2}(z_{t-1}, u)$ \n", + "Generator(Emission): $p_{\\theta}(x | z)=\\mathscr{B}\\left(x ; \\lambda=g_{x}(z)\\right)$ \n", + "\n", + "RNN: $p(h) = RNN(x)$ \n", + "Inference(Combiner): $p_{\\phi}(z | h, z_{t-1}, u) = \\cal{N}(\\mu = f_{\\mu}(h, z_{t-1}, u), \\sigma^2 = f_{\\sigma^2}(h, z_{t-1}, u)$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 確率分布の定義" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "# RNN\n", + "class RNN(Deterministic):\n", + " \"\"\"\n", + " h = RNN(x)\n", + " Given observed x, RNN output hidden state\n", + " \"\"\"\n", + " def __init__(self):\n", + " super(RNN, self).__init__(var=[\"h\"], cond_var=[\"x\"])\n", + " \n", + " # 28x28x3 → 32\n", + " self.conv1 = nn.Conv2d(3, 64, kernel_size=4, stride=2, padding=1)\n", + " self.conv2 = nn.Conv2d(64, 128, kernel_size=4, stride=2, padding=1)\n", + " self.fc1 = nn.Linear(128*7*7, 256)\n", + " self.fc2 = nn.Linear(256, 32)\n", + " \n", + " self.rnn = nn.GRU(32, h_dim, bidirectional=True)\n", + " self.h0 = nn.Parameter(torch.zeros(2, 1, self.rnn.hidden_size))\n", + " self.hidden_size = self.rnn.hidden_size\n", + " \n", + " def forward(self, x):\n", + " \n", + " h0 = self.h0.expand(2, x.size(1), self.rnn.hidden_size).contiguous()\n", + " x = x.reshape(-1, 3, 28, 28) # Nx3x28x28\n", + "\n", + " h = F.relu(self.conv1(x)) # Nx64x14x14\n", + " h = F.relu(self.conv2(h)) # Nx128x7x7\n", + " h = h.view(h.shape[0], 128*7*7) # Nx128*7*7\n", + " h = F.relu(self.fc1(h)) # Nx256\n", + " h = F.relu(self.fc2(h)) # Nx32\n", + " h = h.reshape(30, -1, 32) # 30x128x32\n", + "\n", + " h, _ = self.rnn(h, h0) # 30x128x32, 1x128x32\n", + " return {\"h\": h}\n", + "\n", + "\n", + "# Emission p(x_t | z_t)\n", + "class Generator(Normal):\n", + " \"\"\"\n", + " Given the latent z at time step t, return the vector of\n", + " probabilities that parameterizes the bernlulli distribution p(x_t | z_t)\n", + " \"\"\"\n", + " def __init__(self):\n", + " super(Generator, self).__init__(var=[\"x\"], cond_var=[\"z\"])\n", + " self.fc1 = nn.Linear(z_dim, 256)\n", + " self.fc2 = nn.Linear(256, 128*7*7)\n", + " self.conv1 = nn.ConvTranspose2d(128, 64, kernel_size=4, stride=2, padding=1)\n", + " self.conv2 = nn.ConvTranspose2d(64, 3, kernel_size=4, stride=2, padding=1) \n", + "\n", + " def forward(self, z):\n", + " h = F.relu(self.fc1(z))\n", + " h = F.relu(self.fc2(h))\n", + " h = h.view(h.shape[0], 128, 7, 7) # 128*7*7\n", + " h = F.relu(self.conv1(h)) # 64x14x14\n", + " generated_x = self.conv2(h) # 3x28x28\n", + " return {\"loc\": generated_x, \"scale\": 1.0}\n", + "\n", + "\n", + "class Inference(Normal):\n", + " \"\"\"\n", + " given the latent z at time step t-1, the hidden state of the RNN h(x_{0:T} and u\n", + " return the loc and scale vectors that\n", + " parameterize the gaussian distribution q(z_t | z_{t-1}, x_{t:T}, u)\n", + " \"\"\"\n", + " def __init__(self):\n", + " super(Inference, self).__init__(var=[\"z\"], cond_var=[\"h\", \"z_prev\", \"u\"])\n", + " self.fc1 = nn.Linear(z_dim+u_dim, h_dim*2)\n", + " self.fc21 = nn.Linear(h_dim*2, z_dim)\n", + " self.fc22 = nn.Linear(h_dim*2, z_dim)\n", + "\n", + " \n", + " def forward(self, h, z_prev, u):\n", + " feature = torch.cat((z_prev, u), 1)\n", + " h_z = torch.tanh(self.fc1(feature))\n", + " h = 0.5 * (h + h_z)\n", + " return {\"loc\": self.fc21(h), \"scale\": F.softplus(self.fc22(h))}\n", + "\n", + "\n", + "class Prior(Normal):\n", + " \"\"\"\n", + " Given the latent variable at the time step t-1 and u,\n", + " return the mean and scale vectors that parameterize the\n", + " gaussian distribution p(z_t | z_{t-1}, u)\n", + " \"\"\"\n", + " def __init__(self):\n", + " super(Prior, self).__init__(var=[\"z\"], cond_var=[\"z_prev\", \"u\"])\n", + " self.fc1 = nn.Linear(z_dim+u_dim, hidden_dim)\n", + " self.fc21 = nn.Linear(hidden_dim, z_dim)\n", + " self.fc22 = nn.Linear(hidden_dim, z_dim)\n", + " \n", + " def forward(self, z_prev, u):\n", + " feature = torch.cat((z_prev, u), 1)\n", + " h = F.relu(self.fc1(feature))\n", + " return {\"loc\": self.fc21(h), \"scale\": F.softplus(self.fc22(h))}" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/latex": [ + "$$p(x,z|z_{prev},u) = p(x|z)p(z|z_{prev},u)$$" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "prior = Prior().to(device)\n", + "encoder = Inference().to(device)\n", + "decoder = Generator().to(device)\n", + "rnn = RNN().to(device)\n", + "generate_from_prior = prior * decoder\n", + "\n", + "print_latex(generate_from_prior)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## ロス関数の定義" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "from pixyz.losses import KullbackLeibler\n", + "from pixyz.losses import Expectation as E\n", + "from pixyz.losses import LogProb\n", + "from pixyz.losses import IterativeLoss\n", + "\n", + "step_loss = - E(encoder, LogProb(decoder)) + KullbackLeibler(encoder, prior)\n", + "\n", + "# IterativeLoss: https://docs.pixyz.io/en/latest/losses.html#pixyz.losses.IterativeLoss\n", + "_loss = IterativeLoss(step_loss, max_iter=t_max, \n", + " series_var=[\"x\", \"h\", \"u\"], update_value={\"z\": \"z_prev\"})\n", + "loss = E(rnn, _loss).mean()" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Distributions (for training): \n", + " p(h|x), p(z|h,z_{prev},u), p(x|z), p(z|z_{prev},u) \n", + "Loss function: \n", + " mean \\left(\\mathbb{E}_{p(h|x)} \\left[\\sum_{t=1}^{30} \\left(D_{KL} \\left[p(z|h,z_{prev},u)||p(z|z_{prev},u) \\right] - \\mathbb{E}_{p(z|h,z_{prev},u)} \\left[\\log p(x|z) \\right]\\right) \\right] \\right) \n", + "Optimizer: \n", + " RMSprop (\n", + " Parameter Group 0\n", + " alpha: 0.99\n", + " centered: False\n", + " eps: 1e-08\n", + " lr: 0.0005\n", + " momentum: 0\n", + " weight_decay: 0\n", + " )\n" + ] + }, + { + "data": { + "text/latex": [ + "$$mean \\left(\\mathbb{E}_{p(h|x)} \\left[\\sum_{t=1}^{30} \\left(D_{KL} \\left[p(z|h,z_{prev},u)||p(z|z_{prev},u) \\right] - \\mathbb{E}_{p(z|h,z_{prev},u)} \\left[\\log p(x|z) \\right]\\right) \\right] \\right)$$" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from pixyz.models import Model\n", + "\n", + "dmm = Model(loss, distributions=[rnn, encoder, decoder, prior], \n", + " optimizer=optim.RMSprop, optimizer_params={\"lr\": 5e-4}, clip_grad_value=10)\n", + "\n", + "print(dmm)\n", + "print_latex(dmm)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## サンプリングの実装" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "def data_loop(epoch, loader, model, device, train_mode=False):\n", + " mean_loss = 0\n", + " for data in loader:\n", + " x = data['episode_frames'].to(device) # 256,30,3,28,28\n", + " u = data['actions'].to(device) # 256,30,1\n", + " batch_size = x.size()[0]\n", + " x = x.transpose(0, 1) # 30,256,3,28,28\n", + " u = u.transpose(0, 1) # 30,256,1\n", + " z_prev = torch.zeros(batch_size, z_dim).to(device)\n", + " if train_mode:\n", + " mean_loss += model.train({'x': x, 'z_prev': z_prev, 'u': u}).item() * batch_size\n", + " else:\n", + " mean_loss += model.test({'x': x, 'z_prev': z_prev, 'u': u}).item() * batch_size\n", + " mean_loss /= len(loader.dataset)\n", + " if train_mode:\n", + " print('Epoch: {} Train loss: {:.4f}'.format(epoch, mean_loss))\n", + " else:\n", + " print('Test loss: {:.4f}'.format(mean_loss))\n", + " return mean_loss\n", + "\n", + "_data = iter(train_loader).next()\n", + "_u = _data['actions'].to(device) # 256,30,1\n", + "_u = _u.transpose(0, 1) # 30,256,1\n", + "\n", + "def plot_video_from_latent(batch_size):\n", + " x = []\n", + " z_prev = torch.zeros(batch_size, z_dim).to(device)\n", + " for step in range(t_max):\n", + " samples = generate_from_prior.sample({'z_prev': z_prev, 'u': _u[step]})\n", + " x_t = decoder.sample_mean({\"z\": samples[\"z\"]})\n", + " z_prev = samples[\"z\"]\n", + " x.append(x_t[None, :])\n", + " x = torch.cat(x, dim=0).transpose(0, 1)\n", + " return x" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 学習" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 0%| | 0/200 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 25%|██▌ | 50/200 [03:07<09:21, 3.74s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 51 Train loss: 56918.8460\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 26%|██▌ | 51/200 [03:10<09:17, 3.74s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 52 Train loss: 56915.1000\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 26%|██▌ | 52/200 [03:14<09:14, 3.74s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 53 Train loss: 56753.4140\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 26%|██▋ | 53/200 [03:18<09:10, 3.75s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 54 Train loss: 56730.8040\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 27%|██▋ | 54/200 [03:22<09:06, 3.75s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 55 Train loss: 56547.8380\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 28%|██▊ | 55/200 [03:26<09:03, 3.75s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 56 Train loss: 56521.4380\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 28%|██▊ | 56/200 [03:29<08:59, 3.75s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 57 Train loss: 56354.7460\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 28%|██▊ | 57/200 [03:33<08:56, 3.75s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 58 Train loss: 56339.7680\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 29%|██▉ | 58/200 [03:37<08:52, 3.75s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 59 Train loss: 56202.9720\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 30%|██▉ | 59/200 [03:41<08:48, 3.75s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 60 Train loss: 56237.3020\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 30%|███ | 60/200 [03:44<08:44, 3.75s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 61 Train loss: 56139.1900\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 30%|███ | 61/200 [03:48<08:41, 3.75s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 62 Train loss: 56147.0400\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 31%|███ | 62/200 [03:52<08:37, 3.75s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 63 Train loss: 55940.0920\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 32%|███▏ | 63/200 [03:56<08:33, 3.75s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 64 Train loss: 55937.6240\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 32%|███▏ | 64/200 [04:00<08:30, 3.75s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 65 Train loss: 55873.2520\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 32%|███▎ | 65/200 [04:03<08:26, 3.75s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 66 Train loss: 55850.3560\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 33%|███▎ | 66/200 [04:07<08:22, 3.75s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 67 Train loss: 55750.4980\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 34%|███▎ | 67/200 [04:11<08:18, 3.75s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 68 Train loss: 55680.4340\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 34%|███▍ | 68/200 [04:15<08:15, 3.75s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 69 Train loss: 55597.4760\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 34%|███▍ | 69/200 [04:18<08:11, 3.75s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 70 Train loss: 55611.5000\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 35%|███▌ | 70/200 [04:22<08:07, 3.75s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 71 Train loss: 55472.8580\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 36%|███▌ | 71/200 [04:26<08:04, 3.75s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 72 Train loss: 55479.3820\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 36%|███▌ | 72/200 [04:30<08:00, 3.75s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 73 Train loss: 55377.1240\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 36%|███▋ | 73/200 [04:33<07:56, 3.75s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 74 Train loss: 55396.5380\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 37%|███▋ | 74/200 [04:37<07:52, 3.75s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 75 Train loss: 55280.8860\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 38%|███▊ | 75/200 [04:41<07:48, 3.75s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 76 Train loss: 55321.7620\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 38%|███▊ | 76/200 [04:45<07:45, 3.75s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 77 Train loss: 55240.7700\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 38%|███▊ | 77/200 [04:48<07:41, 3.75s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 78 Train loss: 55269.5880\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 39%|███▉ | 78/200 [04:52<07:37, 3.75s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 79 Train loss: 55133.5280\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 40%|███▉ | 79/200 [04:56<07:33, 3.75s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 80 Train loss: 55104.4220\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 40%|████ | 80/200 [05:00<07:30, 3.75s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 81 Train loss: 55081.1040\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 40%|████ | 81/200 [05:03<07:26, 3.75s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 82 Train loss: 55047.0000\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 41%|████ | 82/200 [05:07<07:22, 3.75s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 83 Train loss: 54985.2680\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 42%|████▏ | 83/200 [05:11<07:19, 3.75s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 84 Train loss: 55013.6080\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 42%|████▏ | 84/200 [05:15<07:15, 3.75s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 85 Train loss: 54898.4080\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 42%|████▎ | 85/200 [05:19<07:11, 3.75s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 86 Train loss: 54905.5400\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 43%|████▎ | 86/200 [05:22<07:07, 3.75s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 87 Train loss: 54800.7460\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 44%|████▎ | 87/200 [05:26<07:04, 3.75s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 88 Train loss: 54869.8440\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 44%|████▍ | 88/200 [05:30<07:00, 3.75s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 89 Train loss: 54773.8220\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 44%|████▍ | 89/200 [05:34<06:56, 3.75s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 90 Train loss: 54797.5880\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 45%|████▌ | 90/200 [05:37<06:52, 3.75s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 91 Train loss: 54722.7540\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 46%|████▌ | 91/200 [05:41<06:49, 3.75s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 92 Train loss: 54689.5920\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 46%|████▌ | 92/200 [05:45<06:45, 3.75s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 93 Train loss: 54673.8340\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 46%|████▋ | 93/200 [05:49<06:41, 3.75s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 94 Train loss: 54688.9560\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 47%|████▋ | 94/200 [05:52<06:38, 3.75s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 95 Train loss: 54589.7360\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 48%|████▊ | 95/200 [05:56<06:34, 3.76s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 96 Train loss: 54670.2120\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 48%|████▊ | 96/200 [06:00<06:30, 3.76s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 97 Train loss: 54538.6200\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 48%|████▊ | 97/200 [06:04<06:26, 3.76s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 98 Train loss: 54601.9580\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 49%|████▉ | 98/200 [06:08<06:23, 3.76s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 99 Train loss: 54493.3220\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 50%|████▉ | 99/200 [06:11<06:19, 3.76s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 100 Train loss: 54537.6560\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 50%|█████ | 100/200 [06:17<06:17, 3.77s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 101 Train loss: 54449.7640\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 50%|█████ | 101/200 [06:20<06:13, 3.77s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 102 Train loss: 54469.0700\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 51%|█████ | 102/200 [06:24<06:09, 3.77s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 103 Train loss: 54416.8460\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 52%|█████▏ | 103/200 [06:28<06:05, 3.77s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 104 Train loss: 54398.1040\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 52%|█████▏ | 104/200 [06:32<06:01, 3.77s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 105 Train loss: 54356.4000\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 52%|█████▎ | 105/200 [06:35<05:58, 3.77s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 106 Train loss: 54385.8600\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 53%|█████▎ | 106/200 [06:39<05:54, 3.77s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 107 Train loss: 54316.6400\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 54%|█████▎ | 107/200 [06:43<05:50, 3.77s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 108 Train loss: 54326.4580\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 54%|█████▍ | 108/200 [06:46<05:46, 3.77s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 109 Train loss: 54278.5520\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 55%|█████▍ | 109/200 [06:50<05:42, 3.77s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 110 Train loss: 54270.9440\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 55%|█████▌ | 110/200 [06:54<05:39, 3.77s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 111 Train loss: 54198.1240\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 56%|█████▌ | 111/200 [06:58<05:35, 3.77s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 112 Train loss: 54217.6400\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 56%|█████▌ | 112/200 [07:01<05:31, 3.77s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 113 Train loss: 54227.1020\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 56%|█████▋ | 113/200 [07:05<05:27, 3.77s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 114 Train loss: 54192.6200\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 57%|█████▋ | 114/200 [07:09<05:23, 3.77s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 115 Train loss: 54128.4960\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 57%|█████▊ | 115/200 [07:12<05:19, 3.76s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 116 Train loss: 54140.9200\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 58%|█████▊ | 116/200 [07:16<05:16, 3.76s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 117 Train loss: 54083.3540\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 58%|█████▊ | 117/200 [07:20<05:12, 3.76s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 118 Train loss: 54150.9420\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 59%|█████▉ | 118/200 [07:24<05:08, 3.76s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 119 Train loss: 54122.0900\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 60%|█████▉ | 119/200 [07:27<05:04, 3.76s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 120 Train loss: 54080.4260\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 60%|██████ | 120/200 [07:31<05:01, 3.76s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 121 Train loss: 54019.1040\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 60%|██████ | 121/200 [07:35<04:57, 3.76s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 122 Train loss: 54062.8540\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 61%|██████ | 122/200 [07:38<04:53, 3.76s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 123 Train loss: 54035.6220\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 62%|██████▏ | 123/200 [07:42<04:49, 3.76s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 124 Train loss: 54011.5440\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 62%|██████▏ | 124/200 [07:46<04:45, 3.76s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 125 Train loss: 54024.6200\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 62%|██████▎ | 125/200 [07:50<04:42, 3.76s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 126 Train loss: 54015.2780\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 63%|██████▎ | 126/200 [07:53<04:38, 3.76s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 127 Train loss: 53925.2420\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 64%|██████▎ | 127/200 [07:57<04:34, 3.76s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 128 Train loss: 53923.9820\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 64%|██████▍ | 128/200 [08:01<04:30, 3.76s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 129 Train loss: 53921.9400\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 64%|██████▍ | 129/200 [08:05<04:27, 3.76s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 130 Train loss: 53954.9500\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 65%|██████▌ | 130/200 [08:08<04:23, 3.76s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 131 Train loss: 53900.2320\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 66%|██████▌ | 131/200 [08:12<04:19, 3.76s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 132 Train loss: 53951.0080\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 66%|██████▌ | 132/200 [08:16<04:15, 3.76s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 133 Train loss: 53882.3460\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 66%|██████▋ | 133/200 [08:19<04:11, 3.76s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 134 Train loss: 53892.5360\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 67%|██████▋ | 134/200 [08:23<04:08, 3.76s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 135 Train loss: 53831.4800\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 68%|██████▊ | 135/200 [08:27<04:04, 3.76s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 136 Train loss: 53867.3220\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 68%|██████▊ | 136/200 [08:31<04:00, 3.76s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 137 Train loss: 53775.3900\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 68%|██████▊ | 137/200 [08:34<03:56, 3.76s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 138 Train loss: 53849.3200\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 69%|██████▉ | 138/200 [08:38<03:53, 3.76s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 139 Train loss: 53799.0400\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 70%|██████▉ | 139/200 [08:42<03:49, 3.76s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 140 Train loss: 53831.0840\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 70%|███████ | 140/200 [08:46<03:45, 3.76s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 141 Train loss: 53774.4560\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 70%|███████ | 141/200 [08:49<03:41, 3.76s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 142 Train loss: 53768.7980\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 71%|███████ | 142/200 [08:53<03:37, 3.76s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 143 Train loss: 53747.4720\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 72%|███████▏ | 143/200 [08:57<03:34, 3.76s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 144 Train loss: 53760.9700\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 72%|███████▏ | 144/200 [09:01<03:30, 3.76s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 145 Train loss: 53726.1320\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 72%|███████▎ | 145/200 [09:04<03:26, 3.76s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 146 Train loss: 53704.6480\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 73%|███████▎ | 146/200 [09:08<03:22, 3.76s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 147 Train loss: 53708.6720\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 74%|███████▎ | 147/200 [09:12<03:19, 3.76s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 148 Train loss: 53695.1900\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 74%|███████▍ | 148/200 [09:15<03:15, 3.76s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 149 Train loss: 53638.0920\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 74%|███████▍ | 149/200 [09:19<03:11, 3.76s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 150 Train loss: 53633.9860\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 75%|███████▌ | 150/200 [09:24<03:08, 3.76s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 151 Train loss: 53657.9560\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 76%|███████▌ | 151/200 [09:28<03:04, 3.76s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 152 Train loss: 53670.0940\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 76%|███████▌ | 152/200 [09:32<03:00, 3.76s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 153 Train loss: 53607.0760\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 76%|███████▋ | 153/200 [09:35<02:56, 3.76s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 154 Train loss: 53651.3560\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 77%|███████▋ | 154/200 [09:39<02:53, 3.76s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 155 Train loss: 53592.4700\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 78%|███████▊ | 155/200 [09:43<02:49, 3.76s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 156 Train loss: 53585.4440\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 78%|███████▊ | 156/200 [09:46<02:45, 3.76s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 157 Train loss: 53552.6640\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 78%|███████▊ | 157/200 [09:50<02:41, 3.76s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 158 Train loss: 53611.3140\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 79%|███████▉ | 158/200 [09:54<02:37, 3.76s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 159 Train loss: 53524.5080\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 80%|███████▉ | 159/200 [09:58<02:34, 3.76s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 160 Train loss: 53590.1420\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 80%|████████ | 160/200 [10:01<02:30, 3.76s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 161 Train loss: 53528.6480\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 80%|████████ | 161/200 [10:05<02:26, 3.76s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 162 Train loss: 53558.7360\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 81%|████████ | 162/200 [10:09<02:22, 3.76s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 163 Train loss: 53519.7460\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 82%|████████▏ | 163/200 [10:12<02:19, 3.76s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 164 Train loss: 53528.5480\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 82%|████████▏ | 164/200 [10:16<02:15, 3.76s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 165 Train loss: 53517.9280\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 82%|████████▎ | 165/200 [10:20<02:11, 3.76s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 166 Train loss: 53496.1340\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 83%|████████▎ | 166/200 [10:24<02:07, 3.76s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 167 Train loss: 53485.6460\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 84%|████████▎ | 167/200 [10:27<02:04, 3.76s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 168 Train loss: 53502.5240\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 84%|████████▍ | 168/200 [10:31<02:00, 3.76s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 169 Train loss: 53443.6100\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 84%|████████▍ | 169/200 [10:35<01:56, 3.76s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 170 Train loss: 53506.9640\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 85%|████████▌ | 170/200 [10:38<01:52, 3.76s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 171 Train loss: 53447.6360\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 86%|████████▌ | 171/200 [10:42<01:48, 3.76s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 172 Train loss: 53448.5900\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 86%|████████▌ | 172/200 [10:46<01:45, 3.76s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 173 Train loss: 53418.1960\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 86%|████████▋ | 173/200 [10:49<01:41, 3.76s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 174 Train loss: 53440.3740\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 87%|████████▋ | 174/200 [10:53<01:37, 3.76s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 175 Train loss: 53428.7820\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 88%|████████▊ | 175/200 [10:57<01:33, 3.76s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 176 Train loss: 53430.0740\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 88%|████████▊ | 176/200 [11:01<01:30, 3.76s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 177 Train loss: 53414.4660\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 88%|████████▊ | 177/200 [11:04<01:26, 3.76s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 178 Train loss: 53422.6460\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 89%|████████▉ | 178/200 [11:08<01:22, 3.76s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 179 Train loss: 53351.5180\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 90%|████████▉ | 179/200 [11:12<01:18, 3.76s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 180 Train loss: 53396.0980\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 90%|█████████ | 180/200 [11:15<01:15, 3.76s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 181 Train loss: 53367.9520\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 90%|█████████ | 181/200 [11:19<01:11, 3.76s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 182 Train loss: 53406.4260\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 91%|█████████ | 182/200 [11:23<01:07, 3.75s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 183 Train loss: 53343.4320\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 92%|█████████▏| 183/200 [11:27<01:03, 3.75s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 184 Train loss: 53386.9000\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 92%|█████████▏| 184/200 [11:30<01:00, 3.75s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 185 Train loss: 53286.1660\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 92%|█████████▎| 185/200 [11:34<00:56, 3.75s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 186 Train loss: 53343.7720\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 93%|█████████▎| 186/200 [11:38<00:52, 3.75s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 187 Train loss: 53285.4420\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 94%|█████████▎| 187/200 [11:42<00:48, 3.75s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 188 Train loss: 53315.5800\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 94%|█████████▍| 188/200 [11:45<00:45, 3.75s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 189 Train loss: 53277.0700\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 94%|█████████▍| 189/200 [11:49<00:41, 3.75s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 190 Train loss: 53293.7760\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 95%|█████████▌| 190/200 [11:53<00:37, 3.75s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 191 Train loss: 53241.2220\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 96%|█████████▌| 191/200 [11:56<00:33, 3.75s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 192 Train loss: 53316.2600\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 96%|█████████▌| 192/200 [12:00<00:30, 3.75s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 193 Train loss: 53282.9120\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 96%|█████████▋| 193/200 [12:04<00:26, 3.75s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 194 Train loss: 53283.6220\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 97%|█████████▋| 194/200 [12:08<00:22, 3.75s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 195 Train loss: 53215.3320\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 98%|█████████▊| 195/200 [12:11<00:18, 3.75s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 196 Train loss: 53229.7160\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 98%|█████████▊| 196/200 [12:15<00:15, 3.75s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 197 Train loss: 53230.3920\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 98%|█████████▊| 197/200 [12:19<00:11, 3.75s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 198 Train loss: 53257.9480\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + " 99%|█████████▉| 198/200 [12:23<00:07, 3.75s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 199 Train loss: 53196.7220\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + "100%|█████████▉| 199/200 [12:26<00:03, 3.75s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 200 Train loss: 53217.5220\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n", + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 200/200 [12:32<00:00, 3.76s/it]\n" + ] + } + ], + "source": [ + "epochs = 200\n", + "for epoch in tqdm(range(1, epochs + 1)):\n", + " train_loss = data_loop(epoch, train_loader, dmm, device, train_mode=True)\n", + " sample = plot_video_from_latent(batch_size)\n", + " if epoch % 50 == 0:\n", + " plt.figure(figsize=(10,3))\n", + " for i in range(30):\n", + " plt.subplot(3,10,i+1)\n", + " plt.imshow(sample[0][i].cpu().detach().numpy().astype(np.float).reshape(3,28,28).transpose(1,2,0))\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "torch.Size([30, 3, 28, 28])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "imshow(postprocess(sample[0].cpu().detach()))" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "torch.Size([30, 3, 28, 28])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tensor([[1.],\n", + " [1.],\n", + " [0.],\n", + " [1.],\n", + " [1.],\n", + " [0.],\n", + " [1.],\n", + " [0.],\n", + " [1.],\n", + " [0.],\n", + " [0.],\n", + " [0.],\n", + " [1.],\n", + " [1.],\n", + " [1.],\n", + " [1.],\n", + " [0.],\n", + " [1.],\n", + " [1.],\n", + " [0.],\n", + " [1.],\n", + " [1.],\n", + " [0.],\n", + " [0.],\n", + " [1.],\n", + " [0.],\n", + " [0.],\n", + " [1.],\n", + " [0.],\n", + " [0.]])\n" + ] + } + ], + "source": [ + "imshow(postprocess(_data[\"episode_frames\"][0]))\n", + "print(_data[\"actions\"][0])" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.4" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/tutorial/Japanese/prepare_cartpole_dataset.py b/tutorial/Japanese/prepare_cartpole_dataset.py new file mode 100644 index 00000000..63acf755 --- /dev/null +++ b/tutorial/Japanese/prepare_cartpole_dataset.py @@ -0,0 +1,41 @@ +import gym +import pickle +import numpy as np +import cv2 + + +def main(): + env = gym.make("CartPole-v1") + observation = env.reset() + + episodes = {"frames": [], "actions": []} + + # for 56 *56 episode num = 500 + # for 28 * 28 episode num = 1000 + for _episode in range(1000): + frames = [] + actions = [] + for _frame in range(30): + action = env.action_space.sample() # your agent here (this takes random actions) + frame = env.render(mode='rgb_array') + observation, reward, done, info = env.step(action) + + img = frame + img = img[150:350, 200:400] + img = cv2.resize(img, (28, 28)) + + frames.append(img) + actions.append(action) + _ = env.reset() + episodes["frames"].append(frames) + episodes["actions"].append(actions) + env.close() + + data = [np.array(episodes["frames"]), np.array(episodes["actions"])] + print(data[0].shape, data[1].shape) + with open('cartpole_28.pickle', mode='wb') as f: + pickle.dump(data, f) + + +if __name__ == "__main__": + main() diff --git a/tutorial/Japanese/utils.py b/tutorial/Japanese/utils.py new file mode 100644 index 00000000..619971bd --- /dev/null +++ b/tutorial/Japanese/utils.py @@ -0,0 +1,87 @@ +from torch.utils.data import Dataset +import pickle +import numpy as np +import torch +import torchvision +import matplotlib.pyplot as plt + + +def imshow(img_tensors): + img = torchvision.utils.make_grid(img_tensors) + npimg = img.numpy() + plt.figure(figsize=(16, 12)) + plt.imshow(np.transpose(npimg, (1, 2, 0))) + plt.show() + + +class DMMDataset(Dataset): + def __init__(self, pickle_path="cartpole_28.pickle"): + + with open(pickle_path, mode='rb') as f: + data = pickle.load(f) + episode_frames, actions = data + # episode_frames: np.array([episode_num, one_episode_length, height, width, Channels]) (10000, 30, 28, 28, 3) + # actions: np.array([episode_num, one_episode_length]) (10000, 30) + # HWC → CHW + episode_frames = episode_frames.transpose(0, 1, 4, 2, 3) / 1.0 + # print(episode_frames.dtype) + actions = actions[:, :, np.newaxis] + + self.episode_frames = torch.from_numpy(episode_frames.astype(np.float32)) + self.actions = torch.from_numpy(actions.astype(np.float32)) + + self.mean = torch.zeros_like(self.episode_frames[0]) + self.std = torch.zeros_like(self.episode_frames[0]) + + self.mean[:, 0, :, :] = 182.6091 + self.mean[:, 1, :, :] = 182.6091 + self.mean[:, 2, :, :] = 182.6091 + + self.std[:, 0, :, :] = 45.5565 + self.std[:, 1, :, :] = 47.6260 + self.std[:, 2, :, :] = 50.7284 + + def __len__(self): + return len(self.episode_frames) + + def __getitem__(self, idx): + return { + "episode_frames": (self.episode_frames[idx] - self.mean) / self.std, + "actions": self.actions[idx] + } + + def _calculate_mean_std(self): + print(self.episode_frames.shape) + std = torch.std(self.episode_frames, dim=(0, 1, 3, 4)) + mean = torch.mean(self.episode_frames, dim=(0, 1, 3, 4)) + print("mean: ", mean) + print(mean.shape) + print("std: ", std) + print(std.shape) + # mean: tensor([182.6091, 182.6091, 182.6091]) + # torch.Size([3]) + # std: tensor([45.5565, 47.6260, 50.7284]) + # torch.Size([3]) + + +def postprocess(image): + image_ = image.detach().clone() + # print(image_.shape) + mean = torch.ones_like(image_) + std = torch.ones_like(image_) + mean[:, 0, :, :] = 182.6091 + mean[:, 1, :, :] = 182.6091 + mean[:, 2, :, :] = 182.6091 + + std[:, 0, :, :] = 45.5565 + std[:, 1, :, :] = 47.6260 + std[:, 2, :, :] = 50.7284 + + image_ = image_ * std + mean + image_ = torch.clamp(image_, min=0.0, max=255.0) / 255. + return image_ + + +if __name__ == "__main__": + data_set = DMMDataset() + data_set._calculate_mean_std() diff --git a/tutorial/README.md b/tutorial/README.md index f7e66a03..a5db7693 100644 --- a/tutorial/README.md +++ b/tutorial/README.md @@ -1,19 +1,21 @@ # Pixyz Tutorials +We have tutorials in [English](https://github.com/masa-su/pixyz/tree/master/tutorial/English) and [Japanese](https://github.com/masa-su/pixyz/tree/master/tutorial/Japanese). + -## [Pixyz Overview](https://github.com/masa-su/pixyz/blob/master/tutorial/English/00-PixyzOverview.ipynb) -Overviewing relationships between each Pixyz APIs(Distribution API, Loss API, Model API) by implementing VAE +- [Pixyz Overview](https://github.com/masa-su/pixyz/blob/master/tutorial/English/00-PixyzOverview.ipynb) + - Overviewing relationships between each Pixyz APIs(Distribution API, Loss API, Model API) by implementing VAE -## [Distribution API Tutorial](https://github.com/masa-su/pixyz/blob/master/tutorial/English/01-DistributionAPITutorial.ipynb) -Detailed introduction of Distribution API +- [Distribution API Tutorial](https://github.com/masa-su/pixyz/blob/master/tutorial/English/01-DistributionAPITutorial.ipynb) + - Detailed introduction of Distribution API -## [Loss API Tutorial](https://github.com/masa-su/pixyz/blob/master/tutorial/English/02-LossAPITutorial.ipynb) -Detailed introduction of Loss API +- [Loss API Tutorial](https://github.com/masa-su/pixyz/blob/master/tutorial/English/02-LossAPITutorial.ipynb) + - Detailed introduction of Loss API -## [Model API Tutorial](https://github.com/masa-su/pixyz/blob/master/tutorial/English/03-ModelAPITutorial.ipynb) -Detailed introduction of Model API +- [Model API Tutorial](https://github.com/masa-su/pixyz/blob/master/tutorial/English/03-ModelAPITutorial.ipynb) + - Detailed introduction of Model API -## [Example: Action conditional Deep Markov Model](https://github.com/masa-su/pixyz/blob/master/tutorial/English/04-DeepMarkovModel.ipynb) -Action conditional Deep Markov Model implemented in Pixyz +- [Example: Action conditional Deep Markov Model](https://github.com/masa-su/pixyz/blob/master/tutorial/English/04-DeepMarkovModel.ipynb) + - Action conditional Deep Markov Model implemented in Pixyz ## For more implementations - [examples](https://github.com/masa-su/pixyz/tree/master/examples)