diff --git a/.gitignore b/.gitignore
index 00c3cdc5a12640cf93a928015d277b16b6f20af7..9bfae9656776347b498f66bc55f18cc1ad498e55 100644
--- a/.gitignore
+++ b/.gitignore
@@ -3,7 +3,8 @@ __pycache__/
 *.py[cod]
 *$py.class
 
-
+pretrained_model
+trained_model
 # fichier mac
 .DS_Store
 
diff --git a/BE2_GAN_and_cGAN.ipynb b/BE2_GAN_and_cGAN.ipynb
index b4943acde1c55c6b494bdde93b708b8d5b1c160e..dc03acc235aaf643a7ad4a8ae4dfa5b42513b506 100644
--- a/BE2_GAN_and_cGAN.ipynb
+++ b/BE2_GAN_and_cGAN.ipynb
@@ -72336,7 +72336,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 2,
    "metadata": {
     "colab": {},
     "colab_type": "code",
@@ -72372,7 +72372,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 3,
    "metadata": {
     "colab": {},
     "colab_type": "code",
@@ -72458,7 +72458,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 63,
+   "execution_count": 130,
    "metadata": {
     "colab": {},
     "colab_type": "code",
@@ -72498,13 +72498,13 @@
     "        # CD512 - CD1024 - CD1024 - C1024 - C1024 - C512 - C256 - C128\n",
     "        # The last layer has already been defined\n",
     "\n",
-    "        self.up1 = up(512, 1024, dropout=True)\n",
-    "        self.up2 = up(1024, 1024, dropout=True)\n",
-    "        self.up3 = up(1024, 1024, dropout=True)\n",
-    "        self.up4 = up(1024, 1024, dropout=False)\n",
-    "        self.up5 = up(1024, 512, dropout=False)\n",
-    "        self.up6 = up(512, 256, dropout=False)\n",
-    "        self.up7 = up(256, 128, dropout=False) \n",
+    "        self.up1 = up(512, 512, dropout=True)\n",
+    "        self.up2 = up(1024, 512, dropout=True)\n",
+    "        self.up3 = up(1024, 512, dropout=True)\n",
+    "        self.up4 = up(1024, 512, dropout=False)\n",
+    "        self.up5 = up(1024, 256, dropout=False)\n",
+    "        self.up6 = up(512, 128, dropout=False)\n",
+    "        self.up7 = up(256, 64, dropout=False) \n",
     "        \n",
     "        self.outc = outconv(128, n_classes) # 128 filters\n",
     "\n",
@@ -72519,11 +72519,23 @@
     "        x8 = self.down7(x7)\n",
     "        # At this stage x8 is our encoded vector, we will now decode it\n",
     "        x = self.up1(x8, x7)\n",
+    "        # print(\"shape of x: \", x.shape)\n",
+    "        # print(\"shape of x7: \", x7.shape)\n",
     "        x = self.up2(x, x6)\n",
+    "        # print(\"shape of x: \", x.shape)\n",
+    "        # print(\"shape of x6: \", x6.shape)\n",
     "        x = self.up3(x, x5)\n",
+    "        # print(\"shape of x: \", x.shape)\n",
+    "        # print(\"shape of x5: \", x5.shape)\n",
     "        x = self.up4(x, x4)\n",
+    "        # print(\"shape of x: \", x.shape)\n",
+    "        # print(\"shape of x4: \", x4.shape)\n",
     "        x = self.up5(x, x3)\n",
+    "        # print(\"shape of x: \", x.shape)\n",
+    "        # print(\"shape of x3: \", x3.shape)\n",
     "        x = self.up6(x, x2)\n",
+    "        # print(\"shape of x: \", x.shape)\n",
+    "        # print(\"shape of x2: \", x2.shape)\n",
     "        x = self.up7(x, x1)\n",
     "        x = self.outc(x)\n",
     "        return x"
@@ -72531,7 +72543,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 64,
+   "execution_count": 131,
    "metadata": {
     "colab": {},
     "colab_type": "code",
@@ -72599,53 +72611,53 @@
        "  )\n",
        "  (up1): up(\n",
        "    (conv): Sequential(\n",
-       "      (0): ConvTranspose2d(512, 1024, kernel_size=(4, 4), stride=(2, 2), padding=(1, 1))\n",
-       "      (1): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "      (0): ConvTranspose2d(512, 512, kernel_size=(4, 4), stride=(2, 2), padding=(1, 1))\n",
+       "      (1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
        "      (2): Dropout(p=0.5, inplace=True)\n",
        "      (3): ReLU(inplace=True)\n",
        "    )\n",
        "  )\n",
        "  (up2): up(\n",
        "    (conv): Sequential(\n",
-       "      (0): ConvTranspose2d(1024, 1024, kernel_size=(4, 4), stride=(2, 2), padding=(1, 1))\n",
-       "      (1): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "      (0): ConvTranspose2d(1024, 512, kernel_size=(4, 4), stride=(2, 2), padding=(1, 1))\n",
+       "      (1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
        "      (2): Dropout(p=0.5, inplace=True)\n",
        "      (3): ReLU(inplace=True)\n",
        "    )\n",
        "  )\n",
        "  (up3): up(\n",
        "    (conv): Sequential(\n",
-       "      (0): ConvTranspose2d(1024, 1024, kernel_size=(4, 4), stride=(2, 2), padding=(1, 1))\n",
-       "      (1): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "      (0): ConvTranspose2d(1024, 512, kernel_size=(4, 4), stride=(2, 2), padding=(1, 1))\n",
+       "      (1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
        "      (2): Dropout(p=0.5, inplace=True)\n",
        "      (3): ReLU(inplace=True)\n",
        "    )\n",
        "  )\n",
        "  (up4): up(\n",
        "    (conv): Sequential(\n",
-       "      (0): ConvTranspose2d(1024, 1024, kernel_size=(4, 4), stride=(2, 2), padding=(1, 1))\n",
-       "      (1): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "      (0): ConvTranspose2d(1024, 512, kernel_size=(4, 4), stride=(2, 2), padding=(1, 1))\n",
+       "      (1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
        "      (2): ReLU(inplace=True)\n",
        "    )\n",
        "  )\n",
        "  (up5): up(\n",
        "    (conv): Sequential(\n",
-       "      (0): ConvTranspose2d(1024, 512, kernel_size=(4, 4), stride=(2, 2), padding=(1, 1))\n",
-       "      (1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "      (0): ConvTranspose2d(1024, 256, kernel_size=(4, 4), stride=(2, 2), padding=(1, 1))\n",
+       "      (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
        "      (2): ReLU(inplace=True)\n",
        "    )\n",
        "  )\n",
        "  (up6): up(\n",
        "    (conv): Sequential(\n",
-       "      (0): ConvTranspose2d(512, 256, kernel_size=(4, 4), stride=(2, 2), padding=(1, 1))\n",
-       "      (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "      (0): ConvTranspose2d(512, 128, kernel_size=(4, 4), stride=(2, 2), padding=(1, 1))\n",
+       "      (1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
        "      (2): ReLU(inplace=True)\n",
        "    )\n",
        "  )\n",
        "  (up7): up(\n",
        "    (conv): Sequential(\n",
-       "      (0): ConvTranspose2d(256, 128, kernel_size=(4, 4), stride=(2, 2), padding=(1, 1))\n",
-       "      (1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "      (0): ConvTranspose2d(256, 64, kernel_size=(4, 4), stride=(2, 2), padding=(1, 1))\n",
+       "      (1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
        "      (2): ReLU(inplace=True)\n",
        "    )\n",
        "  )\n",
@@ -72658,14 +72670,14 @@
        ")"
       ]
      },
-     "execution_count": 64,
+     "execution_count": 131,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
     "# We take images that have 3 channels (RGB) as input and output an image that also have 3 channels (RGB)\n",
-    "generator=U_Net(3,3)\n",
+    "generator = U_Net(3,3)\n",
     "# Check that the architecture is as expected\n",
     "generator"
    ]
@@ -72702,6 +72714,43 @@
     "\n"
    ]
   },
+  {
+   "cell_type": "code",
+   "execution_count": 132,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Shape of the encoded vector x8: torch.Size([10, 512, 1, 1])\n"
+     ]
+    }
+   ],
+   "source": [
+    "import torch\n",
+    "\n",
+    "# Define a dummy input tensor with the same shape as the input images (256x256)\n",
+    "dummy_input = torch.randn(10, 3, 256, 256)  # Assuming 3 channels for RGB images\n",
+    "\n",
+    "# Instantiate the U-Net model\n",
+    "model = U_Net(n_channels=3, n_classes=10)\n",
+    "\n",
+    "# Pass the dummy input through the encoder\n",
+    "with torch.no_grad():\n",
+    "    x1 = model.inc(dummy_input)\n",
+    "    x2 = model.down1(x1)\n",
+    "    x3 = model.down2(x2)\n",
+    "    x4 = model.down3(x3)\n",
+    "    x5 = model.down4(x4)\n",
+    "    x6 = model.down5(x5)\n",
+    "    x7 = model.down6(x6)\n",
+    "    x8 = model.down7(x7)\n",
+    "\n",
+    "# Print the shape of the encoded vector x8\n",
+    "print(\"Shape of the encoded vector x8:\", x8.shape)\n"
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -72749,7 +72798,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 65,
+   "execution_count": 133,
    "metadata": {
     "colab": {},
     "colab_type": "code",
@@ -72824,7 +72873,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 66,
+   "execution_count": 134,
    "metadata": {
     "colab": {},
     "colab_type": "code",
@@ -72840,7 +72889,7 @@
     "        self.conv1 = conv_block(n_channels, 64, use_batchnorm=False)\n",
     "        self.conv2 = conv_block(64, 128)\n",
     "        self.conv3 = conv_block(128, 256)\n",
-    "        self.conv4 = conv_block(256, 512)\n",
+    "        self.conv4 = conv_block(256, 512, stride=1)\n",
     "        # output layer\n",
     "        self.out = out_block(512, n_classes)\n",
     "        \n",
@@ -72856,7 +72905,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 67,
+   "execution_count": 135,
    "metadata": {
     "colab": {},
     "colab_type": "code",
@@ -72889,7 +72938,7 @@
        "  )\n",
        "  (conv4): conv_block(\n",
        "    (conv): Sequential(\n",
-       "      (0): Conv2d(256, 512, kernel_size=(4, 4), stride=(2, 2), padding=(1, 1))\n",
+       "      (0): Conv2d(256, 512, kernel_size=(4, 4), stride=(1, 1), padding=(1, 1))\n",
        "      (1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
        "      (2): LeakyReLU(negative_slope=0.2, inplace=True)\n",
        "    )\n",
@@ -72903,7 +72952,7 @@
        ")"
       ]
      },
-     "execution_count": 67,
+     "execution_count": 135,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -72943,7 +72992,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 68,
+   "execution_count": 113,
    "metadata": {
     "colab": {},
     "colab_type": "code",
@@ -72971,7 +73020,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 69,
+   "execution_count": 114,
    "metadata": {
     "colab": {},
     "colab_type": "code",
@@ -73007,7 +73056,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 36,
+   "execution_count": 27,
    "metadata": {
     "colab": {},
     "colab_type": "code",
@@ -73021,7 +73070,7 @@
      "traceback": [
       "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
       "\u001b[1;31mFileExistsError\u001b[0m                           Traceback (most recent call last)",
-      "Cell \u001b[1;32mIn[36], line 46\u001b[0m\n\u001b[0;32m     44\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m zipfile\u001b[38;5;241m.\u001b[39mZipFile(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mCMP_facade_DB_base.zip\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mr\u001b[39m\u001b[38;5;124m'\u001b[39m) \u001b[38;5;28;01mas\u001b[39;00m zip_ref:\n\u001b[0;32m     45\u001b[0m     zip_ref\u001b[38;5;241m.\u001b[39mextractall(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m./facades\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m---> 46\u001b[0m     \u001b[43mos\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrename\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43m./facades/base\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43m./facades/train\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[0;32m     48\u001b[0m \u001b[38;5;66;03m# Download ground truth\u001b[39;00m\n\u001b[0;32m     49\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m os\u001b[38;5;241m.\u001b[39mpath\u001b[38;5;241m.\u001b[39mexists(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mCMP_facade_DB_extended.zip\u001b[39m\u001b[38;5;124m\"\u001b[39m):\n",
+      "Cell \u001b[1;32mIn[27], line 46\u001b[0m\n\u001b[0;32m     44\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m zipfile\u001b[38;5;241m.\u001b[39mZipFile(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mCMP_facade_DB_base.zip\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mr\u001b[39m\u001b[38;5;124m'\u001b[39m) \u001b[38;5;28;01mas\u001b[39;00m zip_ref:\n\u001b[0;32m     45\u001b[0m     zip_ref\u001b[38;5;241m.\u001b[39mextractall(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m./facades\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m---> 46\u001b[0m     \u001b[43mos\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrename\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43m./facades/base\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43m./facades/train\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[0;32m     48\u001b[0m \u001b[38;5;66;03m# Download ground truth\u001b[39;00m\n\u001b[0;32m     49\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m os\u001b[38;5;241m.\u001b[39mpath\u001b[38;5;241m.\u001b[39mexists(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mCMP_facade_DB_extended.zip\u001b[39m\u001b[38;5;124m\"\u001b[39m):\n",
       "\u001b[1;31mFileExistsError\u001b[0m: [WinError 183] Impossible de créer un fichier déjà existant: './facades/base' -> './facades/train'"
      ]
     }
@@ -73095,7 +73144,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 59,
+   "execution_count": 14,
    "metadata": {
     "colab": {},
     "colab_type": "code",
@@ -73159,7 +73208,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 38,
+   "execution_count": 15,
    "metadata": {
     "colab": {},
     "colab_type": "code",
@@ -73195,7 +73244,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 39,
+   "execution_count": 16,
    "metadata": {
     "colab": {},
     "colab_type": "code",
@@ -73204,7 +73253,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 2 Axes>"
       ]
@@ -73233,7 +73282,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 70,
+   "execution_count": 136,
    "metadata": {
     "colab": {},
     "colab_type": "code",
@@ -73267,7 +73316,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 71,
+   "execution_count": 137,
    "metadata": {
     "colab": {},
     "colab_type": "code",
@@ -73311,7 +73360,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 72,
+   "execution_count": 139,
    "metadata": {
     "colab": {},
     "colab_type": "code",
@@ -73319,26 +73368,2525 @@
    },
    "outputs": [
     {
-     "ename": "RuntimeError",
-     "evalue": "Given transposed=1, weight of size [1024, 1024, 4, 4], expected input[16, 1536, 2, 2] to have 1024 channels, but got 1536 channels instead",
-     "output_type": "error",
-     "traceback": [
-      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
-      "\u001b[1;31mRuntimeError\u001b[0m                              Traceback (most recent call last)",
-      "Cell \u001b[1;32mIn[72], line 39\u001b[0m\n\u001b[0;32m     34\u001b[0m optimizer_G\u001b[38;5;241m.\u001b[39mzero_grad()\n\u001b[0;32m     36\u001b[0m \u001b[38;5;66;03m# GAN loss\u001b[39;00m\n\u001b[0;32m     37\u001b[0m \u001b[38;5;66;03m# TO DO: Put here your GAN loss\u001b[39;00m\n\u001b[1;32m---> 39\u001b[0m fake_B \u001b[38;5;241m=\u001b[39m \u001b[43mgenerator\u001b[49m\u001b[43m(\u001b[49m\u001b[43mreal_A\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m     40\u001b[0m pred_fake \u001b[38;5;241m=\u001b[39m discriminator(fake_B, real_A)\n\u001b[0;32m     41\u001b[0m gan_loss \u001b[38;5;241m=\u001b[39m criterion_GAN(pred_fake, valid)\n",
-      "File \u001b[1;32mc:\\Users\\oscar\\AppData\\Local\\Programs\\Python\\Python311\\Lib\\site-packages\\torch\\nn\\modules\\module.py:1518\u001b[0m, in \u001b[0;36mModule._wrapped_call_impl\u001b[1;34m(self, *args, **kwargs)\u001b[0m\n\u001b[0;32m   1516\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_compiled_call_impl(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)  \u001b[38;5;66;03m# type: ignore[misc]\u001b[39;00m\n\u001b[0;32m   1517\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m-> 1518\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_call_impl\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n",
-      "File \u001b[1;32mc:\\Users\\oscar\\AppData\\Local\\Programs\\Python\\Python311\\Lib\\site-packages\\torch\\nn\\modules\\module.py:1527\u001b[0m, in \u001b[0;36mModule._call_impl\u001b[1;34m(self, *args, **kwargs)\u001b[0m\n\u001b[0;32m   1522\u001b[0m \u001b[38;5;66;03m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[0;32m   1523\u001b[0m \u001b[38;5;66;03m# this function, and just call forward.\u001b[39;00m\n\u001b[0;32m   1524\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_pre_hooks\n\u001b[0;32m   1525\u001b[0m         \u001b[38;5;129;01mor\u001b[39;00m _global_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_backward_hooks\n\u001b[0;32m   1526\u001b[0m         \u001b[38;5;129;01mor\u001b[39;00m _global_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[1;32m-> 1527\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mforward_call\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m   1529\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m   1530\u001b[0m     result \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n",
-      "Cell \u001b[1;32mIn[63], line 54\u001b[0m, in \u001b[0;36mU_Net.forward\u001b[1;34m(self, x)\u001b[0m\n\u001b[0;32m     52\u001b[0m \u001b[38;5;66;03m# At this stage x8 is our encoded vector, we will now decode it\u001b[39;00m\n\u001b[0;32m     53\u001b[0m x \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mup1(x8, x7)\n\u001b[1;32m---> 54\u001b[0m x \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mup2\u001b[49m\u001b[43m(\u001b[49m\u001b[43mx\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mx6\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m     55\u001b[0m x \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mup3(x, x5)\n\u001b[0;32m     56\u001b[0m x \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mup4(x, x4)\n",
-      "File \u001b[1;32mc:\\Users\\oscar\\AppData\\Local\\Programs\\Python\\Python311\\Lib\\site-packages\\torch\\nn\\modules\\module.py:1518\u001b[0m, in \u001b[0;36mModule._wrapped_call_impl\u001b[1;34m(self, *args, **kwargs)\u001b[0m\n\u001b[0;32m   1516\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_compiled_call_impl(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)  \u001b[38;5;66;03m# type: ignore[misc]\u001b[39;00m\n\u001b[0;32m   1517\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m-> 1518\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_call_impl\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n",
-      "File \u001b[1;32mc:\\Users\\oscar\\AppData\\Local\\Programs\\Python\\Python311\\Lib\\site-packages\\torch\\nn\\modules\\module.py:1527\u001b[0m, in \u001b[0;36mModule._call_impl\u001b[1;34m(self, *args, **kwargs)\u001b[0m\n\u001b[0;32m   1522\u001b[0m \u001b[38;5;66;03m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[0;32m   1523\u001b[0m \u001b[38;5;66;03m# this function, and just call forward.\u001b[39;00m\n\u001b[0;32m   1524\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_pre_hooks\n\u001b[0;32m   1525\u001b[0m         \u001b[38;5;129;01mor\u001b[39;00m _global_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_backward_hooks\n\u001b[0;32m   1526\u001b[0m         \u001b[38;5;129;01mor\u001b[39;00m _global_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[1;32m-> 1527\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mforward_call\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m   1529\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m   1530\u001b[0m     result \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n",
-      "Cell \u001b[1;32mIn[6], line 49\u001b[0m, in \u001b[0;36mup.forward\u001b[1;34m(self, x1, x2)\u001b[0m\n\u001b[0;32m     48\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mforward\u001b[39m(\u001b[38;5;28mself\u001b[39m, x1, x2):\n\u001b[1;32m---> 49\u001b[0m     x1 \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mconv\u001b[49m\u001b[43m(\u001b[49m\u001b[43mx1\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m     50\u001b[0m     x \u001b[38;5;241m=\u001b[39m torch\u001b[38;5;241m.\u001b[39mcat([x1, x2], dim\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m1\u001b[39m)\n\u001b[0;32m     51\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m x\n",
-      "File \u001b[1;32mc:\\Users\\oscar\\AppData\\Local\\Programs\\Python\\Python311\\Lib\\site-packages\\torch\\nn\\modules\\module.py:1518\u001b[0m, in \u001b[0;36mModule._wrapped_call_impl\u001b[1;34m(self, *args, **kwargs)\u001b[0m\n\u001b[0;32m   1516\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_compiled_call_impl(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)  \u001b[38;5;66;03m# type: ignore[misc]\u001b[39;00m\n\u001b[0;32m   1517\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m-> 1518\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_call_impl\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n",
-      "File \u001b[1;32mc:\\Users\\oscar\\AppData\\Local\\Programs\\Python\\Python311\\Lib\\site-packages\\torch\\nn\\modules\\module.py:1527\u001b[0m, in \u001b[0;36mModule._call_impl\u001b[1;34m(self, *args, **kwargs)\u001b[0m\n\u001b[0;32m   1522\u001b[0m \u001b[38;5;66;03m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[0;32m   1523\u001b[0m \u001b[38;5;66;03m# this function, and just call forward.\u001b[39;00m\n\u001b[0;32m   1524\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_pre_hooks\n\u001b[0;32m   1525\u001b[0m         \u001b[38;5;129;01mor\u001b[39;00m _global_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_backward_hooks\n\u001b[0;32m   1526\u001b[0m         \u001b[38;5;129;01mor\u001b[39;00m _global_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[1;32m-> 1527\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mforward_call\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m   1529\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m   1530\u001b[0m     result \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n",
-      "File \u001b[1;32mc:\\Users\\oscar\\AppData\\Local\\Programs\\Python\\Python311\\Lib\\site-packages\\torch\\nn\\modules\\container.py:215\u001b[0m, in \u001b[0;36mSequential.forward\u001b[1;34m(self, input)\u001b[0m\n\u001b[0;32m    213\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mforward\u001b[39m(\u001b[38;5;28mself\u001b[39m, \u001b[38;5;28minput\u001b[39m):\n\u001b[0;32m    214\u001b[0m     \u001b[38;5;28;01mfor\u001b[39;00m module \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mself\u001b[39m:\n\u001b[1;32m--> 215\u001b[0m         \u001b[38;5;28minput\u001b[39m \u001b[38;5;241m=\u001b[39m \u001b[43mmodule\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43minput\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[0;32m    216\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28minput\u001b[39m\n",
-      "File \u001b[1;32mc:\\Users\\oscar\\AppData\\Local\\Programs\\Python\\Python311\\Lib\\site-packages\\torch\\nn\\modules\\module.py:1518\u001b[0m, in \u001b[0;36mModule._wrapped_call_impl\u001b[1;34m(self, *args, **kwargs)\u001b[0m\n\u001b[0;32m   1516\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_compiled_call_impl(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)  \u001b[38;5;66;03m# type: ignore[misc]\u001b[39;00m\n\u001b[0;32m   1517\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m-> 1518\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_call_impl\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n",
-      "File \u001b[1;32mc:\\Users\\oscar\\AppData\\Local\\Programs\\Python\\Python311\\Lib\\site-packages\\torch\\nn\\modules\\module.py:1527\u001b[0m, in \u001b[0;36mModule._call_impl\u001b[1;34m(self, *args, **kwargs)\u001b[0m\n\u001b[0;32m   1522\u001b[0m \u001b[38;5;66;03m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[0;32m   1523\u001b[0m \u001b[38;5;66;03m# this function, and just call forward.\u001b[39;00m\n\u001b[0;32m   1524\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_pre_hooks\n\u001b[0;32m   1525\u001b[0m         \u001b[38;5;129;01mor\u001b[39;00m _global_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_backward_hooks\n\u001b[0;32m   1526\u001b[0m         \u001b[38;5;129;01mor\u001b[39;00m _global_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[1;32m-> 1527\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mforward_call\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m   1529\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m   1530\u001b[0m     result \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n",
-      "File \u001b[1;32mc:\\Users\\oscar\\AppData\\Local\\Programs\\Python\\Python311\\Lib\\site-packages\\torch\\nn\\modules\\conv.py:952\u001b[0m, in \u001b[0;36mConvTranspose2d.forward\u001b[1;34m(self, input, output_size)\u001b[0m\n\u001b[0;32m    947\u001b[0m num_spatial_dims \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m2\u001b[39m\n\u001b[0;32m    948\u001b[0m output_padding \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_output_padding(\n\u001b[0;32m    949\u001b[0m     \u001b[38;5;28minput\u001b[39m, output_size, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mstride, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mpadding, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mkernel_size,  \u001b[38;5;66;03m# type: ignore[arg-type]\u001b[39;00m\n\u001b[0;32m    950\u001b[0m     num_spatial_dims, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mdilation)  \u001b[38;5;66;03m# type: ignore[arg-type]\u001b[39;00m\n\u001b[1;32m--> 952\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mF\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mconv_transpose2d\u001b[49m\u001b[43m(\u001b[49m\n\u001b[0;32m    953\u001b[0m \u001b[43m    \u001b[49m\u001b[38;5;28;43minput\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mweight\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mbias\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mstride\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mpadding\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m    954\u001b[0m \u001b[43m    \u001b[49m\u001b[43moutput_padding\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mgroups\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdilation\u001b[49m\u001b[43m)\u001b[49m\n",
-      "\u001b[1;31mRuntimeError\u001b[0m: Given transposed=1, weight of size [1024, 1024, 4, 4], expected input[16, 1536, 2, 2] to have 1024 channels, but got 1536 channels instead"
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "  0%|          | 0/200 [00:00<?, ?it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [    1/  200] | d_loss: 0.2986 | g_loss: 50.4969\n",
+      "Saving model...\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "  0%|          | 1/200 [03:33<11:49:12, 213.83s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [    2/  200] | d_loss: 0.0690 | g_loss: 31.4658\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "  1%|          | 2/200 [20:27<37:37:56, 684.22s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [    3/  200] | d_loss: 0.0285 | g_loss: 22.6373\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "  2%|▏         | 3/200 [24:06<25:49:37, 471.97s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [    4/  200] | d_loss: 0.0201 | g_loss: 19.7219\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "  2%|▏         | 4/200 [27:48<20:19:36, 373.35s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [    5/  200] | d_loss: 0.0111 | g_loss: 23.0053\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "  2%|▎         | 5/200 [31:31<17:16:47, 319.01s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [    6/  200] | d_loss: 0.0035 | g_loss: 19.1029\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "  3%|▎         | 6/200 [35:15<15:27:01, 286.71s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [    7/  200] | d_loss: 0.0003 | g_loss: 20.1084\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "  4%|▎         | 7/200 [38:54<14:11:21, 264.67s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [    8/  200] | d_loss: 0.0002 | g_loss: 20.1762\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "  4%|▍         | 8/200 [42:37<13:23:38, 251.14s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [    9/  200] | d_loss: 0.0002 | g_loss: 18.8630\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "  4%|▍         | 9/200 [46:22<12:54:06, 243.18s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [   10/  200] | d_loss: 0.0001 | g_loss: 20.4450\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "  5%|▌         | 10/200 [50:05<12:30:30, 237.00s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [   11/  200] | d_loss: 0.0001 | g_loss: 16.7274\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "  6%|▌         | 11/200 [53:48<12:12:15, 232.46s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [   12/  200] | d_loss: 0.0001 | g_loss: 14.5277\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "  6%|▌         | 12/200 [57:32<12:00:36, 229.98s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [   13/  200] | d_loss: 0.0001 | g_loss: 14.1265\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "  6%|▋         | 13/200 [1:01:20<11:55:12, 229.48s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [   14/  200] | d_loss: 0.0002 | g_loss: 14.2537\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "  7%|▋         | 14/200 [1:05:03<11:45:00, 227.42s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [   15/  200] | d_loss: 0.0001 | g_loss: 14.7233\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "  8%|▊         | 15/200 [1:08:50<11:40:36, 227.23s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [   16/  200] | d_loss: 0.0001 | g_loss: 13.0323\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "  8%|▊         | 16/200 [1:12:32<11:32:37, 225.86s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [   17/  200] | d_loss: 0.0001 | g_loss: 16.6378\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "  8%|▊         | 17/200 [1:16:11<11:22:38, 223.82s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [   18/  200] | d_loss: 0.0000 | g_loss: 14.7006\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "  9%|▉         | 18/200 [1:19:57<11:20:41, 224.40s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [   19/  200] | d_loss: 0.0001 | g_loss: 12.7880\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 10%|▉         | 19/200 [1:23:43<11:18:35, 224.95s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [   20/  200] | d_loss: 0.0001 | g_loss: 14.7122\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 10%|█         | 20/200 [1:27:33<11:19:03, 226.35s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [   21/  200] | d_loss: 0.0000 | g_loss: 12.6385\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 10%|█         | 21/200 [1:31:15<11:11:32, 225.10s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [   22/  200] | d_loss: 0.0000 | g_loss: 11.4560\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 11%|█         | 22/200 [1:34:57<11:05:00, 224.16s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [   23/  200] | d_loss: 0.0001 | g_loss: 12.0636\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 12%|█▏        | 23/200 [1:38:41<11:01:20, 224.18s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [   24/  200] | d_loss: 0.0000 | g_loss: 12.3158\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 12%|█▏        | 24/200 [1:42:20<10:52:34, 222.47s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [   25/  200] | d_loss: 0.0000 | g_loss: 12.2917\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 12%|█▎        | 25/200 [1:46:02<10:48:17, 222.27s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [   26/  200] | d_loss: 0.0000 | g_loss: 10.1007\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 13%|█▎        | 26/200 [1:49:44<10:44:42, 222.31s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [   27/  200] | d_loss: 0.0000 | g_loss: 11.8435\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 14%|█▎        | 27/200 [18:15:20<860:04:17, 17897.44s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [   28/  200] | d_loss: 0.0000 | g_loss: 11.0159\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 14%|█▍        | 28/200 [18:18:40<601:25:56, 12588.12s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [   29/  200] | d_loss: 0.0000 | g_loss: 9.6258\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 14%|█▍        | 29/200 [18:20:59<420:31:23, 8853.12s/it] "
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [   30/  200] | d_loss: 0.0000 | g_loss: 9.7476\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 15%|█▌        | 30/200 [18:23:20<294:38:49, 6239.58s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [   31/  200] | d_loss: 0.0000 | g_loss: 9.2101\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 16%|█▌        | 31/200 [18:25:40<207:00:46, 4409.74s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [   32/  200] | d_loss: 0.0000 | g_loss: 8.7221\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 16%|█▌        | 32/200 [18:28:01<146:01:02, 3128.94s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [   33/  200] | d_loss: 0.0000 | g_loss: 9.2836\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 16%|█▋        | 33/200 [18:30:20<103:32:21, 2231.99s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [   34/  200] | d_loss: 0.0000 | g_loss: 10.5826\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 17%|█▋        | 34/200 [18:32:21<73:43:05, 1598.71s/it] "
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [   35/  200] | d_loss: 0.0000 | g_loss: 9.2407\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 18%|█▊        | 35/200 [18:34:22<52:57:25, 1155.43s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [   36/  200] | d_loss: 0.0000 | g_loss: 8.6969\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 18%|█▊        | 36/200 [18:36:25<38:31:06, 845.53s/it] "
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [   37/  200] | d_loss: 0.0000 | g_loss: 8.6362\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 18%|█▊        | 37/200 [18:38:26<28:26:55, 628.31s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [   38/  200] | d_loss: 0.0000 | g_loss: 8.7586\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 19%|█▉        | 38/200 [18:40:47<21:42:05, 482.25s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [   39/  200] | d_loss: 0.0000 | g_loss: 9.7060\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 20%|█▉        | 39/200 [18:43:07<16:58:08, 379.43s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [   40/  200] | d_loss: 0.0000 | g_loss: 7.7811\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 20%|██        | 40/200 [18:45:28<13:40:46, 307.79s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [   41/  200] | d_loss: 0.0001 | g_loss: 8.3558\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 20%|██        | 41/200 [18:47:49<11:22:58, 257.73s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [   42/  200] | d_loss: 0.0000 | g_loss: 8.2741\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 21%|██        | 42/200 [18:49:55<9:35:15, 218.45s/it] "
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [   43/  200] | d_loss: 0.0000 | g_loss: 7.0276\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 22%|██▏       | 43/200 [18:52:13<8:27:59, 194.14s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [   44/  200] | d_loss: 0.0000 | g_loss: 7.5418\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 22%|██▏       | 44/200 [18:54:31<7:41:26, 177.48s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [   45/  200] | d_loss: 0.0000 | g_loss: 6.4280\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 22%|██▎       | 45/200 [18:56:52<7:10:12, 166.53s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [   46/  200] | d_loss: 0.0000 | g_loss: 6.5384\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 23%|██▎       | 46/200 [18:59:13<6:47:33, 158.79s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [   47/  200] | d_loss: 0.0000 | g_loss: 6.7810\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 24%|██▎       | 47/200 [19:01:34<6:31:21, 153.47s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [   48/  200] | d_loss: 0.0000 | g_loss: 7.4198\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 24%|██▍       | 48/200 [19:03:54<6:18:37, 149.46s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [   49/  200] | d_loss: 0.0000 | g_loss: 6.4663\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 24%|██▍       | 49/200 [19:06:14<6:09:10, 146.70s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [   50/  200] | d_loss: 0.0000 | g_loss: 6.6329\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 25%|██▌       | 50/200 [19:08:35<6:02:13, 144.89s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [   51/  200] | d_loss: 0.0000 | g_loss: 6.8283\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 26%|██▌       | 51/200 [19:10:56<5:56:52, 143.71s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [   52/  200] | d_loss: 0.0000 | g_loss: 6.5759\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 26%|██▌       | 52/200 [19:13:18<5:53:31, 143.32s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [   53/  200] | d_loss: 0.0000 | g_loss: 6.9568\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 26%|██▋       | 53/200 [19:15:40<5:49:38, 142.71s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [   54/  200] | d_loss: 0.0000 | g_loss: 6.8343\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 27%|██▋       | 54/200 [19:18:00<5:45:17, 141.90s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [   55/  200] | d_loss: 0.0000 | g_loss: 6.7774\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 28%|██▊       | 55/200 [19:20:20<5:41:48, 141.44s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [   56/  200] | d_loss: 0.0000 | g_loss: 6.5278\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 28%|██▊       | 56/200 [19:22:40<5:38:34, 141.07s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [   57/  200] | d_loss: 0.0000 | g_loss: 7.0898\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 28%|██▊       | 57/200 [19:25:02<5:36:17, 141.10s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [   58/  200] | d_loss: 0.0000 | g_loss: 6.9529\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 29%|██▉       | 58/200 [19:27:21<5:32:58, 140.70s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [   59/  200] | d_loss: 0.0000 | g_loss: 6.6683\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 30%|██▉       | 59/200 [19:29:34<5:24:55, 138.27s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [   60/  200] | d_loss: 0.0000 | g_loss: 5.4720\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 30%|███       | 60/200 [19:31:55<5:24:16, 138.97s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [   61/  200] | d_loss: 0.0000 | g_loss: 5.9517\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 30%|███       | 61/200 [19:34:16<5:23:29, 139.64s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [   62/  200] | d_loss: 0.0000 | g_loss: 5.9189\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 31%|███       | 62/200 [19:36:39<5:23:25, 140.62s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [   63/  200] | d_loss: 0.0000 | g_loss: 6.1456\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 32%|███▏      | 63/200 [19:38:57<5:19:52, 140.09s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [   64/  200] | d_loss: 0.0000 | g_loss: 5.8103\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 32%|███▏      | 64/200 [19:41:17<5:17:28, 140.07s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [   65/  200] | d_loss: 0.0000 | g_loss: 6.6359\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 32%|███▎      | 65/200 [19:43:37<5:14:35, 139.82s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [   66/  200] | d_loss: 0.0000 | g_loss: 5.5419\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 33%|███▎      | 66/200 [19:45:57<5:12:37, 139.98s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [   67/  200] | d_loss: 0.0000 | g_loss: 5.9907\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 34%|███▎      | 67/200 [19:48:16<5:09:48, 139.76s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [   68/  200] | d_loss: 0.0000 | g_loss: 5.4248\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 34%|███▍      | 68/200 [19:50:39<5:09:33, 140.71s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [   69/  200] | d_loss: 0.0000 | g_loss: 5.8507\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 34%|███▍      | 69/200 [19:53:00<5:07:13, 140.72s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [   70/  200] | d_loss: 0.0000 | g_loss: 5.4606\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 35%|███▌      | 70/200 [19:55:20<5:04:39, 140.61s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [   71/  200] | d_loss: 0.0000 | g_loss: 5.5825\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 36%|███▌      | 71/200 [19:57:41<5:02:14, 140.58s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [   72/  200] | d_loss: 0.0000 | g_loss: 5.3806\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 36%|███▌      | 72/200 [20:00:00<4:59:13, 140.26s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [   73/  200] | d_loss: 0.0000 | g_loss: 4.9700\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 36%|███▋      | 73/200 [20:02:21<4:56:58, 140.31s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [   74/  200] | d_loss: 0.0000 | g_loss: 6.0687\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 37%|███▋      | 74/200 [20:04:41<4:54:31, 140.25s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [   75/  200] | d_loss: 0.0000 | g_loss: 6.1108\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 38%|███▊      | 75/200 [20:07:03<4:53:04, 140.68s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [   76/  200] | d_loss: 0.0000 | g_loss: 5.0490\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 38%|███▊      | 76/200 [20:09:20<4:48:33, 139.62s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [   77/  200] | d_loss: 0.0000 | g_loss: 5.2028\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 38%|███▊      | 77/200 [21:57:28<69:50:41, 2044.24s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [   78/  200] | d_loss: 0.0000 | g_loss: 5.0322\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 39%|███▉      | 78/200 [22:01:10<50:44:52, 1497.48s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [   79/  200] | d_loss: 0.0000 | g_loss: 5.1501\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 40%|███▉      | 79/200 [22:04:51<37:28:01, 1114.73s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [   80/  200] | d_loss: 0.0000 | g_loss: 4.8963\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 40%|████      | 80/200 [22:08:23<28:07:34, 843.79s/it] "
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [   81/  200] | d_loss: 0.0000 | g_loss: 5.4176\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 40%|████      | 81/200 [22:11:57<21:38:57, 654.93s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [   82/  200] | d_loss: 0.0000 | g_loss: 4.5689\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 41%|████      | 82/200 [22:15:31<17:07:54, 522.67s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [   83/  200] | d_loss: 0.0000 | g_loss: 4.8715\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 42%|████▏     | 83/200 [22:19:06<13:59:03, 430.29s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [   84/  200] | d_loss: 0.0000 | g_loss: 5.2930\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 42%|████▏     | 84/200 [22:22:38<11:45:00, 364.66s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [   85/  200] | d_loss: 0.0000 | g_loss: 5.2364\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 42%|████▎     | 85/200 [22:26:11<10:12:09, 319.39s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [   86/  200] | d_loss: 0.0000 | g_loss: 4.7926\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 43%|████▎     | 86/200 [22:29:55<9:12:11, 290.63s/it] "
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [   87/  200] | d_loss: 0.0000 | g_loss: 4.9839\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 44%|████▎     | 87/200 [22:33:36<8:28:16, 269.88s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [   88/  200] | d_loss: 0.0000 | g_loss: 4.9801\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 44%|████▍     | 88/200 [22:37:19<7:57:05, 255.58s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [   89/  200] | d_loss: 0.0000 | g_loss: 5.0576\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 44%|████▍     | 89/200 [22:41:00<7:33:50, 245.32s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [   90/  200] | d_loss: 0.0000 | g_loss: 4.6227\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 45%|████▌     | 90/200 [22:44:45<7:18:22, 239.12s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [   91/  200] | d_loss: 0.0000 | g_loss: 4.7586\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 46%|████▌     | 91/200 [22:48:25<7:04:22, 233.60s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [   92/  200] | d_loss: 0.0000 | g_loss: 4.9719\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 46%|████▌     | 92/200 [22:52:09<6:54:57, 230.53s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [   93/  200] | d_loss: 0.0000 | g_loss: 5.1167\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 46%|████▋     | 93/200 [22:55:53<6:47:40, 228.60s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [   94/  200] | d_loss: 0.0000 | g_loss: 4.2460\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 47%|████▋     | 94/200 [22:59:36<6:41:11, 227.09s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [   95/  200] | d_loss: 0.0000 | g_loss: 4.9128\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 48%|████▊     | 95/200 [23:03:19<6:35:19, 225.90s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [   96/  200] | d_loss: 0.0000 | g_loss: 4.9049\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 48%|████▊     | 96/200 [23:07:07<6:32:31, 226.46s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [   97/  200] | d_loss: 0.0000 | g_loss: 4.3853\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 48%|████▊     | 97/200 [23:10:51<6:27:21, 225.64s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [   98/  200] | d_loss: 0.0000 | g_loss: 4.9247\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 49%|████▉     | 98/200 [23:14:32<6:21:20, 224.32s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [   99/  200] | d_loss: 0.0000 | g_loss: 4.1643\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 50%|████▉     | 99/200 [23:18:10<6:14:23, 222.41s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [  100/  200] | d_loss: 0.0000 | g_loss: 4.0455\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 50%|█████     | 100/200 [23:21:51<6:09:44, 221.84s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [  101/  200] | d_loss: 0.0000 | g_loss: 4.3069\n",
+      "Saving model...\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 50%|█████     | 101/200 [23:25:31<6:05:14, 221.36s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [  102/  200] | d_loss: 0.0000 | g_loss: 4.2799\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 51%|█████     | 102/200 [23:29:13<6:02:06, 221.70s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [  103/  200] | d_loss: 0.0000 | g_loss: 3.9489\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 52%|█████▏    | 103/200 [23:32:54<5:58:06, 221.51s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [  104/  200] | d_loss: 0.0000 | g_loss: 4.3795\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 52%|█████▏    | 104/200 [23:36:39<5:56:01, 222.51s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [  105/  200] | d_loss: 0.0000 | g_loss: 4.4014\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 52%|█████▎    | 105/200 [23:40:20<5:51:16, 221.85s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [  106/  200] | d_loss: 0.0000 | g_loss: 4.1926\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 53%|█████▎    | 106/200 [23:44:03<5:48:15, 222.29s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [  107/  200] | d_loss: 0.0000 | g_loss: 4.0495\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 54%|█████▎    | 107/200 [23:47:48<5:45:56, 223.19s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [  108/  200] | d_loss: 0.0000 | g_loss: 4.7681\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 54%|█████▍    | 108/200 [23:51:33<5:42:43, 223.52s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [  109/  200] | d_loss: 0.0000 | g_loss: 3.8948\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 55%|█████▍    | 109/200 [23:55:16<5:38:56, 223.48s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [  110/  200] | d_loss: 0.0000 | g_loss: 4.7230\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 55%|█████▌    | 110/200 [23:58:59<5:35:02, 223.36s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [  111/  200] | d_loss: 0.0000 | g_loss: 4.6830\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 56%|█████▌    | 111/200 [24:02:40<5:30:19, 222.69s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [  112/  200] | d_loss: 0.0000 | g_loss: 4.2850\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 56%|█████▌    | 112/200 [24:06:23<5:26:41, 222.74s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [  113/  200] | d_loss: 0.0000 | g_loss: 3.9515\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 56%|█████▋    | 113/200 [24:10:02<5:21:28, 221.71s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [  114/  200] | d_loss: 0.0000 | g_loss: 4.1073\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 57%|█████▋    | 114/200 [24:13:42<5:16:46, 221.01s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [  115/  200] | d_loss: 0.0000 | g_loss: 4.2522\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 57%|█████▊    | 115/200 [24:17:25<5:14:17, 221.86s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [  116/  200] | d_loss: 0.0000 | g_loss: 4.1719\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 58%|█████▊    | 116/200 [24:21:08<5:10:44, 221.96s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [  117/  200] | d_loss: 0.0000 | g_loss: 4.6002\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 58%|█████▊    | 117/200 [24:24:51<5:07:34, 222.34s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [  118/  200] | d_loss: 0.0000 | g_loss: 4.1806\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 59%|█████▉    | 118/200 [24:28:33<5:03:49, 222.31s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [  119/  200] | d_loss: 0.0000 | g_loss: 3.7083\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 60%|█████▉    | 119/200 [24:31:16<4:35:50, 204.33s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [  120/  200] | d_loss: 0.0000 | g_loss: 4.2531\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 60%|██████    | 120/200 [24:33:33<4:05:44, 184.31s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [  121/  200] | d_loss: 0.0000 | g_loss: 3.7991\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 60%|██████    | 121/200 [24:35:52<3:44:47, 170.73s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [  122/  200] | d_loss: 0.0000 | g_loss: 3.6656\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 61%|██████    | 122/200 [24:38:16<3:31:25, 162.64s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [  123/  200] | d_loss: 0.0000 | g_loss: 4.0438\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 62%|██████▏   | 123/200 [24:40:43<3:22:46, 158.01s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [  124/  200] | d_loss: 0.0000 | g_loss: 3.3249\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 62%|██████▏   | 124/200 [24:43:10<3:16:01, 154.76s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [  125/  200] | d_loss: 0.0000 | g_loss: 3.8801\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 62%|██████▎   | 125/200 [24:45:38<3:10:37, 152.50s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [  126/  200] | d_loss: 0.0000 | g_loss: 4.2041\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 63%|██████▎   | 126/200 [24:48:07<3:06:47, 151.46s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [  127/  200] | d_loss: 0.0000 | g_loss: 3.6246\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 64%|██████▎   | 127/200 [24:50:39<3:04:32, 151.68s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [  128/  200] | d_loss: 0.0000 | g_loss: 4.1748\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 64%|██████▍   | 128/200 [24:53:10<3:01:53, 151.58s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [  129/  200] | d_loss: 0.0000 | g_loss: 4.3447\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 64%|██████▍   | 129/200 [24:55:41<2:58:57, 151.24s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [  130/  200] | d_loss: 0.0000 | g_loss: 3.7430\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 65%|██████▌   | 130/200 [24:58:13<2:57:02, 151.75s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [  131/  200] | d_loss: 0.0000 | g_loss: 4.3410\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 66%|██████▌   | 131/200 [25:00:43<2:53:51, 151.19s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [  132/  200] | d_loss: 0.0000 | g_loss: 3.9258\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 66%|██████▌   | 132/200 [25:03:11<2:49:58, 149.98s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [  133/  200] | d_loss: 0.0000 | g_loss: 3.7315\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 66%|██████▋   | 133/200 [25:05:31<2:44:26, 147.27s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [  134/  200] | d_loss: 0.0000 | g_loss: 3.7290\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 67%|██████▋   | 134/200 [25:08:00<2:42:33, 147.78s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [  135/  200] | d_loss: 0.0000 | g_loss: 3.6787\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 68%|██████▊   | 135/200 [31:43:41<130:27:38, 7225.51s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [  136/  200] | d_loss: 0.0000 | g_loss: 4.1081\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 68%|██████▊   | 136/200 [31:47:23<91:06:02, 5124.42s/it] "
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [  137/  200] | d_loss: 0.0000 | g_loss: 3.7930\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 68%|██████▊   | 137/200 [31:51:04<63:56:16, 3653.59s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [  138/  200] | d_loss: 0.0000 | g_loss: 3.7355\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 69%|██████▉   | 138/200 [31:54:46<45:11:25, 2623.96s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [  139/  200] | d_loss: 0.0000 | g_loss: 3.8581\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 70%|██████▉   | 139/200 [31:58:27<32:14:54, 1903.18s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [  140/  200] | d_loss: 0.0000 | g_loss: 3.5164\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 70%|███████   | 140/200 [32:02:08<23:18:26, 1398.44s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [  141/  200] | d_loss: 0.0000 | g_loss: 4.2167\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 70%|███████   | 141/200 [32:05:49<17:07:57, 1045.38s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [  142/  200] | d_loss: 0.0000 | g_loss: 4.1710\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 71%|███████   | 142/200 [32:09:35<12:52:47, 799.43s/it] "
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [  143/  200] | d_loss: 0.0000 | g_loss: 3.4353\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 72%|███████▏  | 143/200 [32:13:16<9:54:37, 625.92s/it] "
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [  144/  200] | d_loss: 0.0000 | g_loss: 4.1769\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 72%|███████▏  | 144/200 [32:16:57<7:50:57, 504.59s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [  145/  200] | d_loss: 0.0000 | g_loss: 3.4113\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 72%|███████▎  | 145/200 [32:20:44<6:26:01, 421.13s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [  146/  200] | d_loss: 0.0000 | g_loss: 3.6495\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 73%|███████▎  | 146/200 [32:24:27<5:25:31, 361.70s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [  147/  200] | d_loss: 0.0000 | g_loss: 3.8438\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 74%|███████▎  | 147/200 [32:28:08<4:42:12, 319.49s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [  148/  200] | d_loss: 0.0000 | g_loss: 3.4885\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 74%|███████▍  | 148/200 [32:31:47<4:10:54, 289.50s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [  149/  200] | d_loss: 0.0000 | g_loss: 3.9255\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 74%|███████▍  | 149/200 [32:35:32<3:49:32, 270.06s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [  150/  200] | d_loss: 0.0000 | g_loss: 3.7591\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 75%|███████▌  | 150/200 [32:39:17<3:33:51, 256.62s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [  151/  200] | d_loss: 0.0000 | g_loss: 3.5302\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 76%|███████▌  | 151/200 [32:43:01<3:21:33, 246.81s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [  152/  200] | d_loss: 0.0000 | g_loss: 3.8970\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 76%|███████▌  | 152/200 [32:46:43<3:11:26, 239.30s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [  153/  200] | d_loss: 0.0000 | g_loss: 3.3882\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 76%|███████▋  | 153/200 [32:50:24<3:03:13, 233.91s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [  154/  200] | d_loss: 0.0000 | g_loss: 3.7872\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 77%|███████▋  | 154/200 [32:54:06<2:56:36, 230.35s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [  155/  200] | d_loss: 0.0000 | g_loss: 3.3681\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 78%|███████▊  | 155/200 [32:57:48<2:50:50, 227.78s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [  156/  200] | d_loss: 0.0000 | g_loss: 3.4925\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 78%|███████▊  | 156/200 [33:01:30<2:45:50, 226.14s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [  157/  200] | d_loss: 0.0000 | g_loss: 3.4799\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 78%|███████▊  | 157/200 [33:05:12<2:41:06, 224.79s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [  158/  200] | d_loss: 0.0000 | g_loss: 3.8227\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 79%|███████▉  | 158/200 [33:08:53<2:36:37, 223.75s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [  159/  200] | d_loss: 0.0000 | g_loss: 3.6413\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 80%|███████▉  | 159/200 [46:04:14<160:43:42, 14112.75s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [  160/  200] | d_loss: 0.0000 | g_loss: 3.4391\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 80%|████████  | 160/200 [46:06:31<110:13:16, 9919.92s/it] "
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [  161/  200] | d_loss: 0.0000 | g_loss: 4.0419\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 80%|████████  | 161/200 [46:08:46<75:40:00, 6984.62s/it] "
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [  162/  200] | d_loss: 0.0000 | g_loss: 3.2419\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 81%|████████  | 162/200 [46:11:03<52:02:31, 4930.29s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [  163/  200] | d_loss: 0.0000 | g_loss: 3.6212\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 82%|████████▏ | 163/200 [46:13:21<35:53:50, 3492.72s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [  164/  200] | d_loss: 0.0000 | g_loss: 3.5620\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 82%|████████▏ | 164/200 [46:15:40<24:51:57, 2486.60s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [  165/  200] | d_loss: 0.0000 | g_loss: 3.2860\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 82%|████████▎ | 165/200 [46:17:48<17:17:45, 1779.01s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [  166/  200] | d_loss: 0.0000 | g_loss: 3.4613\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 83%|████████▎ | 166/200 [46:19:53<12:06:57, 1282.86s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [  167/  200] | d_loss: 0.0000 | g_loss: 2.8703\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 84%|████████▎ | 167/200 [46:22:02<8:35:02, 936.42s/it]  "
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [  168/  200] | d_loss: 0.0000 | g_loss: 3.4632\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 84%|████████▍ | 168/200 [46:24:05<6:09:23, 692.62s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [  169/  200] | d_loss: 0.0000 | g_loss: 3.3067\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 84%|████████▍ | 169/200 [46:26:24<4:31:57, 526.36s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [  170/  200] | d_loss: 0.0000 | g_loss: 3.2975\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 85%|████████▌ | 170/200 [46:28:42<3:24:56, 409.90s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [  171/  200] | d_loss: 0.0000 | g_loss: 3.8963\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 86%|████████▌ | 171/200 [46:31:00<2:38:39, 328.25s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [  172/  200] | d_loss: 0.0000 | g_loss: 3.3173\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 86%|████████▌ | 172/200 [46:33:20<2:06:52, 271.89s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [  173/  200] | d_loss: 0.0000 | g_loss: 3.0768\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 86%|████████▋ | 173/200 [46:35:39<1:44:26, 232.09s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [  174/  200] | d_loss: 0.0000 | g_loss: 2.9947\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 87%|████████▋ | 174/200 [46:37:58<1:28:25, 204.06s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [  175/  200] | d_loss: 0.0000 | g_loss: 3.3563\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 88%|████████▊ | 175/200 [46:40:16<1:16:47, 184.30s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [  176/  200] | d_loss: 0.0000 | g_loss: 3.6079\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 88%|████████▊ | 176/200 [46:42:34<1:08:12, 170.52s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [  177/  200] | d_loss: 0.0000 | g_loss: 3.3227\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 88%|████████▊ | 177/200 [46:44:53<1:01:40, 160.89s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [  178/  200] | d_loss: 0.0000 | g_loss: 3.7596\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 89%|████████▉ | 178/200 [46:47:12<56:33, 154.25s/it]  "
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [  179/  200] | d_loss: 0.0000 | g_loss: 3.5614\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " 90%|████████▉ | 179/200 [46:49:30<52:18, 149.48s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [  180/  200] | d_loss: 0.0000 | g_loss: 3.1136\n"
      ]
     }
    ],
@@ -73361,7 +75909,7 @@
     "generator.train()\n",
     "print_every = 400\n",
     "\n",
-    "for epoch in range(epoch_G, num_epochs):\n",
+    "for epoch in tqdm(range(epoch_G, num_epochs)):\n",
     "    for i, batch in enumerate(dataloader):\n",
     "\n",
     "        # Model inputs\n",
@@ -73382,8 +75930,12 @@
     "        # TO DO: Put here your GAN loss\n",
     "        \n",
     "        fake_B = generator(real_A)\n",
-    "        pred_fake = discriminator(fake_B, real_A)\n",
-    "        gan_loss = criterion_GAN(pred_fake, valid)\n",
+    "        # print(\"real_A shape\", real_A.shape)\n",
+    "        # print(\"fake_B shape\", fake_B.shape)\n",
+    "        pred_fake = discriminator(fake_B.detach(), real_A)\n",
+    "        # print(\"pred_fake shape\", pred_fake.detach().shape)\n",
+    "        # print(\"valid shape\", valid.shape)\n",
+    "        gan_loss = criterion_GAN(pred_fake.detach(), valid)\n",
     "\n",
     "        # Pixel-wise loss\n",
     "        # TO DO: Put here your pixel loss\n",
@@ -73410,7 +75962,7 @@
     "        loss_real = criterion_GAN(pred_real, valid)\n",
     "\n",
     "        # Fake loss\n",
-    "        pred_fake = discriminator(fake_A.detach(), real_B)\n",
+    "        pred_fake = discriminator(fake_B.detach(), real_B)\n",
     "        loss_fake = criterion_GAN(pred_fake, fake)\n",
     "\n",
     "        # Total loss\n",