diff --git a/notebooks/02-rainnet.ipynb b/notebooks/02-rainnet.ipynb
new file mode 100644
index 0000000..e47f6f9
--- /dev/null
+++ b/notebooks/02-rainnet.ipynb
@@ -0,0 +1,1379 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/javascript": [
+       "\n",
+       "            setTimeout(function() {\n",
+       "                var nbb_cell_id = 2;\n",
+       "                var nbb_unformatted_code = \"%reload_ext autoreload\\n%autoreload 2\\n%reload_ext nb_black\";\n",
+       "                var nbb_formatted_code = \"%reload_ext autoreload\\n%autoreload 2\\n%reload_ext nb_black\";\n",
+       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
+       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
+       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
+       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
+       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
+       "                        }\n",
+       "                        break;\n",
+       "                    }\n",
+       "                }\n",
+       "            }, 500);\n",
+       "            "
+      ],
+      "text/plain": [
+       "<IPython.core.display.Javascript object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "%reload_ext autoreload\n",
+    "%autoreload 2\n",
+    "%reload_ext nb_black"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/javascript": [
+       "\n",
+       "            setTimeout(function() {\n",
+       "                var nbb_cell_id = 3;\n",
+       "                var nbb_unformatted_code = \"from pathlib import Path\\nfrom concurrent.futures import ThreadPoolExecutor\\nfrom tqdm.notebook import tqdm\\n\\nimport cv2\\nimport numpy as np\\nimport pandas as pd\\nimport matplotlib.pyplot as plt\\n\\nimport torch\\nimport torch.nn as nn\\nimport torch.nn.functional as F\\nimport pytorch_lightning as pl\";\n",
+       "                var nbb_formatted_code = \"from pathlib import Path\\nfrom concurrent.futures import ThreadPoolExecutor\\nfrom tqdm.notebook import tqdm\\n\\nimport cv2\\nimport numpy as np\\nimport pandas as pd\\nimport matplotlib.pyplot as plt\\n\\nimport torch\\nimport torch.nn as nn\\nimport torch.nn.functional as F\\nimport pytorch_lightning as pl\";\n",
+       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
+       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
+       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
+       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
+       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
+       "                        }\n",
+       "                        break;\n",
+       "                    }\n",
+       "                }\n",
+       "            }, 500);\n",
+       "            "
+      ],
+      "text/plain": [
+       "<IPython.core.display.Javascript object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "from pathlib import Path\n",
+    "from concurrent.futures import ThreadPoolExecutor\n",
+    "from tqdm.notebook import tqdm\n",
+    "\n",
+    "import cv2\n",
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "import torch\n",
+    "import torch.nn as nn\n",
+    "import torch.nn.functional as F\n",
+    "import pytorch_lightning as pl"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/javascript": [
+       "\n",
+       "            setTimeout(function() {\n",
+       "                var nbb_cell_id = 4;\n",
+       "                var nbb_unformatted_code = \"PATH = Path(\\\"../input\\\")\";\n",
+       "                var nbb_formatted_code = \"PATH = Path(\\\"../input\\\")\";\n",
+       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
+       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
+       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
+       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
+       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
+       "                        }\n",
+       "                        break;\n",
+       "                    }\n",
+       "                }\n",
+       "            }, 500);\n",
+       "            "
+      ],
+      "text/plain": [
+       "<IPython.core.display.Javascript object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "PATH = Path(\"../input\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# RainNet ⚡️"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "heading_collapsed": true
+   },
+   "source": [
+    "## Utils"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "hidden": true
+   },
+   "outputs": [],
+   "source": [
+    "def visualize(x, y=None, test=False):\n",
+    "    cmap = plt.cm.get_cmap(\"RdBu\")\n",
+    "    cmap = cmap.reversed()\n",
+    "    if test:\n",
+    "        fig, axes = plt.subplots(1, 4, figsize=(10, 10))\n",
+    "        for i, ax in enumerate(axes):\n",
+    "            img = x[:, :, i]\n",
+    "            ax.imshow(img, cmap=cmap)\n",
+    "    else:\n",
+    "        fig, axes = plt.subplots(1, 5, figsize=(10, 10))\n",
+    "        for i, ax in enumerate(axes[:-1]):\n",
+    "            img = x[:, :, i]\n",
+    "            ax.imshow(img, cmap=cmap)\n",
+    "        axes[-1].imshow(y[:, :, 0], cmap=cmap)\n",
+    "    #     plt.tight_layout()\n",
+    "    plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "heading_collapsed": true
+   },
+   "source": [
+    "## Resize data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {
+    "hidden": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "application/javascript": [
+       "\n",
+       "            setTimeout(function() {\n",
+       "                var nbb_cell_id = 5;\n",
+       "                var nbb_unformatted_code = \"(PATH / \\\"train-128\\\").mkdir(exist_ok=True)\";\n",
+       "                var nbb_formatted_code = \"(PATH / \\\"train-128\\\").mkdir(exist_ok=True)\";\n",
+       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
+       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
+       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
+       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
+       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
+       "                        }\n",
+       "                        break;\n",
+       "                    }\n",
+       "                }\n",
+       "            }, 500);\n",
+       "            "
+      ],
+      "text/plain": [
+       "<IPython.core.display.Javascript object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "(PATH / \"train-128\").mkdir(exist_ok=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {
+    "hidden": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "application/javascript": [
+       "\n",
+       "            setTimeout(function() {\n",
+       "                var nbb_cell_id = 21;\n",
+       "                var nbb_unformatted_code = \"def resize_data(path):\\n    data = np.load(path)\\n    img1 = data[:, :, :3]\\n    img2 = data[:, :, 2:]\\n    img1 = cv2.copyMakeBorder(img1, 4, 4, 4, 4, cv2.BORDER_REFLECT)\\n    img2 = cv2.copyMakeBorder(img2, 4, 4, 4, 4, cv2.BORDER_REFLECT)\\n    img2 = img2[:, :, 1:]\\n    data = np.concatenate([img1, img2], axis=-1)\\n    np.save(PATH / \\\"train-128\\\" / path.name, data)\\n    \\nfiles = list((PATH / \\\"train\\\").glob(\\\"*.npy\\\"))\\nwith ThreadPoolExecutor(8) as e: e.map(resize_data, files)\";\n",
+       "                var nbb_formatted_code = \"def resize_data(path):\\n    data = np.load(path)\\n    img1 = data[:, :, :3]\\n    img2 = data[:, :, 2:]\\n    img1 = cv2.copyMakeBorder(img1, 4, 4, 4, 4, cv2.BORDER_REFLECT)\\n    img2 = cv2.copyMakeBorder(img2, 4, 4, 4, 4, cv2.BORDER_REFLECT)\\n    img2 = img2[:, :, 1:]\\n    data = np.concatenate([img1, img2], axis=-1)\\n    np.save(PATH / \\\"train-128\\\" / path.name, data)\\n\\n\\nfiles = list((PATH / \\\"train\\\").glob(\\\"*.npy\\\"))\\nwith ThreadPoolExecutor(8) as e:\\n    e.map(resize_data, files)\";\n",
+       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
+       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
+       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
+       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
+       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
+       "                        }\n",
+       "                        break;\n",
+       "                    }\n",
+       "                }\n",
+       "            }, 500);\n",
+       "            "
+      ],
+      "text/plain": [
+       "<IPython.core.display.Javascript object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "def resize_data(path):\n",
+    "    data = np.load(path)\n",
+    "    img1 = data[:, :, :3]\n",
+    "    img2 = data[:, :, 2:]\n",
+    "    img1 = cv2.copyMakeBorder(img1, 4, 4, 4, 4, cv2.BORDER_REFLECT)\n",
+    "    img2 = cv2.copyMakeBorder(img2, 4, 4, 4, 4, cv2.BORDER_REFLECT)\n",
+    "    img2 = img2[:, :, 1:]\n",
+    "    data = np.concatenate([img1, img2], axis=-1)\n",
+    "    np.save(PATH / \"train-128\" / path.name, data)\n",
+    "\n",
+    "\n",
+    "files = list((PATH / \"train\").glob(\"*.npy\"))\n",
+    "with ThreadPoolExecutor(8) as e:\n",
+    "    e.map(resize_data, files)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Dataset"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/javascript": [
+       "\n",
+       "            setTimeout(function() {\n",
+       "                var nbb_cell_id = 5;\n",
+       "                var nbb_unformatted_code = \"class NowcastingDataset(torch.utils.data.Dataset):\\n    def __init__(self, paths, test=False):\\n        self.paths = paths\\n        self.test = test\\n\\n    def __len__(self):\\n        return len(self.paths)\\n\\n    def __getitem__(self, idx):\\n        path = self.paths[idx]\\n        data = np.load(path)\\n        x = data[:, :, :4]\\n        x = x / 255.0\\n        x = x.astype(np.float32)\\n        x = torch.tensor(x, dtype=torch.float)\\n        x = x.permute(2, 0, 1)\\n        if self.test:\\n            return x\\n        else:\\n            y = data[:, :, 4]\\n            y = y / 255.0\\n            y = y.astype(np.float32)\\n            y = torch.tensor(y, dtype=torch.float)\\n            y = y.unsqueeze(-1)\\n            y = y.permute(2, 0, 1)\\n\\n            return x, y\";\n",
+       "                var nbb_formatted_code = \"class NowcastingDataset(torch.utils.data.Dataset):\\n    def __init__(self, paths, test=False):\\n        self.paths = paths\\n        self.test = test\\n\\n    def __len__(self):\\n        return len(self.paths)\\n\\n    def __getitem__(self, idx):\\n        path = self.paths[idx]\\n        data = np.load(path)\\n        x = data[:, :, :4]\\n        x = x / 255.0\\n        x = x.astype(np.float32)\\n        x = torch.tensor(x, dtype=torch.float)\\n        x = x.permute(2, 0, 1)\\n        if self.test:\\n            return x\\n        else:\\n            y = data[:, :, 4]\\n            y = y / 255.0\\n            y = y.astype(np.float32)\\n            y = torch.tensor(y, dtype=torch.float)\\n            y = y.unsqueeze(-1)\\n            y = y.permute(2, 0, 1)\\n\\n            return x, y\";\n",
+       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
+       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
+       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
+       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
+       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
+       "                        }\n",
+       "                        break;\n",
+       "                    }\n",
+       "                }\n",
+       "            }, 500);\n",
+       "            "
+      ],
+      "text/plain": [
+       "<IPython.core.display.Javascript object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "class NowcastingDataset(torch.utils.data.Dataset):\n",
+    "    def __init__(self, paths, test=False):\n",
+    "        self.paths = paths\n",
+    "        self.test = test\n",
+    "\n",
+    "    def __len__(self):\n",
+    "        return len(self.paths)\n",
+    "\n",
+    "    def __getitem__(self, idx):\n",
+    "        path = self.paths[idx]\n",
+    "        data = np.load(path)\n",
+    "        x = data[:, :, :4]\n",
+    "        x = x / 255.0\n",
+    "        x = x.astype(np.float32)\n",
+    "        x = torch.tensor(x, dtype=torch.float)\n",
+    "        x = x.permute(2, 0, 1)\n",
+    "        if self.test:\n",
+    "            return x\n",
+    "        else:\n",
+    "            y = data[:, :, 4]\n",
+    "            y = y / 255.0\n",
+    "            y = y.astype(np.float32)\n",
+    "            y = torch.tensor(y, dtype=torch.float)\n",
+    "            y = y.unsqueeze(-1)\n",
+    "            y = y.permute(2, 0, 1)\n",
+    "\n",
+    "            return x, y"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 720x720 with 5 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/javascript": [
+       "\n",
+       "            setTimeout(function() {\n",
+       "                var nbb_cell_id = 6;\n",
+       "                var nbb_unformatted_code = \"files = list((PATH / \\\"train-128\\\").glob(\\\"*.npy\\\"))\\ndataset = NowcastingDataset(files)\\nx, y = dataset[42]\\nx = x.permute(1, 2, 0).numpy()\\ny = y.permute(1, 2, 0).numpy()\\nvisualize(x, y)\";\n",
+       "                var nbb_formatted_code = \"files = list((PATH / \\\"train-128\\\").glob(\\\"*.npy\\\"))\\ndataset = NowcastingDataset(files)\\nx, y = dataset[42]\\nx = x.permute(1, 2, 0).numpy()\\ny = y.permute(1, 2, 0).numpy()\\nvisualize(x, y)\";\n",
+       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
+       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
+       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
+       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
+       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
+       "                        }\n",
+       "                        break;\n",
+       "                    }\n",
+       "                }\n",
+       "            }, 500);\n",
+       "            "
+      ],
+      "text/plain": [
+       "<IPython.core.display.Javascript object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "files = list((PATH / \"train-128\").glob(\"*.npy\"))\n",
+    "dataset = NowcastingDataset(files)\n",
+    "x, y = dataset[42]\n",
+    "x = x.permute(1, 2, 0).numpy()\n",
+    "y = y.permute(1, 2, 0).numpy()\n",
+    "visualize(x, y)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/javascript": [
+       "\n",
+       "            setTimeout(function() {\n",
+       "                var nbb_cell_id = 6;\n",
+       "                var nbb_unformatted_code = \"class NowcastingDataModule(pl.LightningDataModule):\\n    def __init__(self, df, fold, batch_size, test=False, num_workers=4):\\n        super().__init__()\\n        self.df = df\\n        self.fold = fold\\n        self.test = test\\n        self.batch_size = batch_size\\n        self.num_workers = 4\\n\\n    def setup(self, stage=\\\"train\\\"):\\n        if stage == \\\"train\\\":\\n            train_df = self.df[self.df.fold != self.fold]\\n            val_df = self.df[self.df.fold == self.fold]\\n            train_paths = [PATH / \\\"train-128\\\" / fn for fn in train_df.filename.values]\\n            val_paths = [PATH / \\\"train-128\\\" / fn for fn in val_df.filename.values]\\n            self.train_dataset = NowcastingDataset(train_paths)\\n            self.val_dataset = NowcastingDataset(val_paths)\\n        else:\\n            test_paths = list((PATH / \\\"test\\\").glob(\\\"*.npy\\\"))\\n            self.test_dataset = NowcastingDataset(test_paths, test=True)\\n\\n    def train_dataloader(self):\\n        return torch.utils.data.DataLoader(\\n            self.train_dataset,\\n            batch_size=self.batch_size,\\n            shuffle=True,\\n            pin_memory=True,\\n            num_workers=self.num_workers,\\n        )\\n\\n    def val_dataloader(self):\\n        return torch.utils.data.DataLoader(\\n            self.val_dataset,\\n            batch_size=2 * self.batch_size,\\n            pin_memory=True,\\n            num_workers=self.num_workers,\\n        )\\n\\n    def test_dataloader(self):\\n        return torch.utils.data.DataLoader(\\n            self.test_dataset,\\n            batch_size=2 * self.batch_size,\\n            pin_memory=True,\\n            num_workers=self.num_workers,\\n        )\";\n",
+       "                var nbb_formatted_code = \"class NowcastingDataModule(pl.LightningDataModule):\\n    def __init__(self, df, fold, batch_size, test=False, num_workers=4):\\n        super().__init__()\\n        self.df = df\\n        self.fold = fold\\n        self.test = test\\n        self.batch_size = batch_size\\n        self.num_workers = 4\\n\\n    def setup(self, stage=\\\"train\\\"):\\n        if stage == \\\"train\\\":\\n            train_df = self.df[self.df.fold != self.fold]\\n            val_df = self.df[self.df.fold == self.fold]\\n            train_paths = [PATH / \\\"train-128\\\" / fn for fn in train_df.filename.values]\\n            val_paths = [PATH / \\\"train-128\\\" / fn for fn in val_df.filename.values]\\n            self.train_dataset = NowcastingDataset(train_paths)\\n            self.val_dataset = NowcastingDataset(val_paths)\\n        else:\\n            test_paths = list((PATH / \\\"test\\\").glob(\\\"*.npy\\\"))\\n            self.test_dataset = NowcastingDataset(test_paths, test=True)\\n\\n    def train_dataloader(self):\\n        return torch.utils.data.DataLoader(\\n            self.train_dataset,\\n            batch_size=self.batch_size,\\n            shuffle=True,\\n            pin_memory=True,\\n            num_workers=self.num_workers,\\n        )\\n\\n    def val_dataloader(self):\\n        return torch.utils.data.DataLoader(\\n            self.val_dataset,\\n            batch_size=2 * self.batch_size,\\n            pin_memory=True,\\n            num_workers=self.num_workers,\\n        )\\n\\n    def test_dataloader(self):\\n        return torch.utils.data.DataLoader(\\n            self.test_dataset,\\n            batch_size=2 * self.batch_size,\\n            pin_memory=True,\\n            num_workers=self.num_workers,\\n        )\";\n",
+       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
+       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
+       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
+       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
+       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
+       "                        }\n",
+       "                        break;\n",
+       "                    }\n",
+       "                }\n",
+       "            }, 500);\n",
+       "            "
+      ],
+      "text/plain": [
+       "<IPython.core.display.Javascript object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "class NowcastingDataModule(pl.LightningDataModule):\n",
+    "    def __init__(self, df, fold, batch_size, test=False, num_workers=4):\n",
+    "        super().__init__()\n",
+    "        self.df = df\n",
+    "        self.fold = fold\n",
+    "        self.test = test\n",
+    "        self.batch_size = batch_size\n",
+    "        self.num_workers = 4\n",
+    "\n",
+    "    def setup(self, stage=\"train\"):\n",
+    "        if stage == \"train\":\n",
+    "            train_df = self.df[self.df.fold != self.fold]\n",
+    "            val_df = self.df[self.df.fold == self.fold]\n",
+    "            train_paths = [PATH / \"train-128\" / fn for fn in train_df.filename.values]\n",
+    "            val_paths = [PATH / \"train-128\" / fn for fn in val_df.filename.values]\n",
+    "            self.train_dataset = NowcastingDataset(train_paths)\n",
+    "            self.val_dataset = NowcastingDataset(val_paths)\n",
+    "        else:\n",
+    "            test_paths = list((PATH / \"test\").glob(\"*.npy\"))\n",
+    "            self.test_dataset = NowcastingDataset(test_paths, test=True)\n",
+    "\n",
+    "    def train_dataloader(self):\n",
+    "        return torch.utils.data.DataLoader(\n",
+    "            self.train_dataset,\n",
+    "            batch_size=self.batch_size,\n",
+    "            shuffle=True,\n",
+    "            pin_memory=True,\n",
+    "            num_workers=self.num_workers,\n",
+    "        )\n",
+    "\n",
+    "    def val_dataloader(self):\n",
+    "        return torch.utils.data.DataLoader(\n",
+    "            self.val_dataset,\n",
+    "            batch_size=2 * self.batch_size,\n",
+    "            pin_memory=True,\n",
+    "            num_workers=self.num_workers,\n",
+    "        )\n",
+    "\n",
+    "    def test_dataloader(self):\n",
+    "        return torch.utils.data.DataLoader(\n",
+    "            self.test_dataset,\n",
+    "            batch_size=2 * self.batch_size,\n",
+    "            pin_memory=True,\n",
+    "            num_workers=self.num_workers,\n",
+    "        )"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 720x720 with 5 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/javascript": [
+       "\n",
+       "            setTimeout(function() {\n",
+       "                var nbb_cell_id = 25;\n",
+       "                var nbb_unformatted_code = \"df = pd.read_csv(PATH / \\\"train_folds.csv\\\")\\ndm = NowcastingDataModule(df, fold=0, batch_size=32)\\ndm.setup()\\nfor batch in dm.train_dataloader():\\n    xs, ys = batch\\n    x, y = xs[0], ys[0]\\n    x = x.permute(1, 2, 0).numpy()\\n    y = y.permute(1, 2, 0).numpy()\\n    visualize(x, y)\\n    break\";\n",
+       "                var nbb_formatted_code = \"df = pd.read_csv(PATH / \\\"train_folds.csv\\\")\\ndm = NowcastingDataModule(df, fold=0, batch_size=32)\\ndm.setup()\\nfor batch in dm.train_dataloader():\\n    xs, ys = batch\\n    x, y = xs[0], ys[0]\\n    x = x.permute(1, 2, 0).numpy()\\n    y = y.permute(1, 2, 0).numpy()\\n    visualize(x, y)\\n    break\";\n",
+       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
+       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
+       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
+       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
+       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
+       "                        }\n",
+       "                        break;\n",
+       "                    }\n",
+       "                }\n",
+       "            }, 500);\n",
+       "            "
+      ],
+      "text/plain": [
+       "<IPython.core.display.Javascript object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "df = pd.read_csv(PATH / \"train_folds.csv\")\n",
+    "dm = NowcastingDataModule(df, fold=0, batch_size=32)\n",
+    "dm.setup()\n",
+    "for batch in dm.train_dataloader():\n",
+    "    xs, ys = batch\n",
+    "    x, y = xs[0], ys[0]\n",
+    "    x = x.permute(1, 2, 0).numpy()\n",
+    "    y = y.permute(1, 2, 0).numpy()\n",
+    "    visualize(x, y)\n",
+    "    break"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Model"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### RainNet"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/javascript": [
+       "\n",
+       "            setTimeout(function() {\n",
+       "                var nbb_cell_id = 18;\n",
+       "                var nbb_unformatted_code = \"class Block(nn.Module):\\n    def __init__(self, in_ch, out_ch, bn=True):\\n        super().__init__()\\n        if bn:\\n            self.net = nn.Sequential(\\n                nn.Conv2d(in_ch, out_ch, kernel_size=3, padding=1, bias=False),\\n                nn.BatchNorm2d(out_ch),\\n                nn.ReLU(inplace=True),\\n                nn.Conv2d(out_ch, out_ch, kernel_size=3, padding=1, bias=False),\\n                nn.BatchNorm2d(out_ch),\\n                nn.ReLU(inplace=True),\\n            )\\n        else:\\n            self.net = nn.Sequential(\\n                nn.Conv2d(in_ch, out_ch, kernel_size=3, padding=1),\\n                nn.ReLU(inplace=True),\\n                nn.Conv2d(out_ch, out_ch, kernel_size=3, padding=1),\\n                nn.ReLU(inplace=True),\\n            )\\n\\n    def forward(self, x):\\n        return self.net(x)\";\n",
+       "                var nbb_formatted_code = \"class Block(nn.Module):\\n    def __init__(self, in_ch, out_ch, bn=True):\\n        super().__init__()\\n        if bn:\\n            self.net = nn.Sequential(\\n                nn.Conv2d(in_ch, out_ch, kernel_size=3, padding=1, bias=False),\\n                nn.BatchNorm2d(out_ch),\\n                nn.ReLU(inplace=True),\\n                nn.Conv2d(out_ch, out_ch, kernel_size=3, padding=1, bias=False),\\n                nn.BatchNorm2d(out_ch),\\n                nn.ReLU(inplace=True),\\n            )\\n        else:\\n            self.net = nn.Sequential(\\n                nn.Conv2d(in_ch, out_ch, kernel_size=3, padding=1),\\n                nn.ReLU(inplace=True),\\n                nn.Conv2d(out_ch, out_ch, kernel_size=3, padding=1),\\n                nn.ReLU(inplace=True),\\n            )\\n\\n    def forward(self, x):\\n        return self.net(x)\";\n",
+       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
+       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
+       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
+       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
+       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
+       "                        }\n",
+       "                        break;\n",
+       "                    }\n",
+       "                }\n",
+       "            }, 500);\n",
+       "            "
+      ],
+      "text/plain": [
+       "<IPython.core.display.Javascript object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "class Block(nn.Module):\n",
+    "    def __init__(self, in_ch, out_ch, bn=True):\n",
+    "        super().__init__()\n",
+    "        if bn:\n",
+    "            self.net = nn.Sequential(\n",
+    "                nn.Conv2d(in_ch, out_ch, kernel_size=3, padding=1, bias=False),\n",
+    "                nn.BatchNorm2d(out_ch),\n",
+    "                nn.ReLU(inplace=True),\n",
+    "                nn.Conv2d(out_ch, out_ch, kernel_size=3, padding=1, bias=False),\n",
+    "                nn.BatchNorm2d(out_ch),\n",
+    "                nn.ReLU(inplace=True),\n",
+    "            )\n",
+    "        else:\n",
+    "            self.net = nn.Sequential(\n",
+    "                nn.Conv2d(in_ch, out_ch, kernel_size=3, padding=1),\n",
+    "                nn.ReLU(inplace=True),\n",
+    "                nn.Conv2d(out_ch, out_ch, kernel_size=3, padding=1),\n",
+    "                nn.ReLU(inplace=True),\n",
+    "            )\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "        return self.net(x)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/javascript": [
+       "\n",
+       "            setTimeout(function() {\n",
+       "                var nbb_cell_id = 19;\n",
+       "                var nbb_unformatted_code = \"class Encoder(nn.Module):\\n    def __init__(self, chs=[4, 64, 128, 256, 512, 1024], bn=True):\\n        super().__init__()\\n        self.blocks = nn.ModuleList(\\n            [Block(chs[i], chs[i + 1], bn=bn) for i in range(len(chs) - 1)]\\n        )\\n        self.pool = nn.MaxPool2d(kernel_size=2, stride=2)\\n\\n    def forward(self, x):\\n        ftrs = []\\n        for block in self.blocks:\\n            x = block(x)\\n            ftrs.append(x)\\n            x = self.pool(x)\\n        return ftrs\";\n",
+       "                var nbb_formatted_code = \"class Encoder(nn.Module):\\n    def __init__(self, chs=[4, 64, 128, 256, 512, 1024], bn=True):\\n        super().__init__()\\n        self.blocks = nn.ModuleList(\\n            [Block(chs[i], chs[i + 1], bn=bn) for i in range(len(chs) - 1)]\\n        )\\n        self.pool = nn.MaxPool2d(kernel_size=2, stride=2)\\n\\n    def forward(self, x):\\n        ftrs = []\\n        for block in self.blocks:\\n            x = block(x)\\n            ftrs.append(x)\\n            x = self.pool(x)\\n        return ftrs\";\n",
+       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
+       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
+       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
+       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
+       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
+       "                        }\n",
+       "                        break;\n",
+       "                    }\n",
+       "                }\n",
+       "            }, 500);\n",
+       "            "
+      ],
+      "text/plain": [
+       "<IPython.core.display.Javascript object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "class Encoder(nn.Module):\n",
+    "    def __init__(self, chs=[4, 64, 128, 256, 512, 1024], bn=True):\n",
+    "        super().__init__()\n",
+    "        self.blocks = nn.ModuleList(\n",
+    "            [Block(chs[i], chs[i + 1], bn=bn) for i in range(len(chs) - 1)]\n",
+    "        )\n",
+    "        self.pool = nn.MaxPool2d(kernel_size=2, stride=2)\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "        ftrs = []\n",
+    "        for block in self.blocks:\n",
+    "            x = block(x)\n",
+    "            ftrs.append(x)\n",
+    "            x = self.pool(x)\n",
+    "        return ftrs"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/javascript": [
+       "\n",
+       "            setTimeout(function() {\n",
+       "                var nbb_cell_id = 20;\n",
+       "                var nbb_unformatted_code = \"class Decoder(nn.Module):\\n    def __init__(self, chs=[1024, 512, 256, 128, 64], bn=True):\\n        super().__init__()\\n        self.chs = chs\\n        self.tr_convs = nn.ModuleList(\\n            [\\n                nn.ConvTranspose2d(chs[i], chs[i], kernel_size=2, stride=2)\\n                for i in range(len(chs) - 1)\\n            ]\\n        )\\n        self.convs = nn.ModuleList(\\n            [Block(chs[i] + chs[i + 1], chs[i + 1], bn=bn) for i in range(len(chs) - 1)]\\n        )\\n\\n    def forward(self, x, ftrs):\\n        for i in range(len(self.chs) - 1):\\n            x = self.tr_convs[i](x)\\n            ftr = ftrs[i]\\n            x = torch.cat([ftr, x], dim=1)\\n            x = self.convs[i](x)\\n        return x\";\n",
+       "                var nbb_formatted_code = \"class Decoder(nn.Module):\\n    def __init__(self, chs=[1024, 512, 256, 128, 64], bn=True):\\n        super().__init__()\\n        self.chs = chs\\n        self.tr_convs = nn.ModuleList(\\n            [\\n                nn.ConvTranspose2d(chs[i], chs[i], kernel_size=2, stride=2)\\n                for i in range(len(chs) - 1)\\n            ]\\n        )\\n        self.convs = nn.ModuleList(\\n            [Block(chs[i] + chs[i + 1], chs[i + 1], bn=bn) for i in range(len(chs) - 1)]\\n        )\\n\\n    def forward(self, x, ftrs):\\n        for i in range(len(self.chs) - 1):\\n            x = self.tr_convs[i](x)\\n            ftr = ftrs[i]\\n            x = torch.cat([ftr, x], dim=1)\\n            x = self.convs[i](x)\\n        return x\";\n",
+       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
+       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
+       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
+       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
+       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
+       "                        }\n",
+       "                        break;\n",
+       "                    }\n",
+       "                }\n",
+       "            }, 500);\n",
+       "            "
+      ],
+      "text/plain": [
+       "<IPython.core.display.Javascript object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "class Decoder(nn.Module):\n",
+    "    def __init__(self, chs=[1024, 512, 256, 128, 64], bn=True):\n",
+    "        super().__init__()\n",
+    "        self.chs = chs\n",
+    "        self.tr_convs = nn.ModuleList(\n",
+    "            [\n",
+    "                nn.ConvTranspose2d(chs[i], chs[i], kernel_size=2, stride=2)\n",
+    "                for i in range(len(chs) - 1)\n",
+    "            ]\n",
+    "        )\n",
+    "        self.convs = nn.ModuleList(\n",
+    "            [Block(chs[i] + chs[i + 1], chs[i + 1], bn=bn) for i in range(len(chs) - 1)]\n",
+    "        )\n",
+    "\n",
+    "    def forward(self, x, ftrs):\n",
+    "        for i in range(len(self.chs) - 1):\n",
+    "            x = self.tr_convs[i](x)\n",
+    "            ftr = ftrs[i]\n",
+    "            x = torch.cat([ftr, x], dim=1)\n",
+    "            x = self.convs[i](x)\n",
+    "        return x"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "torch.Size([3, 512, 16, 16])\n",
+      "torch.Size([3, 256, 32, 32])\n",
+      "torch.Size([3, 128, 64, 64])\n",
+      "torch.Size([3, 64, 128, 128])\n"
+     ]
+    },
+    {
+     "data": {
+      "application/javascript": [
+       "\n",
+       "            setTimeout(function() {\n",
+       "                var nbb_cell_id = 21;\n",
+       "                var nbb_unformatted_code = \"for ftr in ftrs[::-1][1:]:\\n    print(ftr.shape)\";\n",
+       "                var nbb_formatted_code = \"for ftr in ftrs[::-1][1:]:\\n    print(ftr.shape)\";\n",
+       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
+       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
+       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
+       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
+       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
+       "                        }\n",
+       "                        break;\n",
+       "                    }\n",
+       "                }\n",
+       "            }, 500);\n",
+       "            "
+      ],
+      "text/plain": [
+       "<IPython.core.display.Javascript object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "for ftr in ftrs[::-1][1:]:\n",
+    "    print(ftr.shape)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "torch.Size([3, 64, 128, 128])"
+      ]
+     },
+     "execution_count": 22,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "application/javascript": [
+       "\n",
+       "            setTimeout(function() {\n",
+       "                var nbb_cell_id = 22;\n",
+       "                var nbb_unformatted_code = \"dec = Decoder()\\nx = torch.randn(3, 1024, 8, 8)\\ndec(x, ftrs=ftrs[::-1][1:]).shape\";\n",
+       "                var nbb_formatted_code = \"dec = Decoder()\\nx = torch.randn(3, 1024, 8, 8)\\ndec(x, ftrs=ftrs[::-1][1:]).shape\";\n",
+       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
+       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
+       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
+       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
+       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
+       "                        }\n",
+       "                        break;\n",
+       "                    }\n",
+       "                }\n",
+       "            }, 500);\n",
+       "            "
+      ],
+      "text/plain": [
+       "<IPython.core.display.Javascript object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "dec = Decoder()\n",
+    "x = torch.randn(3, 1024, 8, 8)\n",
+    "dec(x, ftrs=ftrs[::-1][1:]).shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/javascript": [
+       "\n",
+       "            setTimeout(function() {\n",
+       "                var nbb_cell_id = 23;\n",
+       "                var nbb_unformatted_code = \"class LogCoshLoss(torch.nn.Module):\\n    def __init__(self):\\n        super().__init__()\\n\\n    def forward(self, inp, targ, epsilon=1e-12):\\n        e = inp - targ\\n        return torch.mean(torch.log(torch.cosh(e + episilon)))\";\n",
+       "                var nbb_formatted_code = \"class LogCoshLoss(torch.nn.Module):\\n    def __init__(self):\\n        super().__init__()\\n\\n    def forward(self, inp, targ, epsilon=1e-12):\\n        e = inp - targ\\n        return torch.mean(torch.log(torch.cosh(e + episilon)))\";\n",
+       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
+       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
+       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
+       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
+       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
+       "                        }\n",
+       "                        break;\n",
+       "                    }\n",
+       "                }\n",
+       "            }, 500);\n",
+       "            "
+      ],
+      "text/plain": [
+       "<IPython.core.display.Javascript object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "class LogCoshLoss(torch.nn.Module):\n",
+    "    def __init__(self):\n",
+    "        super().__init__()\n",
+    "\n",
+    "    def forward(self, inp, targ, epsilon=1e-12):\n",
+    "        e = inp - targ\n",
+    "        return torch.mean(torch.log(torch.cosh(e + episilon)))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/javascript": [
+       "\n",
+       "            setTimeout(function() {\n",
+       "                var nbb_cell_id = 24;\n",
+       "                var nbb_unformatted_code = \"class RainNet(pl.LightningModule):\\n    def __init__(\\n        self,\\n        lr=1e-4,\\n        bn=True,\\n        enc_chs=[4, 64, 128, 256, 512, 1024],\\n        dec_chs=[1024, 512, 256, 128, 64],\\n    ):\\n        super().__init__()\\n        self.save_hyperparameters()\\n        self.criterion = LogCoshLoss()\\n        self.encoder = Encoder(enc_chs, bn=bn)\\n        self.decoder = Decoder(dec_chs, bn=bn)\\n        if bn:\\n            self.out = nn.Sequential(\\n                nn.Conv2d(64, 2, kernel_size=3, bias=False, padding=1),\\n                nn.BatchNorm2d(2),\\n                nn.ReLU(inplace=True),\\n                nn.Conv2d(2, 1, kernel_size=1, bias=False),\\n                nn.BatchNorm2d(1),\\n                nn.ReLU(inplace=True),\\n            )\\n        else:\\n            self.out = nn.Sequential(\\n                nn.Conv2d(64, 2, kernel_size=3, bias=False, padding=1),\\n                nn.ReLU(inplace=True),\\n                nn.Conv2d(2, 1, kernel_size=1, bias=False),\\n                nn.ReLU(inplace=True),\\n            )\\n\\n    def forward(self, x):\\n        ftrs = self.encoder(x)\\n        ftrs = list(reversed(ftrs))\\n        x = self.decoder(ftrs[0], ftrs[1:])\\n        out = self.out(x)\\n        return out\\n\\n    def training_step(self, batch, batch_idx):\\n        loss = self._shared_step()\\n        self.log(\\\"train_loss\\\", loss)\\n        return loss\\n\\n    def validation_step(self, batch, batch_idx):\\n        loss = self._shared_step(batch, batch_idx)\\n        self.log(\\\"val_loss\\\", loss)\\n\\n    def _shared_step(self, batch, batch_idx):\\n        x, y = batch\\n        y_hat = self(x)\\n        loss = self.criterion(y_hat, y)\\n        return loss\\n\\n    def configure_optimizers(self):\\n        optimizer = torch.optim.Adam(self.paramters(), lr=self.hparams.lr)\\n        return optimizer\";\n",
+       "                var nbb_formatted_code = \"class RainNet(pl.LightningModule):\\n    def __init__(\\n        self,\\n        lr=1e-4,\\n        bn=True,\\n        enc_chs=[4, 64, 128, 256, 512, 1024],\\n        dec_chs=[1024, 512, 256, 128, 64],\\n    ):\\n        super().__init__()\\n        self.save_hyperparameters()\\n        self.criterion = LogCoshLoss()\\n        self.encoder = Encoder(enc_chs, bn=bn)\\n        self.decoder = Decoder(dec_chs, bn=bn)\\n        if bn:\\n            self.out = nn.Sequential(\\n                nn.Conv2d(64, 2, kernel_size=3, bias=False, padding=1),\\n                nn.BatchNorm2d(2),\\n                nn.ReLU(inplace=True),\\n                nn.Conv2d(2, 1, kernel_size=1, bias=False),\\n                nn.BatchNorm2d(1),\\n                nn.ReLU(inplace=True),\\n            )\\n        else:\\n            self.out = nn.Sequential(\\n                nn.Conv2d(64, 2, kernel_size=3, bias=False, padding=1),\\n                nn.ReLU(inplace=True),\\n                nn.Conv2d(2, 1, kernel_size=1, bias=False),\\n                nn.ReLU(inplace=True),\\n            )\\n\\n    def forward(self, x):\\n        ftrs = self.encoder(x)\\n        ftrs = list(reversed(ftrs))\\n        x = self.decoder(ftrs[0], ftrs[1:])\\n        out = self.out(x)\\n        return out\\n\\n    def training_step(self, batch, batch_idx):\\n        loss = self._shared_step()\\n        self.log(\\\"train_loss\\\", loss)\\n        return loss\\n\\n    def validation_step(self, batch, batch_idx):\\n        loss = self._shared_step(batch, batch_idx)\\n        self.log(\\\"val_loss\\\", loss)\\n\\n    def _shared_step(self, batch, batch_idx):\\n        x, y = batch\\n        y_hat = self(x)\\n        loss = self.criterion(y_hat, y)\\n        return loss\\n\\n    def configure_optimizers(self):\\n        optimizer = torch.optim.Adam(self.paramters(), lr=self.hparams.lr)\\n        return optimizer\";\n",
+       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
+       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
+       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
+       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
+       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
+       "                        }\n",
+       "                        break;\n",
+       "                    }\n",
+       "                }\n",
+       "            }, 500);\n",
+       "            "
+      ],
+      "text/plain": [
+       "<IPython.core.display.Javascript object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "class RainNet(pl.LightningModule):\n",
+    "    def __init__(\n",
+    "        self,\n",
+    "        lr=1e-4,\n",
+    "        bn=True,\n",
+    "        enc_chs=[4, 64, 128, 256, 512, 1024],\n",
+    "        dec_chs=[1024, 512, 256, 128, 64],\n",
+    "    ):\n",
+    "        super().__init__()\n",
+    "        self.save_hyperparameters()\n",
+    "        self.criterion = LogCoshLoss()\n",
+    "        self.encoder = Encoder(enc_chs, bn=bn)\n",
+    "        self.decoder = Decoder(dec_chs, bn=bn)\n",
+    "        if bn:\n",
+    "            self.out = nn.Sequential(\n",
+    "                nn.Conv2d(64, 2, kernel_size=3, bias=False, padding=1),\n",
+    "                nn.BatchNorm2d(2),\n",
+    "                nn.ReLU(inplace=True),\n",
+    "                nn.Conv2d(2, 1, kernel_size=1, bias=False),\n",
+    "                nn.BatchNorm2d(1),\n",
+    "                nn.ReLU(inplace=True),\n",
+    "            )\n",
+    "        else:\n",
+    "            self.out = nn.Sequential(\n",
+    "                nn.Conv2d(64, 2, kernel_size=3, bias=False, padding=1),\n",
+    "                nn.ReLU(inplace=True),\n",
+    "                nn.Conv2d(2, 1, kernel_size=1, bias=False),\n",
+    "                nn.ReLU(inplace=True),\n",
+    "            )\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "        ftrs = self.encoder(x)\n",
+    "        ftrs = list(reversed(ftrs))\n",
+    "        x = self.decoder(ftrs[0], ftrs[1:])\n",
+    "        out = self.out(x)\n",
+    "        return out\n",
+    "\n",
+    "    def training_step(self, batch, batch_idx):\n",
+    "        loss = self._shared_step()\n",
+    "        self.log(\"train_loss\", loss)\n",
+    "        return loss\n",
+    "\n",
+    "    def validation_step(self, batch, batch_idx):\n",
+    "        loss = self._shared_step(batch, batch_idx)\n",
+    "        self.log(\"val_loss\", loss)\n",
+    "\n",
+    "    def _shared_step(self, batch, batch_idx):\n",
+    "        x, y = batch\n",
+    "        y_hat = self(x)\n",
+    "        loss = self.criterion(y_hat, y)\n",
+    "        return loss\n",
+    "\n",
+    "    def configure_optimizers(self):\n",
+    "        optimizer = torch.optim.Adam(self.paramters(), lr=self.hparams.lr)\n",
+    "        return optimizer"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "torch.Size([3, 1, 128, 128])"
+      ]
+     },
+     "execution_count": 25,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "application/javascript": [
+       "\n",
+       "            setTimeout(function() {\n",
+       "                var nbb_cell_id = 25;\n",
+       "                var nbb_unformatted_code = \"model = RainNet()\\nx = torch.randn(3, 4, 128, 128)\\nmodel(x).shape\";\n",
+       "                var nbb_formatted_code = \"model = RainNet()\\nx = torch.randn(3, 4, 128, 128)\\nmodel(x).shape\";\n",
+       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
+       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
+       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
+       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
+       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
+       "                        }\n",
+       "                        break;\n",
+       "                    }\n",
+       "                }\n",
+       "            }, 500);\n",
+       "            "
+      ],
+      "text/plain": [
+       "<IPython.core.display.Javascript object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "model = RainNet()\n",
+    "x = torch.randn(3, 4, 128, 128)\n",
+    "model(x).shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {
+    "code_folding": [
+     99
+    ]
+   },
+   "outputs": [
+    {
+     "data": {
+      "application/javascript": [
+       "\n",
+       "            setTimeout(function() {\n",
+       "                var nbb_cell_id = 18;\n",
+       "                var nbb_unformatted_code = \"class RainNet(pl.LightningModule):\\n    def __init__(self, lr: float = 1e-4):\\n        super().__init__()\\n        self.lr = lr\\n        self.criterion = LogCoshLoss()\\n        \\n        # Layers\\n        self.pool = nn.MaxPool2d(kernel_size=2, stride=2)\\n        \\n        # Encoder layers\\n        self.down1 = nn.Sequential(\\n            nn.Conv2d(4, 64, kernel_size=3, bias=False, padding=1),\\n            nn.BatchNorm2d(64),\\n            nn.ReLU(inplace=True),\\n            nn.Conv2d(64, 64, kernel_size=3, bias=False, padding=1),\\n            nn.ReLU(inplace=True),\\n            nn.BatchNorm2d(64),\\n        )\\n        self.down2 = nn.Sequential(\\n            nn.Conv2d(64, 128, kernel_size=3, bias=False, padding=1),\\n            nn.BatchNorm2d(128),\\n            nn.ReLU(inplace=True),\\n            nn.Conv2d(128, 128, kernel_size=3, bias=False, padding=1),\\n            nn.BatchNorm2d(128),\\n            nn.ReLU(inplace=True),\\n        )\\n        self.down3 = nn.Sequential(\\n            nn.Conv2d(128, 256, kernel_size=3, bias=False, padding=1),\\n            nn.BatchNorm2d(256),\\n            nn.ReLU(inplace=True),\\n            nn.Conv2d(256, 256, kernel_size=3, bias=False, padding=1),\\n            nn.BatchNorm2d(256),\\n            nn.ReLU(inplace=True),\\n        )\\n        self.down4 = nn.Sequential(\\n            nn.Conv2d(256, 512, kernel_size=3, bias=False, padding=1),\\n            nn.BatchNorm2d(512),\\n            nn.ReLU(inplace=True),\\n            nn.Conv2d(512, 512, kernel_size=3, bias=False, padding=1),\\n            nn.BatchNorm2d(512),\\n            nn.ReLU(inplace=True),\\n            nn.Dropout2d(p=0.5),\\n        )\\n        self.down5 = nn.Sequential(\\n            nn.Conv2d(512, 1024, kernel_size=3, bias=False, padding=1),\\n            nn.BatchNorm2d(1024),\\n            nn.ReLU(inplace=True),\\n            nn.Conv2d(1024, 1024, kernel_size=3, bias=False, padding=1),\\n            nn.BatchNorm2d(1024),\\n            nn.ReLU(inplace=True),\\n            nn.Dropout2d(p=0.5),\\n        )\\n\\n        # Decoder layers\\n        self.upsample6 = nn.ConvTranspose2d(1024, 1024, kernel_size=2, stride=2)\\n        self.uconv6 = nn.Sequential(\\n            nn.Conv2d(1024 + 512, 512, kernel_size=3, bias=False, padding=1),\\n            nn.BatchNorm2d(512),\\n            nn.ReLU(inplace=True),\\n            nn.Conv2d(512, 512, kernel_size=3, bias=False, padding=1),\\n            nn.BatchNorm2d(512),\\n            nn.ReLU(inplace=True),\\n        )\\n        self.upsample7 = nn.ConvTranspose2d(512, 512, kernel_size=2, stride=2)\\n        self.uconv7 = nn.Sequential(\\n            nn.Conv2d(512 + 256, 256, kernel_size=3, bias=False, padding=1),\\n            nn.BatchNorm2d(256),\\n            nn.ReLU(inplace=True),\\n            nn.Conv2d(256, 256, kernel_size=3, bias=False, padding=1),\\n            nn.BatchNorm2d(256),\\n            nn.ReLU(inplace=True),\\n        )\\n        self.upsample8 = nn.ConvTranspose2d(256, 256, kernel_size=2, stride=2)\\n        self.uconv8 = nn.Sequential(\\n            nn.Conv2d(256 + 128, 128, kernel_size=3, bias=False, padding=1),\\n            nn.BatchNorm2d(128),\\n            nn.ReLU(inplace=True),\\n            nn.Conv2d(128, 128, kernel_size=3, bias=False, padding=1),\\n            nn.BatchNorm2d(128),\\n            nn.ReLU(inplace=True),\\n        )\\n        self.upsample9 = nn.ConvTranspose2d(128, 128, kernel_size=2, stride=2)\\n        self.uconv9 = nn.Sequential(\\n            nn.Conv2d(128 + 64, 64, kernel_size=3, bias=False, padding=1),\\n            nn.BatchNorm2d(64),\\n            nn.ReLU(inplace=True),\\n            nn.Conv2d(64, 64, kernel_size=3, bias=False, padding=1),\\n            nn.BatchNorm2d(64),\\n            nn.ReLU(inplace=True),\\n        )\\n        self.out = nn.Sequential(\\n            nn.Conv2d(64, 2, kernel_size=3, bias=False, padding=1),\\n            nn.BatchNorm2d(2),\\n            nn.ReLU(inplace=True),\\n            nn.Conv2d(2, 1, kernel_size=1, bias=False),\\n            nn.BatchNorm2d(1),\\n            nn.ReLU(inplace=True),\\n        )\\n\\n    def forward(self, x):\\n        conv1 = self.down1(x)\\n        pool1 = self.pool(conv1)\\n\\n        conv2 = self.down2(pool1)\\n        pool2 = self.pool(conv2)\\n\\n        conv3 = self.down3(pool2)\\n        pool3 = self.pool(conv3)\\n\\n        conv4 = self.down4(pool3)\\n        pool4 = self.pool(conv4)\\n\\n        conv5 = self.down5(pool4)\\n\\n        up6 = self.upsample6(conv5)\\n        up6 = torch.cat([up6, conv4], dim=1)\\n        conv6 = self.uconv6(up6)\\n\\n        up7 = self.upsample7(conv6)\\n        up7 = torch.cat([up7, conv3], dim=1)\\n        conv7 = self.uconv7(up7)\\n\\n        up8 = self.upsample8(conv7)\\n        up8 = torch.cat([up8, conv2], dim=1)\\n        conv8 = self.uconv8(up8)\\n\\n        up9 = self.upsample9(conv8)\\n        up9 = torch.cat([up9, conv1], dim=1)\\n        conv9 = self.uconv9(up9)\\n\\n        out = self.out(conv9)\\n\\n        return out\\n    \\n    def training_step(self, batch, batch_idx):\\n        loss = self.shared_step()\\n        self.log(\\\"train_loss\\\", loss)\\n        return loss\\n        \\n    def validation_step(self, batch, batch_idx):\\n        loss = self.shared_step(batch, batch_idx)\\n        self.log(\\\"val_loss\\\", loss)\\n    \\n    def shared_step(self, batch, batch_idx):\\n        x, y = batch\\n        y_hat = self(x)\\n        loss = self.criterion(y_hat, y)\\n        return loss\\n\\n    def configure_optimizers(self):\\n        optimizer = torch.optim.Adam(self.paramters(), lr=self.lr)\\n        return optimizer\";\n",
+       "                var nbb_formatted_code = \"class RainNet(pl.LightningModule):\\n    def __init__(self, lr: float = 1e-4):\\n        super().__init__()\\n        self.lr = lr\\n        self.criterion = LogCoshLoss()\\n\\n        # Layers\\n        self.pool = nn.MaxPool2d(kernel_size=2, stride=2)\\n\\n        # Encoder layers\\n        self.down1 = nn.Sequential(\\n            nn.Conv2d(4, 64, kernel_size=3, bias=False, padding=1),\\n            nn.BatchNorm2d(64),\\n            nn.ReLU(inplace=True),\\n            nn.Conv2d(64, 64, kernel_size=3, bias=False, padding=1),\\n            nn.ReLU(inplace=True),\\n            nn.BatchNorm2d(64),\\n        )\\n        self.down2 = nn.Sequential(\\n            nn.Conv2d(64, 128, kernel_size=3, bias=False, padding=1),\\n            nn.BatchNorm2d(128),\\n            nn.ReLU(inplace=True),\\n            nn.Conv2d(128, 128, kernel_size=3, bias=False, padding=1),\\n            nn.BatchNorm2d(128),\\n            nn.ReLU(inplace=True),\\n        )\\n        self.down3 = nn.Sequential(\\n            nn.Conv2d(128, 256, kernel_size=3, bias=False, padding=1),\\n            nn.BatchNorm2d(256),\\n            nn.ReLU(inplace=True),\\n            nn.Conv2d(256, 256, kernel_size=3, bias=False, padding=1),\\n            nn.BatchNorm2d(256),\\n            nn.ReLU(inplace=True),\\n        )\\n        self.down4 = nn.Sequential(\\n            nn.Conv2d(256, 512, kernel_size=3, bias=False, padding=1),\\n            nn.BatchNorm2d(512),\\n            nn.ReLU(inplace=True),\\n            nn.Conv2d(512, 512, kernel_size=3, bias=False, padding=1),\\n            nn.BatchNorm2d(512),\\n            nn.ReLU(inplace=True),\\n            nn.Dropout2d(p=0.5),\\n        )\\n        self.down5 = nn.Sequential(\\n            nn.Conv2d(512, 1024, kernel_size=3, bias=False, padding=1),\\n            nn.BatchNorm2d(1024),\\n            nn.ReLU(inplace=True),\\n            nn.Conv2d(1024, 1024, kernel_size=3, bias=False, padding=1),\\n            nn.BatchNorm2d(1024),\\n            nn.ReLU(inplace=True),\\n            nn.Dropout2d(p=0.5),\\n        )\\n\\n        # Decoder layers\\n        self.upsample6 = nn.ConvTranspose2d(1024, 1024, kernel_size=2, stride=2)\\n        self.uconv6 = nn.Sequential(\\n            nn.Conv2d(1024 + 512, 512, kernel_size=3, bias=False, padding=1),\\n            nn.BatchNorm2d(512),\\n            nn.ReLU(inplace=True),\\n            nn.Conv2d(512, 512, kernel_size=3, bias=False, padding=1),\\n            nn.BatchNorm2d(512),\\n            nn.ReLU(inplace=True),\\n        )\\n        self.upsample7 = nn.ConvTranspose2d(512, 512, kernel_size=2, stride=2)\\n        self.uconv7 = nn.Sequential(\\n            nn.Conv2d(512 + 256, 256, kernel_size=3, bias=False, padding=1),\\n            nn.BatchNorm2d(256),\\n            nn.ReLU(inplace=True),\\n            nn.Conv2d(256, 256, kernel_size=3, bias=False, padding=1),\\n            nn.BatchNorm2d(256),\\n            nn.ReLU(inplace=True),\\n        )\\n        self.upsample8 = nn.ConvTranspose2d(256, 256, kernel_size=2, stride=2)\\n        self.uconv8 = nn.Sequential(\\n            nn.Conv2d(256 + 128, 128, kernel_size=3, bias=False, padding=1),\\n            nn.BatchNorm2d(128),\\n            nn.ReLU(inplace=True),\\n            nn.Conv2d(128, 128, kernel_size=3, bias=False, padding=1),\\n            nn.BatchNorm2d(128),\\n            nn.ReLU(inplace=True),\\n        )\\n        self.upsample9 = nn.ConvTranspose2d(128, 128, kernel_size=2, stride=2)\\n        self.uconv9 = nn.Sequential(\\n            nn.Conv2d(128 + 64, 64, kernel_size=3, bias=False, padding=1),\\n            nn.BatchNorm2d(64),\\n            nn.ReLU(inplace=True),\\n            nn.Conv2d(64, 64, kernel_size=3, bias=False, padding=1),\\n            nn.BatchNorm2d(64),\\n            nn.ReLU(inplace=True),\\n        )\\n        self.out = nn.Sequential(\\n            nn.Conv2d(64, 2, kernel_size=3, bias=False, padding=1),\\n            nn.BatchNorm2d(2),\\n            nn.ReLU(inplace=True),\\n            nn.Conv2d(2, 1, kernel_size=1, bias=False),\\n            nn.BatchNorm2d(1),\\n            nn.ReLU(inplace=True),\\n        )\\n\\n    def forward(self, x):\\n        conv1 = self.down1(x)\\n        pool1 = self.pool(conv1)\\n\\n        conv2 = self.down2(pool1)\\n        pool2 = self.pool(conv2)\\n\\n        conv3 = self.down3(pool2)\\n        pool3 = self.pool(conv3)\\n\\n        conv4 = self.down4(pool3)\\n        pool4 = self.pool(conv4)\\n\\n        conv5 = self.down5(pool4)\\n\\n        up6 = self.upsample6(conv5)\\n        up6 = torch.cat([up6, conv4], dim=1)\\n        conv6 = self.uconv6(up6)\\n\\n        up7 = self.upsample7(conv6)\\n        up7 = torch.cat([up7, conv3], dim=1)\\n        conv7 = self.uconv7(up7)\\n\\n        up8 = self.upsample8(conv7)\\n        up8 = torch.cat([up8, conv2], dim=1)\\n        conv8 = self.uconv8(up8)\\n\\n        up9 = self.upsample9(conv8)\\n        up9 = torch.cat([up9, conv1], dim=1)\\n        conv9 = self.uconv9(up9)\\n\\n        out = self.out(conv9)\\n\\n        return out\\n\\n    def training_step(self, batch, batch_idx):\\n        loss = self.shared_step()\\n        self.log(\\\"train_loss\\\", loss)\\n        return loss\\n\\n    def validation_step(self, batch, batch_idx):\\n        loss = self.shared_step(batch, batch_idx)\\n        self.log(\\\"val_loss\\\", loss)\\n\\n    def shared_step(self, batch, batch_idx):\\n        x, y = batch\\n        y_hat = self(x)\\n        loss = self.criterion(y_hat, y)\\n        return loss\\n\\n    def configure_optimizers(self):\\n        optimizer = torch.optim.Adam(self.paramters(), lr=self.lr)\\n        return optimizer\";\n",
+       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
+       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
+       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
+       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
+       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
+       "                        }\n",
+       "                        break;\n",
+       "                    }\n",
+       "                }\n",
+       "            }, 500);\n",
+       "            "
+      ],
+      "text/plain": [
+       "<IPython.core.display.Javascript object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "class RainNet(pl.LightningModule):\n",
+    "    def __init__(self, lr: float = 1e-4):\n",
+    "        super().__init__()\n",
+    "        self.save_hyperparameters()\n",
+    "        \n",
+    "        self.criterion = LogCoshLoss()\n",
+    "\n",
+    "        # Layers\n",
+    "        self.pool = nn.MaxPool2d(kernel_size=2, stride=2)\n",
+    "\n",
+    "        # Encoder layers\n",
+    "        self.down1 = nn.Sequential(\n",
+    "            nn.Conv2d(4, 64, kernel_size=3, bias=False, padding=1),\n",
+    "            nn.BatchNorm2d(64),\n",
+    "            nn.ReLU(inplace=True),\n",
+    "            nn.Conv2d(64, 64, kernel_size=3, bias=False, padding=1),\n",
+    "            nn.ReLU(inplace=True),\n",
+    "            nn.BatchNorm2d(64),\n",
+    "        )\n",
+    "        self.down2 = nn.Sequential(\n",
+    "            nn.Conv2d(64, 128, kernel_size=3, bias=False, padding=1),\n",
+    "            nn.BatchNorm2d(128),\n",
+    "            nn.ReLU(inplace=True),\n",
+    "            nn.Conv2d(128, 128, kernel_size=3, bias=False, padding=1),\n",
+    "            nn.BatchNorm2d(128),\n",
+    "            nn.ReLU(inplace=True),\n",
+    "        )\n",
+    "        self.down3 = nn.Sequential(\n",
+    "            nn.Conv2d(128, 256, kernel_size=3, bias=False, padding=1),\n",
+    "            nn.BatchNorm2d(256),\n",
+    "            nn.ReLU(inplace=True),\n",
+    "            nn.Conv2d(256, 256, kernel_size=3, bias=False, padding=1),\n",
+    "            nn.BatchNorm2d(256),\n",
+    "            nn.ReLU(inplace=True),\n",
+    "        )\n",
+    "        self.down4 = nn.Sequential(\n",
+    "            nn.Conv2d(256, 512, kernel_size=3, bias=False, padding=1),\n",
+    "            nn.BatchNorm2d(512),\n",
+    "            nn.ReLU(inplace=True),\n",
+    "            nn.Conv2d(512, 512, kernel_size=3, bias=False, padding=1),\n",
+    "            nn.BatchNorm2d(512),\n",
+    "            nn.ReLU(inplace=True),\n",
+    "            nn.Dropout2d(p=0.5),\n",
+    "        )\n",
+    "        self.down5 = nn.Sequential(\n",
+    "            nn.Conv2d(512, 1024, kernel_size=3, bias=False, padding=1),\n",
+    "            nn.BatchNorm2d(1024),\n",
+    "            nn.ReLU(inplace=True),\n",
+    "            nn.Conv2d(1024, 1024, kernel_size=3, bias=False, padding=1),\n",
+    "            nn.BatchNorm2d(1024),\n",
+    "            nn.ReLU(inplace=True),\n",
+    "            nn.Dropout2d(p=0.5),\n",
+    "        )\n",
+    "\n",
+    "        # Decoder layers\n",
+    "        self.upsample6 = nn.ConvTranspose2d(1024, 1024, kernel_size=2, stride=2)\n",
+    "        self.uconv6 = nn.Sequential(\n",
+    "            nn.Conv2d(1024 + 512, 512, kernel_size=3, bias=False, padding=1),\n",
+    "            nn.BatchNorm2d(512),\n",
+    "            nn.ReLU(inplace=True),\n",
+    "            nn.Conv2d(512, 512, kernel_size=3, bias=False, padding=1),\n",
+    "            nn.BatchNorm2d(512),\n",
+    "            nn.ReLU(inplace=True),\n",
+    "        )\n",
+    "        self.upsample7 = nn.ConvTranspose2d(512, 512, kernel_size=2, stride=2)\n",
+    "        self.uconv7 = nn.Sequential(\n",
+    "            nn.Conv2d(512 + 256, 256, kernel_size=3, bias=False, padding=1),\n",
+    "            nn.BatchNorm2d(256),\n",
+    "            nn.ReLU(inplace=True),\n",
+    "            nn.Conv2d(256, 256, kernel_size=3, bias=False, padding=1),\n",
+    "            nn.BatchNorm2d(256),\n",
+    "            nn.ReLU(inplace=True),\n",
+    "        )\n",
+    "        self.upsample8 = nn.ConvTranspose2d(256, 256, kernel_size=2, stride=2)\n",
+    "        self.uconv8 = nn.Sequential(\n",
+    "            nn.Conv2d(256 + 128, 128, kernel_size=3, bias=False, padding=1),\n",
+    "            nn.BatchNorm2d(128),\n",
+    "            nn.ReLU(inplace=True),\n",
+    "            nn.Conv2d(128, 128, kernel_size=3, bias=False, padding=1),\n",
+    "            nn.BatchNorm2d(128),\n",
+    "            nn.ReLU(inplace=True),\n",
+    "        )\n",
+    "        self.upsample9 = nn.ConvTranspose2d(128, 128, kernel_size=2, stride=2)\n",
+    "        self.uconv9 = nn.Sequential(\n",
+    "            nn.Conv2d(128 + 64, 64, kernel_size=3, bias=False, padding=1),\n",
+    "            nn.BatchNorm2d(64),\n",
+    "            nn.ReLU(inplace=True),\n",
+    "            nn.Conv2d(64, 64, kernel_size=3, bias=False, padding=1),\n",
+    "            nn.BatchNorm2d(64),\n",
+    "            nn.ReLU(inplace=True),\n",
+    "        )\n",
+    "        \n",
+    "        self.out = nn.Sequential(\n",
+    "            nn.Conv2d(64, 2, kernel_size=3, bias=False, padding=1),\n",
+    "            nn.BatchNorm2d(2),\n",
+    "            nn.ReLU(inplace=True),\n",
+    "            nn.Conv2d(2, 1, kernel_size=1, bias=False),\n",
+    "            nn.BatchNorm2d(1),\n",
+    "            nn.ReLU(inplace=True),\n",
+    "        )\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "        conv1 = self.down1(x)\n",
+    "        pool1 = self.pool(conv1)\n",
+    "\n",
+    "        conv2 = self.down2(pool1)\n",
+    "        pool2 = self.pool(conv2)\n",
+    "\n",
+    "        conv3 = self.down3(pool2)\n",
+    "        pool3 = self.pool(conv3)\n",
+    "\n",
+    "        conv4 = self.down4(pool3)\n",
+    "        pool4 = self.pool(conv4)\n",
+    "\n",
+    "        conv5 = self.down5(pool4)\n",
+    "\n",
+    "        up6 = self.upsample6(conv5)\n",
+    "        up6 = torch.cat([up6, conv4], dim=1)\n",
+    "        conv6 = self.uconv6(up6)\n",
+    "\n",
+    "        up7 = self.upsample7(conv6)\n",
+    "        up7 = torch.cat([up7, conv3], dim=1)\n",
+    "        conv7 = self.uconv7(up7)\n",
+    "\n",
+    "        up8 = self.upsample8(conv7)\n",
+    "        up8 = torch.cat([up8, conv2], dim=1)\n",
+    "        conv8 = self.uconv8(up8)\n",
+    "\n",
+    "        up9 = self.upsample9(conv8)\n",
+    "        up9 = torch.cat([up9, conv1], dim=1)\n",
+    "        conv9 = self.uconv9(up9)\n",
+    "\n",
+    "        out = self.out(conv9)\n",
+    "\n",
+    "        return out\n",
+    "\n",
+    "    def training_step(self, batch, batch_idx):\n",
+    "        loss = self.shared_step()\n",
+    "        self.log(\"train_loss\", loss)\n",
+    "        return loss\n",
+    "\n",
+    "    def validation_step(self, batch, batch_idx):\n",
+    "        loss = self.shared_step(batch, batch_idx)\n",
+    "        self.log(\"val_loss\", loss)\n",
+    "\n",
+    "    def shared_step(self, batch, batch_idx):\n",
+    "        x, y = batch\n",
+    "        y_hat = self(x)\n",
+    "        loss = self.criterion(y_hat, y)\n",
+    "        return loss\n",
+    "\n",
+    "    def configure_optimizers(self):\n",
+    "        optimizer = torch.optim.Adam(self.paramters(), lr=self.hparams.lr)\n",
+    "        return optimizer"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "torch.Size([3, 1, 128, 128])"
+      ]
+     },
+     "execution_count": 19,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "application/javascript": [
+       "\n",
+       "            setTimeout(function() {\n",
+       "                var nbb_cell_id = 19;\n",
+       "                var nbb_unformatted_code = \"model = RainNet()\\nx = torch.randn(3, 4, 128, 128)\\nmodel(x).shape\";\n",
+       "                var nbb_formatted_code = \"model = RainNet()\\nx = torch.randn(3, 4, 128, 128)\\nmodel(x).shape\";\n",
+       "                var nbb_cells = Jupyter.notebook.get_cells();\n",
+       "                for (var i = 0; i < nbb_cells.length; ++i) {\n",
+       "                    if (nbb_cells[i].input_prompt_number == nbb_cell_id) {\n",
+       "                        if (nbb_cells[i].get_text() == nbb_unformatted_code) {\n",
+       "                             nbb_cells[i].set_text(nbb_formatted_code);\n",
+       "                        }\n",
+       "                        break;\n",
+       "                    }\n",
+       "                }\n",
+       "            }, 500);\n",
+       "            "
+      ],
+      "text/plain": [
+       "<IPython.core.display.Javascript object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "model = RainNet()\n",
+    "x = torch.randn(3, 4, 128, 128)\n",
+    "model(x).shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "trainer = pl.Trainer(gpus=1, max_epochs=3, progress_bar_refresh_rate=20)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python [conda env:torch] *",
+   "language": "python",
+   "name": "conda-env-torch-py"
+  },
+  "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.8.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}