From d5c3ca4456f436e99564e7afdbeb9c67c3e9653a Mon Sep 17 00:00:00 2001 From: OeslleLucena Date: Thu, 6 Apr 2023 17:59:38 +0100 Subject: [PATCH 01/13] [WIP] reformat using pl --- ...fusion_v2_super_resolution-lightning.ipynb | 1638 +++++++++++++++++ 1 file changed, 1638 insertions(+) create mode 100644 tutorials/generative/2d_super_resolution/2d_stable_diffusion_v2_super_resolution-lightning.ipynb diff --git a/tutorials/generative/2d_super_resolution/2d_stable_diffusion_v2_super_resolution-lightning.ipynb b/tutorials/generative/2d_super_resolution/2d_stable_diffusion_v2_super_resolution-lightning.ipynb new file mode 100644 index 00000000..a03c168e --- /dev/null +++ b/tutorials/generative/2d_super_resolution/2d_stable_diffusion_v2_super_resolution-lightning.ipynb @@ -0,0 +1,1638 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "bc11fdc9", + "metadata": {}, + "outputs": [], + "source": [ + "# Copyright (c) MONAI Consortium\n", + "# Licensed under the Apache License, Version 2.0 (the \"License\");\n", + "# you may not use this file except in compliance with the License.\n", + "# You may obtain a copy of the License at\n", + "# http://www.apache.org/licenses/LICENSE-2.0\n", + "# Unless required by applicable law or agreed to in writing, software\n", + "# distributed under the License is distributed on an \"AS IS\" BASIS,\n", + "# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n", + "# See the License for the specific language governing permissions and\n", + "# limitations under the License." + ] + }, + { + "cell_type": "markdown", + "id": "95c08725", + "metadata": {}, + "source": [ + "# Super-resolution using Stable Diffusion v2 Upscalers\n", + "\n", + "Tutorial to illustrate the super-resolution task on medical images using Latent Diffusion Models (LDMs) [1]. For that, we will use an autoencoder to obtain a latent representation of the high-resolution images. Then, we train a diffusion model to infer this latent representation when conditioned on a low-resolution image.\n", + "\n", + "To improve the performance of our models, we will use a method called \"noise conditioning augmentation\" (introduced in [2] and used in Stable Diffusion v2.0 and Imagen Video [3]). During the training, we add noise to the low-resolution images using a random signal-to-noise ratio, and we condition the diffusion models on the amount of noise added. At sampling time, we use a fixed signal-to-noise ratio, representing a small amount of augmentation that aids in removing artefacts in the samples.\n", + "\n", + "\n", + "[1] - Rombach et al. \"High-Resolution Image Synthesis with Latent Diffusion Models\" https://arxiv.org/abs/2112.10752\n", + "\n", + "[2] - Ho et al. \"Cascaded diffusion models for high fidelity image generation\" https://arxiv.org/abs/2106.15282\n", + "\n", + "[3] - Ho et al. \"High Definition Video Generation with Diffusion Models\" https://arxiv.org/abs/2210.02303" + ] + }, + { + "cell_type": "markdown", + "id": "b839bf2d", + "metadata": {}, + "source": [ + "## Set up environment using Colab\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "77f7e633", + "metadata": {}, + "outputs": [], + "source": [ + "!python -c \"import monai\" || pip install -q \"monai-weekly[tqdm]\"\n", + "!python -c \"import matplotlib\" || pip install -q matplotlib\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "markdown", + "id": "214066de", + "metadata": {}, + "source": [ + "## Set up imports" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "de71fe08", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/ol18/miniconda3/envs/monai_generative/lib/python3.8/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", + " from .autonotebook import tqdm as notebook_tqdm\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2023-04-06 16:56:02,588 - WARNING[XFORMERS]: xFormers can't load C++/CUDA extensions. xFormers was built for:\n", + " PyTorch 1.13.1+cu117 with CUDA 1107 (you have 1.12.1)\n", + " Python 3.8.16 (you have 3.8.16)\n", + " Please reinstall xformers (see https://github.com/facebookresearch/xformers#installing-xformers)\n", + " Memory-efficient attention, SwiGLU, sparse and more won't be available.\n", + " Set XFORMERS_MORE_DETAILS=1 for more details\n", + "2023-04-06 16:56:04,614 - Created a temporary directory at /tmp/tmp0zwlum7_\n", + "2023-04-06 16:56:04,617 - Writing /tmp/tmp0zwlum7_/_remote_module_non_scriptable.py\n", + "MONAI version: 1.2.dev2304\n", + "Numpy version: 1.23.5\n", + "Pytorch version: 1.12.1\n", + "MONAI flags: HAS_EXT = False, USE_COMPILED = False, USE_META_DICT = False\n", + "MONAI rev id: 9a57be5aab9f2c2a134768c0c146399150e247a0\n", + "MONAI __file__: /home/ol18/miniconda3/envs/monai_generative/lib/python3.8/site-packages/monai_weekly-1.2.dev2304-py3.8.egg/monai/__init__.py\n", + "\n", + "Optional dependencies:\n", + "Pytorch Ignite version: 0.4.10\n", + "ITK version: 5.3.0\n", + "Nibabel version: 5.1.0\n", + "scikit-image version: 0.20.0\n", + "Pillow version: 9.4.0\n", + "Tensorboard version: 2.12.1\n", + "gdown version: 4.7.1\n", + "TorchVision version: 0.13.1\n", + "tqdm version: 4.65.0\n", + "lmdb version: 1.4.0\n", + "psutil version: 5.9.4\n", + "pandas version: 2.0.0\n", + "einops version: 0.6.0\n", + "transformers version: 4.21.3\n", + "mlflow version: 2.2.2\n", + "pynrrd version: 1.0.0\n", + "\n", + "For details about installing the optional dependencies, please visit:\n", + " https://docs.monai.io/en/latest/installation.html#installing-the-recommended-dependencies\n", + "\n" + ] + } + ], + "source": [ + "import os\n", + "import shutil\n", + "import tempfile\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import torch\n", + "import torch.nn.functional as F\n", + "from monai import transforms\n", + "from monai.apps import MedNISTDataset\n", + "from monai.config import print_config\n", + "from monai.data import CacheDataset, DataLoader\n", + "from monai.utils import first, set_determinism\n", + "from torch import nn\n", + "from torch.cuda.amp import GradScaler, autocast\n", + "from tqdm import tqdm\n", + "\n", + "from generative.losses import PatchAdversarialLoss, PerceptualLoss\n", + "from generative.networks.nets import AutoencoderKL, DiffusionModelUNet, PatchDiscriminator\n", + "from generative.networks.schedulers import DDPMScheduler\n", + "\n", + "import pytorch_lightning as pl\n", + "from pytorch_lightning.callbacks.model_checkpoint import ModelCheckpoint\n", + "\n", + "print_config()" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "9f0a17bc", + "metadata": {}, + "outputs": [], + "source": [ + "# for reproducibility purposes set a seed\n", + "set_determinism(42)" + ] + }, + { + "cell_type": "markdown", + "id": "c0dde922", + "metadata": {}, + "source": [ + "## Setup a data directory and download dataset\n", + "Specify a MONAI_DATA_DIRECTORY variable, where the data will be downloaded. If not specified a temporary directory will be used." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "ded618a7", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "/tmp/tmpqpsolhvx\n" + ] + } + ], + "source": [ + "directory = os.environ.get(\"MONAI_DATA_DIRECTORY\")\n", + "root_dir = tempfile.mkdtemp() if directory is None else directory\n", + "print(root_dir)" + ] + }, + { + "cell_type": "markdown", + "id": "d80e045b", + "metadata": {}, + "source": [ + "## Define the LightningModule for AutoEncoder (transforms, network, loaders, etc)\n", + "The LightningModule contains a refactoring of your training code. The following module is a refactoring of the code in 2d_stable_diffusion_v2_super_resolution-lightning\n" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "d5d1caff", + "metadata": { + "scrolled": false + }, + "outputs": [], + "source": [ + "class AutoEnconder(pl.LightningModule):\n", + " def __init__(self):\n", + " super().__init__()\n", + " self.data_dir = root_dir\n", + " self.autoencoderkl = AutoencoderKL(spatial_dims=2,\n", + " in_channels=1,\n", + " out_channels=1,\n", + " num_channels=(256, 512, 512),\n", + " latent_channels=3,\n", + " num_res_blocks=2,\n", + " norm_num_groups=32,\n", + " attention_levels=(False, False, True))\n", + " self.discriminator = PatchDiscriminator(spatial_dims=2, in_channels=1,\n", + " num_layers_d=3, num_channels=64)\n", + " self.perceptual_loss = PerceptualLoss(spatial_dims=2, network_type=\"alex\")\n", + " self.perceptual_weight = 0.002\n", + " self.autoencoder_warm_up_n_epochs = 10\n", + " self.automatic_optimization = False\n", + " self.adv_loss = PatchAdversarialLoss(criterion=\"least_squares\")\n", + " self.adv_weight = 0.005\n", + " self.kl_weight = 1e-6\n", + " \n", + " def forward(self, z):\n", + " return self.autoencoderkl(z)\n", + "\n", + " def prepare_data(self):\n", + " image_size = 64\n", + " train_transforms = transforms.Compose(\n", + " [\n", + " transforms.LoadImaged(keys=[\"image\"]),\n", + " transforms.EnsureChannelFirstd(keys=[\"image\"]),\n", + " transforms.ScaleIntensityRanged(keys=[\"image\"], a_min=0.0, a_max=255.0, b_min=0.0,\n", + " b_max=1.0, clip=True),\n", + " transforms.RandAffined(\n", + " keys=[\"image\"],\n", + " rotate_range=[(-np.pi / 36, np.pi / 36), (-np.pi / 36, np.pi / 36)],\n", + " translate_range=[(-1, 1), (-1, 1)],\n", + " scale_range=[(-0.05, 0.05), (-0.05, 0.05)],\n", + " spatial_size=[image_size, image_size],\n", + " padding_mode=\"zeros\",\n", + " prob=0.5,\n", + " ),\n", + " transforms.CopyItemsd(keys=[\"image\"], times=1, names=[\"low_res_image\"]),\n", + " transforms.Resized(keys=[\"low_res_image\"], spatial_size=(16, 16)),\n", + " ]\n", + " )\n", + " \n", + " val_transforms = transforms.Compose(\n", + " [\n", + " transforms.LoadImaged(keys=[\"image\"]),\n", + " transforms.EnsureChannelFirstd(keys=[\"image\"]),\n", + " transforms.ScaleIntensityRanged(keys=[\"image\"], a_min=0.0, a_max=255.0, b_min=0.0, \n", + " b_max=1.0, clip=True),\n", + " transforms.CopyItemsd(keys=[\"image\"], times=1, names=[\"low_res_image\"]),\n", + " transforms.Resized(keys=[\"low_res_image\"], spatial_size=(16, 16)),\n", + " ]\n", + " )\n", + " \n", + " train_data = MedNISTDataset(root_dir=self.data_dir, section=\"training\", download=True, seed=0)\n", + " train_datalist = [{\"image\": item[\"image\"]} for item in train_data.data if item[\"class_name\"] == \"HeadCT\"]\n", + " val_data = MedNISTDataset(root_dir=self.data_dir, section=\"validation\", download=True, seed=0)\n", + " val_datalist = [{\"image\": item[\"image\"]} for item in val_data.data if item[\"class_name\"] == \"HeadCT\"]\n", + " \n", + " self.train_ds = CacheDataset(data=train_datalist, transform=train_transforms)\n", + " self.val_ds = CacheDataset(data=val_datalist, transform=val_transforms)\n", + " \n", + " def train_dataloader(self):\n", + " return DataLoader(self.train_ds, batch_size=16, shuffle=True,\n", + " num_workers=4, persistent_workers=True)\n", + " \n", + " def val_dataloader(self):\n", + " return DataLoader(self.val_ds, batch_size=16, shuffle=False,\n", + " num_workers=4)\n", + " \n", + " def _compute_loss_generator(self, images, reconstruction, z_mu, z_sigma):\n", + " recons_loss = F.l1_loss(reconstruction.float(), images.float())\n", + " p_loss = self.perceptual_loss(reconstruction.float(), images.float())\n", + " kl_loss = 0.5 * torch.sum(z_mu.pow(2) + z_sigma.pow(2) - torch.log(z_sigma.pow(2)) - 1, dim=[1, 2, 3])\n", + " kl_loss = torch.sum(kl_loss) / kl_loss.shape[0]\n", + " loss_g = recons_loss + (self.kl_weight * kl_loss) + (self.perceptual_weight * p_loss)\n", + " return loss_g,recons_loss\n", + " \n", + " def _compute_loss_discriminator(self, reconstruction):\n", + " logits_fake = discriminator(reconstruction.contiguous().detach())[-1]\n", + " loss_d_fake = self.adv_loss(logits_fake, target_is_real=False, for_discriminator=True)\n", + " logits_real = discriminator(images.contiguous().detach())[-1]\n", + " loss_d_real = adv_loss(logits_real, target_is_real=True, for_discriminator=True)\n", + " discriminator_loss = (loss_d_fake + loss_d_real) * 0.5\n", + " loss_d = self.adv_weight * discriminator_loss\n", + " return loss_d, discriminator_loss\n", + " \n", + " def training_step(self, batch, batch_idx):\n", + " optimizer_g, optimizer_d = self.optimizers()\n", + " images = batch[\"image\"]\n", + " reconstruction, z_mu, z_sigma = self.forward(images)\n", + " loss_g, recons_loss = self._compute_loss_generator(images, reconstruction, z_mu, z_sigma)\n", + " self.log(\"recons_loss\", recons_loss, prog_bar=True)\n", + "\n", + " if self.current_epoch > self.autoencoder_warm_up_n_epochs:\n", + " logits_fake = discriminator(reconstruction.contiguous().float())[-1]\n", + " generator_loss = adv_loss(logits_fake, target_is_real=True, for_discriminator=False)\n", + " loss_g += adv_weight * generator_loss\n", + " \n", + "\n", + " self.log(\"loss_g\", loss_g, prog_bar=True)\n", + " self.manual_backward(loss_g)\n", + " optimizer_g.step()\n", + " optimizer_g.zero_grad()\n", + " self.untoggle_optimizer(optimizer_g)\n", + "\n", + " if self.current_epoch > self.autoencoder_warm_up_n_epochs:\n", + " loss_d, discriminator_loss = self._compute_loss_discriminator(reconstruction)\n", + " self.log(\"loss_d\", loss_d, prog_bar=True)\n", + " self.manual_backward(loss_d)\n", + " optimizer_d.step()\n", + " optimizer_d.zero_grad()\n", + " self.untoggle_optimizer(optimizer_d)\n", + "\n", + " \n", + " if self.current_epoch > self.autoencoder_warm_up_n_epochs:\n", + " gen_epoch_loss += generator_loss.item()\n", + " disc_epoch_loss += discriminator_loss.item()\n", + " self.log(\"gen_loss\", gen_loss, prog_bar=True)\n", + " self.log(\"disc_loss\", disc_loss, prog_bar=True)\n", + " \n", + " \n", + " def validation_step(self, batch, batch_idx):\n", + " images = batch[\"image\"]\n", + " reconstruction, z_mu, z_sigma = self.autoencoderkl(images)\n", + " recons_loss = F.l1_loss(images.float(), reconstruction.float())\n", + " self.log(\"loss_d\", recons_loss, prog_bar=True)\n", + " \n", + "\n", + " def configure_optimizers(self):\n", + " optimizer_g = torch.optim.Adam(self.autoencoderkl.parameters(), lr=5e-5)\n", + " optimizer_d = torch.optim.Adam(self.discriminator.parameters(), lr=1e-4)\n", + " return [optimizer_g, optimizer_d], []\n", + " \n" + ] + }, + { + "cell_type": "markdown", + "id": "c16de505", + "metadata": {}, + "source": [ + "## Train Autoencoder" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "fd8ccebf", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "The parameter 'pretrained' is deprecated since 0.13 and will be removed in 0.15, please use 'weights' instead.\n", + "Arguments other than a weight enum or `None` for 'weights' are deprecated since 0.13 and will be removed in 0.15. The current behavior is equivalent to passing `weights=AlexNet_Weights.IMAGENET1K_V1`. You can also use `weights=AlexNet_Weights.DEFAULT` to get the most up-to-date weights.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2023-04-06 17:32:20,399 - GPU available: True (cuda), used: True\n", + "2023-04-06 17:32:20,401 - TPU available: False, using: 0 TPU cores\n", + "2023-04-06 17:32:20,402 - IPU available: False, using: 0 IPUs\n", + "2023-04-06 17:32:20,403 - HPU available: False, using: 0 HPUs\n", + "2023-04-06 17:32:20,576 - INFO - Verified 'MedNIST.tar.gz', md5: 0bc7306e7427e00ad1c5526a6677552d.\n", + "2023-04-06 17:32:20,578 - INFO - File exists: /tmp/tmpqpsolhvx/MedNIST.tar.gz, skipped downloading.\n", + "2023-04-06 17:32:20,579 - INFO - Non-empty folder exists in /tmp/tmpqpsolhvx/MedNIST, skipped extracting.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "Loading dataset: 0%| | 0/47164 [00:00 x_t-1\n", + " latents, _ = scheduler.step(noise_pred, t, latents)\n", + "\n", + "with torch.no_grad():\n", + " decoded = autoencoderkl.decode_stage_2_outputs(latents / scale_factor)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "32e16e69", + "metadata": {}, + "outputs": [], + "source": [ + "low_res_bicubic = nn.functional.interpolate(sampling_image, (64, 64), mode=\"bicubic\")\n", + "fig, axs = plt.subplots(num_samples, 3, figsize=(8, 8))\n", + "axs[0, 0].set_title(\"Original image\")\n", + "axs[0, 1].set_title(\"Low-resolution Image\")\n", + "axs[0, 2].set_title(\"Outputted image\")\n", + "for i in range(0, num_samples):\n", + " axs[i, 0].imshow(images[i, 0].cpu(), vmin=0, vmax=1, cmap=\"gray\")\n", + " axs[i, 0].axis(\"off\")\n", + " axs[i, 1].imshow(low_res_bicubic[i, 0].cpu(), vmin=0, vmax=1, cmap=\"gray\")\n", + " axs[i, 1].axis(\"off\")\n", + " axs[i, 2].imshow(decoded[i, 0].cpu(), vmin=0, vmax=1, cmap=\"gray\")\n", + " axs[i, 2].axis(\"off\")\n", + "plt.tight_layout()" + ] + }, + { + "cell_type": "markdown", + "id": "7fa52acc", + "metadata": {}, + "source": [ + "### Clean-up data directory" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3a6f6d5a", + "metadata": {}, + "outputs": [], + "source": [ + "if directory is None:\n", + " shutil.rmtree(root_dir)" + ] + } + ], + "metadata": { + "jupytext": { + "cell_metadata_filter": "-all", + "formats": "ipynb,py:percent" + }, + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.16" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 5501053ac4141c9f88eda8d5ad5080c9ea1a259d Mon Sep 17 00:00:00 2001 From: OeslleLucena Date: Fri, 7 Apr 2023 18:58:49 +0100 Subject: [PATCH 02/13] [WIP] full draft done --- ...fusion_v2_super_resolution-lightning.ipynb | 1421 +++++------------ ...diffusion_v2_super_resolution-lightning.py | 479 ++++++ 2 files changed, 917 insertions(+), 983 deletions(-) create mode 100644 tutorials/generative/2d_super_resolution/2d_stable_diffusion_v2_super_resolution-lightning.py diff --git a/tutorials/generative/2d_super_resolution/2d_stable_diffusion_v2_super_resolution-lightning.ipynb b/tutorials/generative/2d_super_resolution/2d_stable_diffusion_v2_super_resolution-lightning.ipynb index a03c168e..c722a653 100644 --- a/tutorials/generative/2d_super_resolution/2d_stable_diffusion_v2_super_resolution-lightning.ipynb +++ b/tutorials/generative/2d_super_resolution/2d_stable_diffusion_v2_super_resolution-lightning.ipynb @@ -48,7 +48,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 2, "id": "77f7e633", "metadata": {}, "outputs": [], @@ -68,7 +68,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 3, "id": "de71fe08", "metadata": {}, "outputs": [ @@ -84,14 +84,14 @@ "name": "stdout", "output_type": "stream", "text": [ - "2023-04-06 16:56:02,588 - WARNING[XFORMERS]: xFormers can't load C++/CUDA extensions. xFormers was built for:\n", + "2023-04-07 18:33:20,193 - WARNING[XFORMERS]: xFormers can't load C++/CUDA extensions. xFormers was built for:\n", " PyTorch 1.13.1+cu117 with CUDA 1107 (you have 1.12.1)\n", " Python 3.8.16 (you have 3.8.16)\n", " Please reinstall xformers (see https://github.com/facebookresearch/xformers#installing-xformers)\n", " Memory-efficient attention, SwiGLU, sparse and more won't be available.\n", " Set XFORMERS_MORE_DETAILS=1 for more details\n", - "2023-04-06 16:56:04,614 - Created a temporary directory at /tmp/tmp0zwlum7_\n", - "2023-04-06 16:56:04,617 - Writing /tmp/tmp0zwlum7_/_remote_module_non_scriptable.py\n", + "2023-04-07 18:33:21,929 - Created a temporary directory at /tmp/tmpq2wlch6q\n", + "2023-04-07 18:33:21,932 - Writing /tmp/tmpq2wlch6q/_remote_module_non_scriptable.py\n", "MONAI version: 1.2.dev2304\n", "Numpy version: 1.23.5\n", "Pytorch version: 1.12.1\n", @@ -153,7 +153,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 4, "id": "9f0a17bc", "metadata": {}, "outputs": [], @@ -173,7 +173,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 5, "id": "ded618a7", "metadata": {}, "outputs": [ @@ -181,7 +181,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "/tmp/tmpqpsolhvx\n" + "/tmp/tmp1sbvw3_e\n" ] } ], @@ -191,18 +191,70 @@ "print(root_dir)" ] }, + { + "cell_type": "markdown", + "id": "46bafb78", + "metadata": {}, + "source": [ + "## Setup utils functions" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "4f8eff03", + "metadata": {}, + "outputs": [], + "source": [ + "def get_train_transforms():\n", + " image_size = 64\n", + " train_transforms = transforms.Compose(\n", + " [\n", + " transforms.LoadImaged(keys=[\"image\"]),\n", + " transforms.EnsureChannelFirstd(keys=[\"image\"]),\n", + " transforms.ScaleIntensityRanged(keys=[\"image\"], a_min=0.0, a_max=255.0, b_min=0.0,\n", + " b_max=1.0, clip=True),\n", + " transforms.RandAffined(\n", + " keys=[\"image\"],\n", + " rotate_range=[(-np.pi / 36, np.pi / 36), (-np.pi / 36, np.pi / 36)],\n", + " translate_range=[(-1, 1), (-1, 1)],\n", + " scale_range=[(-0.05, 0.05), (-0.05, 0.05)],\n", + " spatial_size=[image_size, image_size],\n", + " padding_mode=\"zeros\",\n", + " prob=0.5,\n", + " ),\n", + " transforms.CopyItemsd(keys=[\"image\"], times=1, names=[\"low_res_image\"]),\n", + " transforms.Resized(keys=[\"low_res_image\"], spatial_size=(16, 16)),\n", + " ]\n", + " )\n", + " return train_transforms\n", + "\n", + "def get_val_transforms():\n", + " val_transforms = transforms.Compose(\n", + " [\n", + " transforms.LoadImaged(keys=[\"image\"]),\n", + " transforms.EnsureChannelFirstd(keys=[\"image\"]),\n", + " transforms.ScaleIntensityRanged(keys=[\"image\"], a_min=0.0, a_max=255.0, b_min=0.0, \n", + " b_max=1.0, clip=True),\n", + " transforms.CopyItemsd(keys=[\"image\"], times=1, names=[\"low_res_image\"]),\n", + " transforms.Resized(keys=[\"low_res_image\"], spatial_size=(16, 16)),\n", + " ]\n", + " )\n", + " return val_transforms\n" + ] + }, { "cell_type": "markdown", "id": "d80e045b", "metadata": {}, "source": [ "## Define the LightningModule for AutoEncoder (transforms, network, loaders, etc)\n", - "The LightningModule contains a refactoring of your training code. The following module is a refactoring of the code in 2d_stable_diffusion_v2_super_resolution-lightning\n" + "The LightningModule contains a refactoring of your training code. The following module is a reformatiing of the code in 2d_stable_diffusion_v2_super_resolution.\n" ] }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 7, "id": "d5d1caff", "metadata": { "scrolled": false @@ -235,37 +287,8 @@ " return self.autoencoderkl(z)\n", "\n", " def prepare_data(self):\n", - " image_size = 64\n", - " train_transforms = transforms.Compose(\n", - " [\n", - " transforms.LoadImaged(keys=[\"image\"]),\n", - " transforms.EnsureChannelFirstd(keys=[\"image\"]),\n", - " transforms.ScaleIntensityRanged(keys=[\"image\"], a_min=0.0, a_max=255.0, b_min=0.0,\n", - " b_max=1.0, clip=True),\n", - " transforms.RandAffined(\n", - " keys=[\"image\"],\n", - " rotate_range=[(-np.pi / 36, np.pi / 36), (-np.pi / 36, np.pi / 36)],\n", - " translate_range=[(-1, 1), (-1, 1)],\n", - " scale_range=[(-0.05, 0.05), (-0.05, 0.05)],\n", - " spatial_size=[image_size, image_size],\n", - " padding_mode=\"zeros\",\n", - " prob=0.5,\n", - " ),\n", - " transforms.CopyItemsd(keys=[\"image\"], times=1, names=[\"low_res_image\"]),\n", - " transforms.Resized(keys=[\"low_res_image\"], spatial_size=(16, 16)),\n", - " ]\n", - " )\n", - " \n", - " val_transforms = transforms.Compose(\n", - " [\n", - " transforms.LoadImaged(keys=[\"image\"]),\n", - " transforms.EnsureChannelFirstd(keys=[\"image\"]),\n", - " transforms.ScaleIntensityRanged(keys=[\"image\"], a_min=0.0, a_max=255.0, b_min=0.0, \n", - " b_max=1.0, clip=True),\n", - " transforms.CopyItemsd(keys=[\"image\"], times=1, names=[\"low_res_image\"]),\n", - " transforms.Resized(keys=[\"low_res_image\"], spatial_size=(16, 16)),\n", - " ]\n", - " )\n", + " train_transforms = get_train_transforms()\n", + " val_transforms = get_val_transforms()\n", " \n", " train_data = MedNISTDataset(root_dir=self.data_dir, section=\"training\", download=True, seed=0)\n", " train_datalist = [{\"image\": item[\"image\"]} for item in train_data.data if item[\"class_name\"] == \"HeadCT\"]\n", @@ -305,7 +328,7 @@ " images = batch[\"image\"]\n", " reconstruction, z_mu, z_sigma = self.forward(images)\n", " loss_g, recons_loss = self._compute_loss_generator(images, reconstruction, z_mu, z_sigma)\n", - " self.log(\"recons_loss\", recons_loss, prog_bar=True)\n", + " self.log(\"recons_loss\", recons_loss, batch_size=16, prog_bar=True)\n", "\n", " if self.current_epoch > self.autoencoder_warm_up_n_epochs:\n", " logits_fake = discriminator(reconstruction.contiguous().float())[-1]\n", @@ -313,7 +336,7 @@ " loss_g += adv_weight * generator_loss\n", " \n", "\n", - " self.log(\"loss_g\", loss_g, prog_bar=True)\n", + " self.log(\"loss_g\", loss_g, batch_size=16, prog_bar=True)\n", " self.manual_backward(loss_g)\n", " optimizer_g.step()\n", " optimizer_g.zero_grad()\n", @@ -321,7 +344,7 @@ "\n", " if self.current_epoch > self.autoencoder_warm_up_n_epochs:\n", " loss_d, discriminator_loss = self._compute_loss_discriminator(reconstruction)\n", - " self.log(\"loss_d\", loss_d, prog_bar=True)\n", + " self.log(\"train_loss_d\", loss_d, batch_size=16, prog_bar=True)\n", " self.manual_backward(loss_d)\n", " optimizer_d.step()\n", " optimizer_d.zero_grad()\n", @@ -331,15 +354,15 @@ " if self.current_epoch > self.autoencoder_warm_up_n_epochs:\n", " gen_epoch_loss += generator_loss.item()\n", " disc_epoch_loss += discriminator_loss.item()\n", - " self.log(\"gen_loss\", gen_loss, prog_bar=True)\n", - " self.log(\"disc_loss\", disc_loss, prog_bar=True)\n", + " self.log(\"gen_loss\", gen_loss, batch_size=16, prog_bar=True)\n", + " self.log(\"disc_loss\", disc_loss, batch_size=16, prog_bar=True)\n", " \n", " \n", " def validation_step(self, batch, batch_idx):\n", " images = batch[\"image\"]\n", " reconstruction, z_mu, z_sigma = self.autoencoderkl(images)\n", " recons_loss = F.l1_loss(images.float(), reconstruction.float())\n", - " self.log(\"loss_d\", recons_loss, prog_bar=True)\n", + " self.log(\"val_loss_d\", recons_loss, prog_bar=True)\n", " \n", "\n", " def configure_optimizers(self):\n", @@ -359,8 +382,8 @@ }, { "cell_type": "code", - "execution_count": 22, - "id": "fd8ccebf", + "execution_count": 8, + "id": "9d903aaa", "metadata": { "scrolled": true }, @@ -377,733 +400,86 @@ "name": "stdout", "output_type": "stream", "text": [ - "2023-04-06 17:32:20,399 - GPU available: True (cuda), used: True\n", - "2023-04-06 17:32:20,401 - TPU available: False, using: 0 TPU cores\n", - "2023-04-06 17:32:20,402 - IPU available: False, using: 0 IPUs\n", - "2023-04-06 17:32:20,403 - HPU available: False, using: 0 HPUs\n", - "2023-04-06 17:32:20,576 - INFO - Verified 'MedNIST.tar.gz', md5: 0bc7306e7427e00ad1c5526a6677552d.\n", - "2023-04-06 17:32:20,578 - INFO - File exists: /tmp/tmpqpsolhvx/MedNIST.tar.gz, skipped downloading.\n", - "2023-04-06 17:32:20,579 - INFO - Non-empty folder exists in /tmp/tmpqpsolhvx/MedNIST, skipped extracting.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n", - "Loading dataset: 0%| | 0/47164 [00:00 x_t-1\n", " latents, _ = scheduler.step(noise_pred, t, latents)\n", "\n", "with torch.no_grad():\n", - " decoded = autoencoderkl.decode_stage_2_outputs(latents / scale_factor)" + " decoded = ae_net.autoencoderkl.decode_stage_2_outputs(latents / scale_factor)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 14, "id": "32e16e69", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "low_res_bicubic = nn.functional.interpolate(sampling_image, (64, 64), mode=\"bicubic\")\n", "fig, axs = plt.subplots(num_samples, 3, figsize=(8, 8))\n", @@ -1600,7 +1055,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 15, "id": "3a6f6d5a", "metadata": {}, "outputs": [], diff --git a/tutorials/generative/2d_super_resolution/2d_stable_diffusion_v2_super_resolution-lightning.py b/tutorials/generative/2d_super_resolution/2d_stable_diffusion_v2_super_resolution-lightning.py new file mode 100644 index 00000000..0449491c --- /dev/null +++ b/tutorials/generative/2d_super_resolution/2d_stable_diffusion_v2_super_resolution-lightning.py @@ -0,0 +1,479 @@ +# --- +# jupyter: +# jupytext: +# cell_metadata_filter: -all +# formats: ipynb,py:percent +# text_representation: +# extension: .py +# format_name: percent +# format_version: '1.3' +# jupytext_version: 1.14.5 +# kernelspec: +# display_name: Python 3 (ipykernel) +# language: python +# name: python3 +# --- + +# %% +# Copyright (c) MONAI Consortium +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# http://www.apache.org/licenses/LICENSE-2.0 +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +# %% [markdown] +# # Super-resolution using Stable Diffusion v2 Upscalers +# +# Tutorial to illustrate the super-resolution task on medical images using Latent Diffusion Models (LDMs) [1]. For that, we will use an autoencoder to obtain a latent representation of the high-resolution images. Then, we train a diffusion model to infer this latent representation when conditioned on a low-resolution image. +# +# To improve the performance of our models, we will use a method called "noise conditioning augmentation" (introduced in [2] and used in Stable Diffusion v2.0 and Imagen Video [3]). During the training, we add noise to the low-resolution images using a random signal-to-noise ratio, and we condition the diffusion models on the amount of noise added. At sampling time, we use a fixed signal-to-noise ratio, representing a small amount of augmentation that aids in removing artefacts in the samples. +# +# +# [1] - Rombach et al. "High-Resolution Image Synthesis with Latent Diffusion Models" https://arxiv.org/abs/2112.10752 +# +# [2] - Ho et al. "Cascaded diffusion models for high fidelity image generation" https://arxiv.org/abs/2106.15282 +# +# [3] - Ho et al. "High Definition Video Generation with Diffusion Models" https://arxiv.org/abs/2210.02303 + +# %% [markdown] +# ## Set up environment using Colab +# + +# %% +# !python -c "import monai" || pip install -q "monai-weekly[tqdm]" +# !python -c "import matplotlib" || pip install -q matplotlib +# %matplotlib inline + +# %% [markdown] +# ## Set up imports + +# %% +import os +import shutil +import tempfile + +import matplotlib.pyplot as plt +import numpy as np +import torch +import torch.nn.functional as F +from monai import transforms +from monai.apps import MedNISTDataset +from monai.config import print_config +from monai.data import CacheDataset, DataLoader +from monai.utils import first, set_determinism +from torch import nn +from torch.cuda.amp import GradScaler, autocast +from tqdm import tqdm + +from generative.losses import PatchAdversarialLoss, PerceptualLoss +from generative.networks.nets import AutoencoderKL, DiffusionModelUNet, PatchDiscriminator +from generative.networks.schedulers import DDPMScheduler + +import pytorch_lightning as pl +from pytorch_lightning.callbacks.model_checkpoint import ModelCheckpoint + +print_config() + +# %% +# for reproducibility purposes set a seed +set_determinism(42) + +# %% [markdown] +# ## Setup a data directory and download dataset +# Specify a MONAI_DATA_DIRECTORY variable, where the data will be downloaded. If not specified a temporary directory will be used. + +# %% +directory = os.environ.get("MONAI_DATA_DIRECTORY") +root_dir = tempfile.mkdtemp() if directory is None else directory +print(root_dir) + + +# %% [markdown] +# ## Setup utils functions + +# %% +def get_train_transforms(): + image_size = 64 + train_transforms = transforms.Compose( + [ + transforms.LoadImaged(keys=["image"]), + transforms.EnsureChannelFirstd(keys=["image"]), + transforms.ScaleIntensityRanged(keys=["image"], a_min=0.0, a_max=255.0, b_min=0.0, + b_max=1.0, clip=True), + transforms.RandAffined( + keys=["image"], + rotate_range=[(-np.pi / 36, np.pi / 36), (-np.pi / 36, np.pi / 36)], + translate_range=[(-1, 1), (-1, 1)], + scale_range=[(-0.05, 0.05), (-0.05, 0.05)], + spatial_size=[image_size, image_size], + padding_mode="zeros", + prob=0.5, + ), + transforms.CopyItemsd(keys=["image"], times=1, names=["low_res_image"]), + transforms.Resized(keys=["low_res_image"], spatial_size=(16, 16)), + ] + ) + return train_transforms + +def get_val_transforms(): + val_transforms = transforms.Compose( + [ + transforms.LoadImaged(keys=["image"]), + transforms.EnsureChannelFirstd(keys=["image"]), + transforms.ScaleIntensityRanged(keys=["image"], a_min=0.0, a_max=255.0, b_min=0.0, + b_max=1.0, clip=True), + transforms.CopyItemsd(keys=["image"], times=1, names=["low_res_image"]), + transforms.Resized(keys=["low_res_image"], spatial_size=(16, 16)), + ] + ) + return val_transforms + + + +# %% [markdown] +# ## Define the LightningModule for AutoEncoder (transforms, network, loaders, etc) +# The LightningModule contains a refactoring of your training code. The following module is a reformatiing of the code in 2d_stable_diffusion_v2_super_resolution. +# + +# %% +class AutoEnconder(pl.LightningModule): + def __init__(self): + super().__init__() + self.data_dir = root_dir + self.autoencoderkl = AutoencoderKL(spatial_dims=2, + in_channels=1, + out_channels=1, + num_channels=(256, 512, 512), + latent_channels=3, + num_res_blocks=2, + norm_num_groups=32, + attention_levels=(False, False, True)) + self.discriminator = PatchDiscriminator(spatial_dims=2, in_channels=1, + num_layers_d=3, num_channels=64) + self.perceptual_loss = PerceptualLoss(spatial_dims=2, network_type="alex") + self.perceptual_weight = 0.002 + self.autoencoder_warm_up_n_epochs = 10 + self.automatic_optimization = False + self.adv_loss = PatchAdversarialLoss(criterion="least_squares") + self.adv_weight = 0.005 + self.kl_weight = 1e-6 + + def forward(self, z): + return self.autoencoderkl(z) + + def prepare_data(self): + train_transforms = get_train_transforms() + val_transforms = get_val_transforms() + + train_data = MedNISTDataset(root_dir=self.data_dir, section="training", download=True, seed=0) + train_datalist = [{"image": item["image"]} for item in train_data.data if item["class_name"] == "HeadCT"] + val_data = MedNISTDataset(root_dir=self.data_dir, section="validation", download=True, seed=0) + val_datalist = [{"image": item["image"]} for item in val_data.data if item["class_name"] == "HeadCT"] + + self.train_ds = CacheDataset(data=train_datalist, transform=train_transforms) + self.val_ds = CacheDataset(data=val_datalist, transform=val_transforms) + + def train_dataloader(self): + return DataLoader(self.train_ds, batch_size=16, shuffle=True, + num_workers=4, persistent_workers=True) + + def val_dataloader(self): + return DataLoader(self.val_ds, batch_size=16, shuffle=False, + num_workers=4) + + def _compute_loss_generator(self, images, reconstruction, z_mu, z_sigma): + recons_loss = F.l1_loss(reconstruction.float(), images.float()) + p_loss = self.perceptual_loss(reconstruction.float(), images.float()) + kl_loss = 0.5 * torch.sum(z_mu.pow(2) + z_sigma.pow(2) - torch.log(z_sigma.pow(2)) - 1, dim=[1, 2, 3]) + kl_loss = torch.sum(kl_loss) / kl_loss.shape[0] + loss_g = recons_loss + (self.kl_weight * kl_loss) + (self.perceptual_weight * p_loss) + return loss_g,recons_loss + + def _compute_loss_discriminator(self, reconstruction): + logits_fake = discriminator(reconstruction.contiguous().detach())[-1] + loss_d_fake = self.adv_loss(logits_fake, target_is_real=False, for_discriminator=True) + logits_real = discriminator(images.contiguous().detach())[-1] + loss_d_real = adv_loss(logits_real, target_is_real=True, for_discriminator=True) + discriminator_loss = (loss_d_fake + loss_d_real) * 0.5 + loss_d = self.adv_weight * discriminator_loss + return loss_d, discriminator_loss + + def training_step(self, batch, batch_idx): + optimizer_g, optimizer_d = self.optimizers() + images = batch["image"] + reconstruction, z_mu, z_sigma = self.forward(images) + loss_g, recons_loss = self._compute_loss_generator(images, reconstruction, z_mu, z_sigma) + self.log("recons_loss", recons_loss, batch_size=16, prog_bar=True) + + if self.current_epoch > self.autoencoder_warm_up_n_epochs: + logits_fake = discriminator(reconstruction.contiguous().float())[-1] + generator_loss = adv_loss(logits_fake, target_is_real=True, for_discriminator=False) + loss_g += adv_weight * generator_loss + + + self.log("loss_g", loss_g, batch_size=16, prog_bar=True) + self.manual_backward(loss_g) + optimizer_g.step() + optimizer_g.zero_grad() + self.untoggle_optimizer(optimizer_g) + + if self.current_epoch > self.autoencoder_warm_up_n_epochs: + loss_d, discriminator_loss = self._compute_loss_discriminator(reconstruction) + self.log("train_loss_d", loss_d, batch_size=16, prog_bar=True) + self.manual_backward(loss_d) + optimizer_d.step() + optimizer_d.zero_grad() + self.untoggle_optimizer(optimizer_d) + + + if self.current_epoch > self.autoencoder_warm_up_n_epochs: + gen_epoch_loss += generator_loss.item() + disc_epoch_loss += discriminator_loss.item() + self.log("gen_loss", gen_loss, batch_size=16, prog_bar=True) + self.log("disc_loss", disc_loss, batch_size=16, prog_bar=True) + + + def validation_step(self, batch, batch_idx): + images = batch["image"] + reconstruction, z_mu, z_sigma = self.autoencoderkl(images) + recons_loss = F.l1_loss(images.float(), reconstruction.float()) + self.log("val_loss_d", recons_loss, prog_bar=True) + + + def configure_optimizers(self): + optimizer_g = torch.optim.Adam(self.autoencoderkl.parameters(), lr=5e-5) + optimizer_d = torch.optim.Adam(self.discriminator.parameters(), lr=1e-4) + return [optimizer_g, optimizer_d], [] + + + +# %% [markdown] +# ## Train Autoencoder + +# %% +n_epochs = 1 +val_interval = 1 + + +# initialise the LightningModule +ae_net = AutoEnconder() + +# set up checkpoints + +checkpoint_callback = ModelCheckpoint(dirpath=root_dir, filename="best_metric_model") + + +# initialise Lightning's trainer. +trainer = pl.Trainer(devices=1, + max_epochs=n_epochs, + check_val_every_n_epoch=val_interval, + callbacks=checkpoint_callback, + default_root_dir=root_dir) + +# train +trainer.fit(ae_net) + +# %% [markdown] +# ## Rescaling factor +# +# As mentioned in Rombach et al. [1] Section 4.3.2 and D.1, the signal-to-noise ratio (induced by the scale of the latent space) became crucial in image-to-image translation models (such as the ones used for super-resolution). For this reason, we will compute the component-wise standard deviation to be used as scaling factor. + +# %% +train_loader = ae_net.train_dataloader() +check_data = first(train_loader) +z = ae_net.autoencoderkl.train(mode=False).encode_stage_2_inputs(check_data["image"].to(ae_net.device)) +print(f"Scaling factor set to {1/torch.std(z)}") +scale_factor = 1 / torch.std(z) + + +# %% [markdown] +# ## Define the LightningModule for DiffusionModelUnet (transforms, network, loaders, etc) +# The LightningModule contains a refactoring of your training code. The following module is a reformatiing of the code in 2d_stable_diffusion_v2_super_resolution. + +# %% +class DiffusionUNET(pl.LightningModule): + def __init__(self): + super().__init__() + self.data_dir = root_dir + self.unet = DiffusionModelUNet( + spatial_dims=2, + in_channels=4, + out_channels=3, + num_res_blocks=2, + num_channels=(256, 256, 512, 1024), + attention_levels=(False, False, True, True), + num_head_channels=(0, 0, 64, 64), + ) + self.max_noise_level = 350 + self.scheduler = DDPMScheduler(num_train_timesteps=1000, + beta_schedule="linear", + beta_start=0.0015, + beta_end=0.0195) + self.z = ae_net.autoencoderkl.train(mode=False) + + + def forward(self, x, timesteps, low_res_timesteps): + return self.unet(x=x, + timesteps=timesteps, + class_labels=low_res_timesteps) + + + def prepare_data(self): + train_transforms = get_train_transforms() + val_transforms = get_val_transforms() + + train_data = MedNISTDataset(root_dir=self.data_dir, section="training", + download=True, seed=0) + train_datalist = [{"image": item["image"]} for item in train_data.data if item["class_name"] == "HeadCT"] + val_data = MedNISTDataset(root_dir=self.data_dir, section="validation", + download=True, seed=0) + val_datalist = [{"image": item["image"]} for item in val_data.data if item["class_name"] == "HeadCT"] + + self.train_ds = CacheDataset(data=train_datalist, transform=train_transforms) + self.val_ds = CacheDataset(data=val_datalist, transform=val_transforms) + + def train_dataloader(self): + return DataLoader(self.train_ds, batch_size=16, shuffle=True, + num_workers=4, persistent_workers=True) + + def val_dataloader(self): + return DataLoader(self.val_ds, batch_size=16, shuffle=True, + num_workers=4) + + def _calculate_loss(self, batch, batch_idx): + images = batch["image"] + low_res_image = batch["low_res_image"] + latent = self.z.encode_stage_2_inputs(images) * scale_factor + latent = latent.detach() # avoid adding this to graph. + optimizer = self.optimizers() + + # Noise augmentation + noise = torch.randn_like(latent) + low_res_noise = torch.randn_like(low_res_image) + timesteps = torch.randint(0, self.scheduler.num_train_timesteps, (latent.shape[0],), + device=latent.device).long() + low_res_timesteps = torch.randint( + 0, self.max_noise_level, (low_res_image.shape[0],), device=latent.device + ).long() + + noisy_latent = self.scheduler.add_noise(original_samples=latent, + noise=noise, timesteps=timesteps) + noisy_low_res_image = self.scheduler.add_noise( + original_samples=low_res_image, noise=low_res_noise, + timesteps=low_res_timesteps + ) + + latent_model_input = torch.cat([noisy_latent, noisy_low_res_image], dim=1) + + noise_pred = self.forward(latent_model_input, timesteps, low_res_timesteps) + loss = F.mse_loss(noise_pred.float(), noise.float()) + return loss + + def training_step(self, batch, batch_idx): + loss = self._calculate_loss(batch, batch_idx) + self.log("train_loss", loss, batch_size=16, prog_bar=True) + return loss + + + def validation_step(self, batch, batch_idx): + loss = self._calculate_loss(batch, batch_idx) + self.log("val_loss", loss, batch_size=16, prog_bar=True) + return loss + + def configure_optimizers(self): + optimizer = torch.optim.Adam(self.unet.parameters(), lr=5e-5) + return optimizer + + +# %% [markdown] +# ## Train Diffusion Model +# +# In order to train the diffusion model to perform super-resolution, we will need to concatenate the latent representation of the high-resolution with the low-resolution image. For this, we create a Diffusion model with `in_channels=4`. Since only the outputted latent representation is interesting, we set `out_channels=3`. +# +# As mentioned, we will use the conditioned augmentation (introduced in [2] section 3 and used on Stable Diffusion Upscalers and Imagen Video [3] Section 2.5) as it has been shown critical for cascaded diffusion models, as well for super-resolution tasks. For this, we apply Gaussian noise augmentation to the low-resolution images. We will use a scheduler low_res_scheduler to add this noise, with the t step defining the signal-to-noise ratio and use the t value to condition the diffusion model (inputted using class_labels argument). + +# %% +n_epochs = 3 +val_interval = 3 + + +# initialise the LightningModule +d_net = DiffusionUNET() + +# set up checkpoints + +checkpoint_callback = ModelCheckpoint(dirpath=root_dir, filename="best_metric_model_dunet") + + +# initialise Lightning's trainer. +trainer = pl.Trainer(devices=1, + max_epochs=n_epochs, + check_val_every_n_epoch=val_interval, + callbacks=checkpoint_callback, + default_root_dir=root_dir) + +# train +trainer.fit(d_net) + +# %% [markdown] +# ### Plotting sampling example + +# %% +# Sampling image during training +num_samples = 3 +val_loader = d_net.val_dataloader() +check_data = first(val_loader) +images = check_data["image"] +sampling_image = check_data["low_res_image"][:num_samples] + +# %% +latents = torch.randn((num_samples, 3, 16, 16)).to(images.device) +low_res_noise = torch.randn((num_samples, 1, 16, 16)).to(images.device) +noise_level = 10 +noise_level = torch.Tensor((noise_level,)).long().to(images.device) +scheduler = d_net.scheduler +noisy_low_res_image = scheduler.add_noise(original_samples=sampling_image, + noise=low_res_noise, + timesteps=torch.Tensor((noise_level,)).long()) + +scheduler.set_timesteps(num_inference_steps=1000) +for t in tqdm(scheduler.timesteps, ncols=110): + with torch.no_grad(): + with autocast(enabled=True): + latent_model_input = torch.cat([latents, noisy_low_res_image], dim=1) + noise_pred = d_net.forward(x=latent_model_input, + timesteps=torch.Tensor((t,)), + low_res_timesteps=noise_level) + + # 2. compute previous image: x_t -> x_t-1 + latents, _ = scheduler.step(noise_pred, t, latents) + +with torch.no_grad(): + decoded = ae_net.autoencoderkl.decode_stage_2_outputs(latents / scale_factor) + +# %% +low_res_bicubic = nn.functional.interpolate(sampling_image, (64, 64), mode="bicubic") +fig, axs = plt.subplots(num_samples, 3, figsize=(8, 8)) +axs[0, 0].set_title("Original image") +axs[0, 1].set_title("Low-resolution Image") +axs[0, 2].set_title("Outputted image") +for i in range(0, num_samples): + axs[i, 0].imshow(images[i, 0].cpu(), vmin=0, vmax=1, cmap="gray") + axs[i, 0].axis("off") + axs[i, 1].imshow(low_res_bicubic[i, 0].cpu(), vmin=0, vmax=1, cmap="gray") + axs[i, 1].axis("off") + axs[i, 2].imshow(decoded[i, 0].cpu(), vmin=0, vmax=1, cmap="gray") + axs[i, 2].axis("off") +plt.tight_layout() + +# %% [markdown] +# ### Clean-up data directory + +# %% +if directory is None: + shutil.rmtree(root_dir) From ed276ada2c6916dd4a4570b2b5fd278ee16f30fa Mon Sep 17 00:00:00 2001 From: OeslleLucena Date: Mon, 10 Apr 2023 18:43:57 +0100 Subject: [PATCH 03/13] [WIP] 2nd draft done --- ...fusion_v2_super_resolution-lightning.ipynb | 958 +++++++++++++----- ...diffusion_v2_super_resolution-lightning.py | 8 +- 2 files changed, 733 insertions(+), 233 deletions(-) diff --git a/tutorials/generative/2d_super_resolution/2d_stable_diffusion_v2_super_resolution-lightning.ipynb b/tutorials/generative/2d_super_resolution/2d_stable_diffusion_v2_super_resolution-lightning.ipynb index c722a653..5a56755e 100644 --- a/tutorials/generative/2d_super_resolution/2d_stable_diffusion_v2_super_resolution-lightning.ipynb +++ b/tutorials/generative/2d_super_resolution/2d_stable_diffusion_v2_super_resolution-lightning.ipynb @@ -84,14 +84,28 @@ "name": "stdout", "output_type": "stream", "text": [ - "2023-04-07 18:33:20,193 - WARNING[XFORMERS]: xFormers can't load C++/CUDA extensions. xFormers was built for:\n", + "2023-04-10 18:37:53,570 - WARNING[XFORMERS]: xFormers can't load C++/CUDA extensions. xFormers was built for:\n", " PyTorch 1.13.1+cu117 with CUDA 1107 (you have 1.12.1)\n", " Python 3.8.16 (you have 3.8.16)\n", " Please reinstall xformers (see https://github.com/facebookresearch/xformers#installing-xformers)\n", " Memory-efficient attention, SwiGLU, sparse and more won't be available.\n", - " Set XFORMERS_MORE_DETAILS=1 for more details\n", - "2023-04-07 18:33:21,929 - Created a temporary directory at /tmp/tmpq2wlch6q\n", - "2023-04-07 18:33:21,932 - Writing /tmp/tmpq2wlch6q/_remote_module_non_scriptable.py\n", + " Set XFORMERS_MORE_DETAILS=1 for more details\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "CUDA initialization: Unexpected error from cudaGetDeviceCount(). Did you run some cuda functions before calling NumCudaDevices() that might have already set an error? Error 804: forward compatibility was attempted on non supported HW (Triggered internally at /opt/conda/conda-bld/pytorch_1659484810403/work/c10/cuda/CUDAFunctions.cpp:109.)\n", + "User provided device_type of 'cuda', but CUDA is not available. Disabling\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2023-04-10 18:37:54,723 - Created a temporary directory at /tmp/tmpk_8ni2di\n", + "2023-04-10 18:37:54,724 - Writing /tmp/tmpk_8ni2di/_remote_module_non_scriptable.py\n", "MONAI version: 1.2.dev2304\n", "Numpy version: 1.23.5\n", "Pytorch version: 1.12.1\n", @@ -181,7 +195,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "/tmp/tmp1sbvw3_e\n" + "/tmp/tmpa48mavq5\n" ] } ], @@ -240,7 +254,8 @@ " transforms.Resized(keys=[\"low_res_image\"], spatial_size=(16, 16)),\n", " ]\n", " )\n", - " return val_transforms\n" + " return val_transforms\n", + "\n" ] }, { @@ -400,24 +415,25 @@ "name": "stdout", "output_type": "stream", "text": [ - "2023-04-07 18:33:24,966 - GPU available: True (cuda), used: True\n", - "2023-04-07 18:33:24,967 - TPU available: False, using: 0 TPU cores\n", - "2023-04-07 18:33:24,968 - IPU available: False, using: 0 IPUs\n", - "2023-04-07 18:33:24,968 - HPU available: False, using: 0 HPUs\n" + "2023-04-10 18:37:58,137 - GPU available: False, used: False\n", + "2023-04-10 18:37:58,138 - TPU available: False, using: 0 TPU cores\n", + "2023-04-10 18:37:58,140 - IPU available: False, using: 0 IPUs\n", + "2023-04-10 18:37:58,141 - HPU available: False, using: 0 HPUs\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "MedNIST.tar.gz: 59.0MB [00:02, 23.0MB/s] " + "Can't initialize NVML\n", + "MedNIST.tar.gz: 59.0MB [00:02, 23.5MB/s] " ] }, { "name": "stdout", "output_type": "stream", "text": [ - "2023-04-07 18:33:27,673 - INFO - Downloaded: /tmp/tmp1sbvw3_e/MedNIST.tar.gz\n" + "2023-04-10 18:38:00,799 - INFO - Downloaded: /tmp/tmpa48mavq5/MedNIST.tar.gz\n" ] }, { @@ -431,55 +447,55 @@ "name": "stdout", "output_type": "stream", "text": [ - "2023-04-07 18:33:27,791 - INFO - Verified 'MedNIST.tar.gz', md5: 0bc7306e7427e00ad1c5526a6677552d.\n", - "2023-04-07 18:33:27,792 - INFO - Writing into directory: /tmp/tmp1sbvw3_e.\n" + "2023-04-10 18:38:00,916 - INFO - Verified 'MedNIST.tar.gz', md5: 0bc7306e7427e00ad1c5526a6677552d.\n", + "2023-04-10 18:38:00,918 - INFO - Writing into directory: /tmp/tmpa48mavq5.\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "Loading dataset: 100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 47164/47164 [00:40<00:00, 1177.19it/s]\n" + "Loading dataset: 100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 47164/47164 [00:45<00:00, 1047.66it/s]\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "2023-04-07 18:34:17,104 - INFO - Verified 'MedNIST.tar.gz', md5: 0bc7306e7427e00ad1c5526a6677552d.\n", - "2023-04-07 18:34:17,105 - INFO - File exists: /tmp/tmp1sbvw3_e/MedNIST.tar.gz, skipped downloading.\n", - "2023-04-07 18:34:17,107 - INFO - Non-empty folder exists in /tmp/tmp1sbvw3_e/MedNIST, skipped extracting.\n" + "2023-04-10 18:38:55,238 - INFO - Verified 'MedNIST.tar.gz', md5: 0bc7306e7427e00ad1c5526a6677552d.\n", + "2023-04-10 18:38:55,240 - INFO - File exists: /tmp/tmpa48mavq5/MedNIST.tar.gz, skipped downloading.\n", + "2023-04-10 18:38:55,242 - INFO - Non-empty folder exists in /tmp/tmpa48mavq5/MedNIST, skipped extracting.\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "Loading dataset: 100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 5895/5895 [00:04<00:00, 1228.05it/s]\n", - "Loading dataset: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 7991/7991 [00:11<00:00, 715.18it/s]\n", - "Loading dataset: 100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 972/972 [00:02<00:00, 442.12it/s]\n" + "Loading dataset: 100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 5895/5895 [00:05<00:00, 1061.53it/s]\n", + "Loading dataset: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 7991/7991 [00:12<00:00, 637.95it/s]\n", + "Loading dataset: 100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 972/972 [00:02<00:00, 414.79it/s]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "2023-04-07 18:34:35,829 - Missing logger folder: /tmp/tmp1sbvw3_e/lightning_logs\n" + "2023-04-10 18:39:16,217 - Missing logger folder: /tmp/tmpa48mavq5/lightning_logs\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "Checkpoint directory /tmp/tmp1sbvw3_e exists and is not empty.\n" + "\n", + "Checkpoint directory /tmp/tmpa48mavq5 exists and is not empty.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "2023-04-07 18:34:37,274 - LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0,1]\n", - "2023-04-07 18:34:37,290 - \n", + "2023-04-10 18:39:16,255 - \n", " | Name | Type | Params\n", "---------------------------------------------------------\n", "0 | autoencoderkl | AutoencoderKL | 75.1 M\n", @@ -491,7 +507,7 @@ "2.5 M Non-trainable params\n", "80.3 M Total params\n", "321.225 Total estimated model params size (MB)\n", - "Sanity Checking DataLoader 0: 100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████| 2/2 [00:01<00:00, 1.30it/s]" + "Sanity Checking DataLoader 0: 50%|███████████████████████████████████████████████████████ | 1/2 [00:04<00:04, 4.34s/it]" ] }, { @@ -505,99 +521,20 @@ "name": "stdout", "output_type": "stream", "text": [ - "Epoch 0: 100%|███████████████████████████████████████████████████████████████████████████████████| 500/500 [05:34<00:00, 1.50it/s, v_num=0, recons_loss=0.0421, loss_g=0.0443]\n", - "Validation: 0it [00:00, ?it/s]\u001b[A\n", - "Validation: 0%| | 0/61 [00:00" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "low_res_bicubic = nn.functional.interpolate(sampling_image, (64, 64), mode=\"bicubic\")\n", "fig, axs = plt.subplots(num_samples, 3, figsize=(8, 8))\n", @@ -1055,7 +1555,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": null, "id": "3a6f6d5a", "metadata": {}, "outputs": [], diff --git a/tutorials/generative/2d_super_resolution/2d_stable_diffusion_v2_super_resolution-lightning.py b/tutorials/generative/2d_super_resolution/2d_stable_diffusion_v2_super_resolution-lightning.py index 0449491c..14d36417 100644 --- a/tutorials/generative/2d_super_resolution/2d_stable_diffusion_v2_super_resolution-lightning.py +++ b/tutorials/generative/2d_super_resolution/2d_stable_diffusion_v2_super_resolution-lightning.py @@ -256,8 +256,8 @@ def configure_optimizers(self): # ## Train Autoencoder # %% -n_epochs = 1 -val_interval = 1 +n_epochs = 75 +val_interval = 10 # initialise the LightningModule @@ -398,8 +398,8 @@ def configure_optimizers(self): # As mentioned, we will use the conditioned augmentation (introduced in [2] section 3 and used on Stable Diffusion Upscalers and Imagen Video [3] Section 2.5) as it has been shown critical for cascaded diffusion models, as well for super-resolution tasks. For this, we apply Gaussian noise augmentation to the low-resolution images. We will use a scheduler low_res_scheduler to add this noise, with the t step defining the signal-to-noise ratio and use the t value to condition the diffusion model (inputted using class_labels argument). # %% -n_epochs = 3 -val_interval = 3 +n_epochs = 200 +val_interval = 20 # initialise the LightningModule From aea030200153f8865cd03bf764d6d026f522d7a6 Mon Sep 17 00:00:00 2001 From: OeslleLucena Date: Wed, 12 Apr 2023 15:13:23 +0100 Subject: [PATCH 04/13] Tutorial with a few images --- ...fusion_v2_super_resolution-lightning.ipynb | 1883 +++++++++-------- ...diffusion_v2_super_resolution-lightning.py | 285 ++- 2 files changed, 1176 insertions(+), 992 deletions(-) diff --git a/tutorials/generative/2d_super_resolution/2d_stable_diffusion_v2_super_resolution-lightning.ipynb b/tutorials/generative/2d_super_resolution/2d_stable_diffusion_v2_super_resolution-lightning.ipynb index 5a56755e..1b8251da 100644 --- a/tutorials/generative/2d_super_resolution/2d_stable_diffusion_v2_super_resolution-lightning.ipynb +++ b/tutorials/generative/2d_super_resolution/2d_stable_diffusion_v2_super_resolution-lightning.ipynb @@ -72,40 +72,18 @@ "id": "de71fe08", "metadata": {}, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/ol18/miniconda3/envs/monai_generative/lib/python3.8/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", - " from .autonotebook import tqdm as notebook_tqdm\n" - ] - }, { "name": "stdout", "output_type": "stream", "text": [ - "2023-04-10 18:37:53,570 - WARNING[XFORMERS]: xFormers can't load C++/CUDA extensions. xFormers was built for:\n", + "2023-04-12 14:09:21,976 - WARNING[XFORMERS]: xFormers can't load C++/CUDA extensions. xFormers was built for:\n", " PyTorch 1.13.1+cu117 with CUDA 1107 (you have 1.12.1)\n", " Python 3.8.16 (you have 3.8.16)\n", " Please reinstall xformers (see https://github.com/facebookresearch/xformers#installing-xformers)\n", " Memory-efficient attention, SwiGLU, sparse and more won't be available.\n", - " Set XFORMERS_MORE_DETAILS=1 for more details\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "CUDA initialization: Unexpected error from cudaGetDeviceCount(). Did you run some cuda functions before calling NumCudaDevices() that might have already set an error? Error 804: forward compatibility was attempted on non supported HW (Triggered internally at /opt/conda/conda-bld/pytorch_1659484810403/work/c10/cuda/CUDAFunctions.cpp:109.)\n", - "User provided device_type of 'cuda', but CUDA is not available. Disabling\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2023-04-10 18:37:54,723 - Created a temporary directory at /tmp/tmpk_8ni2di\n", - "2023-04-10 18:37:54,724 - Writing /tmp/tmpk_8ni2di/_remote_module_non_scriptable.py\n", + " Set XFORMERS_MORE_DETAILS=1 for more details\n", + "2023-04-12 14:09:23,860 - Created a temporary directory at /tmp/tmpo49u4ma3\n", + "2023-04-12 14:09:23,864 - Writing /tmp/tmpo49u4ma3/_remote_module_non_scriptable.py\n", "MONAI version: 1.2.dev2304\n", "Numpy version: 1.23.5\n", "Pytorch version: 1.12.1\n", @@ -141,6 +119,7 @@ "import os\n", "import shutil\n", "import tempfile\n", + "from pathlib import Path\n", "\n", "import matplotlib.pyplot as plt\n", "import numpy as np\n", @@ -149,11 +128,11 @@ "from monai import transforms\n", "from monai.apps import MedNISTDataset\n", "from monai.config import print_config\n", - "from monai.data import CacheDataset, DataLoader\n", + "from monai.data import CacheDataset, ThreadDataLoader\n", "from monai.utils import first, set_determinism\n", - "from torch import nn\n", "from torch.cuda.amp import GradScaler, autocast\n", - "from tqdm import tqdm\n", + "from torch import nn\n", + "from tqdm.notebook import tqdm\n", "\n", "from generative.losses import PatchAdversarialLoss, PerceptualLoss\n", "from generative.networks.nets import AutoencoderKL, DiffusionModelUNet, PatchDiscriminator\n", @@ -195,7 +174,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "/tmp/tmpa48mavq5\n" + "/tmp/tmpizuu167z\n" ] } ], @@ -205,6 +184,74 @@ "print(root_dir)" ] }, + { + "cell_type": "code", + "execution_count": 6, + "id": "298d964a", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "MedNIST.tar.gz: 59.0MB [00:11, 5.17MB/s] " + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2023-04-12 14:09:35,992 - INFO - Downloaded: /tmp/tmpizuu167z/MedNIST.tar.gz\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2023-04-12 14:09:36,099 - INFO - Verified 'MedNIST.tar.gz', md5: 0bc7306e7427e00ad1c5526a6677552d.\n", + "2023-04-12 14:09:36,100 - INFO - Writing into directory: /tmp/tmpizuu167z.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Loading dataset: 100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████| 47164/47164 [00:35<00:00, 1335.82it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2023-04-12 14:10:20,302 - INFO - Verified 'MedNIST.tar.gz', md5: 0bc7306e7427e00ad1c5526a6677552d.\n", + "2023-04-12 14:10:20,303 - INFO - File exists: /tmp/tmpizuu167z/MedNIST.tar.gz, skipped downloading.\n", + "2023-04-12 14:10:20,304 - INFO - Non-empty folder exists in /tmp/tmpizuu167z/MedNIST, skipped extracting.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Loading dataset: 100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████| 5895/5895 [00:04<00:00, 1332.80it/s]\n" + ] + } + ], + "source": [ + "train_data = MedNISTDataset(root_dir=root_dir, section=\"training\",\n", + " download=True, seed=0)\n", + "train_datalist = [{\"image\": item[\"image\"]} for item in train_data.data if item[\"class_name\"] == \"HeadCT\"]\n", + "val_data = MedNISTDataset(root_dir=root_dir, section=\"validation\",\n", + " download=True, seed=0)\n", + "val_datalist = [{\"image\": item[\"image\"]} for item in val_data.data if item[\"class_name\"] == \"HeadCT\"]" + ] + }, { "cell_type": "markdown", "id": "46bafb78", @@ -215,7 +262,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 7, "id": "4f8eff03", "metadata": {}, "outputs": [], @@ -255,6 +302,14 @@ " ]\n", " )\n", " return val_transforms\n", + "\n", + " \n", + "def get_datasets():\n", + " train_transforms = get_train_transforms()\n", + " val_transforms = get_val_transforms()\n", + " train_ds = CacheDataset(data=train_datalist[:320], transform=train_transforms)\n", + " val_ds = CacheDataset(data=val_datalist[:32], transform=val_transforms)\n", + " return train_ds, val_ds\n", "\n" ] }, @@ -269,7 +324,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 8, "id": "d5d1caff", "metadata": { "scrolled": false @@ -302,23 +357,14 @@ " return self.autoencoderkl(z)\n", "\n", " def prepare_data(self):\n", - " train_transforms = get_train_transforms()\n", - " val_transforms = get_val_transforms()\n", - " \n", - " train_data = MedNISTDataset(root_dir=self.data_dir, section=\"training\", download=True, seed=0)\n", - " train_datalist = [{\"image\": item[\"image\"]} for item in train_data.data if item[\"class_name\"] == \"HeadCT\"]\n", - " val_data = MedNISTDataset(root_dir=self.data_dir, section=\"validation\", download=True, seed=0)\n", - " val_datalist = [{\"image\": item[\"image\"]} for item in val_data.data if item[\"class_name\"] == \"HeadCT\"]\n", - " \n", - " self.train_ds = CacheDataset(data=train_datalist, transform=train_transforms)\n", - " self.val_ds = CacheDataset(data=val_datalist, transform=val_transforms)\n", - " \n", + " self.train_ds, self.val_ds = get_datasets()\n", + " \n", " def train_dataloader(self):\n", - " return DataLoader(self.train_ds, batch_size=16, shuffle=True,\n", + " return ThreadDataLoader(self.train_ds, batch_size=16, shuffle=True,\n", " num_workers=4, persistent_workers=True)\n", " \n", " def val_dataloader(self):\n", - " return DataLoader(self.val_ds, batch_size=16, shuffle=False,\n", + " return ThreadDataLoader(self.val_ds, batch_size=16, shuffle=False,\n", " num_workers=4)\n", " \n", " def _compute_loss_generator(self, images, reconstruction, z_mu, z_sigma):\n", @@ -329,11 +375,11 @@ " loss_g = recons_loss + (self.kl_weight * kl_loss) + (self.perceptual_weight * p_loss)\n", " return loss_g,recons_loss\n", " \n", - " def _compute_loss_discriminator(self, reconstruction):\n", - " logits_fake = discriminator(reconstruction.contiguous().detach())[-1]\n", + " def _compute_loss_discriminator(self, images, reconstruction):\n", + " logits_fake = self.discriminator(reconstruction.contiguous().detach())[-1]\n", " loss_d_fake = self.adv_loss(logits_fake, target_is_real=False, for_discriminator=True)\n", - " logits_real = discriminator(images.contiguous().detach())[-1]\n", - " loss_d_real = adv_loss(logits_real, target_is_real=True, for_discriminator=True)\n", + " logits_real = self.discriminator(images.contiguous().detach())[-1]\n", + " loss_d_real = self.adv_loss(logits_real, target_is_real=True, for_discriminator=True)\n", " discriminator_loss = (loss_d_fake + loss_d_real) * 0.5\n", " loss_d = self.adv_weight * discriminator_loss\n", " return loss_d, discriminator_loss\n", @@ -346,9 +392,11 @@ " self.log(\"recons_loss\", recons_loss, batch_size=16, prog_bar=True)\n", "\n", " if self.current_epoch > self.autoencoder_warm_up_n_epochs:\n", - " logits_fake = discriminator(reconstruction.contiguous().float())[-1]\n", - " generator_loss = adv_loss(logits_fake, target_is_real=True, for_discriminator=False)\n", - " loss_g += adv_weight * generator_loss\n", + " logits_fake = self.discriminator(reconstruction.contiguous().float())[-1]\n", + " generator_loss = self.adv_loss(logits_fake, target_is_real=True, for_discriminator=False)\n", + " loss_g += self.adv_weight * generator_loss\n", + " self.log(\"gen_loss\", generator_loss, batch_size=16, prog_bar=True)\n", + " \n", " \n", "\n", " self.log(\"loss_g\", loss_g, batch_size=16, prog_bar=True)\n", @@ -358,7 +406,8 @@ " self.untoggle_optimizer(optimizer_g)\n", "\n", " if self.current_epoch > self.autoencoder_warm_up_n_epochs:\n", - " loss_d, discriminator_loss = self._compute_loss_discriminator(reconstruction)\n", + " loss_d, discriminator_loss = self._compute_loss_discriminator(images, reconstruction)\n", + " self.log(\"disc_loss\", loss_d, batch_size=16, prog_bar=True)\n", " self.log(\"train_loss_d\", loss_d, batch_size=16, prog_bar=True)\n", " self.manual_backward(loss_d)\n", " optimizer_d.step()\n", @@ -366,19 +415,26 @@ " self.untoggle_optimizer(optimizer_d)\n", "\n", " \n", - " if self.current_epoch > self.autoencoder_warm_up_n_epochs:\n", - " gen_epoch_loss += generator_loss.item()\n", - " disc_epoch_loss += discriminator_loss.item()\n", - " self.log(\"gen_loss\", gen_loss, batch_size=16, prog_bar=True)\n", - " self.log(\"disc_loss\", disc_loss, batch_size=16, prog_bar=True)\n", - " \n", " \n", " def validation_step(self, batch, batch_idx):\n", " images = batch[\"image\"]\n", " reconstruction, z_mu, z_sigma = self.autoencoderkl(images)\n", " recons_loss = F.l1_loss(images.float(), reconstruction.float())\n", - " self.log(\"val_loss_d\", recons_loss, prog_bar=True)\n", - " \n", + " self.log(\"val_loss_d\", recons_loss, batch_size=1, prog_bar=True)\n", + " self.images = images\n", + " self.reconstruction = reconstruction\n", + "\n", + "\n", + " def on_validation_epoch_end(self):\n", + " # ploting reconstruction\n", + " plt.figure(figsize=(2, 2))\n", + " plt.imshow(torch.cat([self.images[0, 0].cpu(), \n", + " self.reconstruction[0, 0].cpu()],\n", + " dim=1), vmin=0, vmax=1, cmap=\"gray\")\n", + " plt.tight_layout()\n", + " plt.axis(\"off\")\n", + " plt.show()\n", + " \n", "\n", " def configure_optimizers(self):\n", " optimizer_g = torch.optim.Adam(self.autoencoderkl.parameters(), lr=5e-5)\n", @@ -397,7 +453,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 9, "id": "9d903aaa", "metadata": { "scrolled": true @@ -415,125 +471,253 @@ "name": "stdout", "output_type": "stream", "text": [ - "2023-04-10 18:37:58,137 - GPU available: False, used: False\n", - "2023-04-10 18:37:58,138 - TPU available: False, using: 0 TPU cores\n", - "2023-04-10 18:37:58,140 - IPU available: False, using: 0 IPUs\n", - "2023-04-10 18:37:58,141 - HPU available: False, using: 0 HPUs\n" + "2023-04-12 14:10:27,910 - GPU available: True (cuda), used: True\n", + "2023-04-12 14:10:27,911 - TPU available: False, using: 0 TPU cores\n", + "2023-04-12 14:10:27,912 - IPU available: False, using: 0 IPUs\n", + "2023-04-12 14:10:27,913 - HPU available: False, using: 0 HPUs\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "Can't initialize NVML\n", - "MedNIST.tar.gz: 59.0MB [00:02, 23.5MB/s] " + "Loading dataset: 100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████| 320/320 [00:00<00:00, 892.62it/s]\n", + "Loading dataset: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 32/32 [00:00<00:00, 413.74it/s]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "2023-04-10 18:38:00,799 - INFO - Downloaded: /tmp/tmpa48mavq5/MedNIST.tar.gz\n" + "2023-04-12 14:10:28,377 - Missing logger folder: /tmp/tmpizuu167z/lightning_logs\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "\n" + "\n", + "Checkpoint directory /tmp/tmpizuu167z exists and is not empty.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "2023-04-10 18:38:00,916 - INFO - Verified 'MedNIST.tar.gz', md5: 0bc7306e7427e00ad1c5526a6677552d.\n", - "2023-04-10 18:38:00,918 - INFO - Writing into directory: /tmp/tmpa48mavq5.\n" + "2023-04-12 14:10:29,835 - LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0,1]\n", + "2023-04-12 14:10:29,850 - \n", + " | Name | Type | Params\n", + "---------------------------------------------------------\n", + "0 | autoencoderkl | AutoencoderKL | 75.1 M\n", + "1 | discriminator | PatchDiscriminator | 2.8 M \n", + "2 | perceptual_loss | PerceptualLoss | 2.5 M \n", + "3 | adv_loss | PatchAdversarialLoss | 0 \n", + "---------------------------------------------------------\n", + "77.8 M Trainable params\n", + "2.5 M Non-trainable params\n", + "80.3 M Total params\n", + "321.225 Total estimated model params size (MB)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "Loading dataset: 100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 47164/47164 [00:45<00:00, 1047.66it/s]\n" + "The number of training batches (20) is smaller than the logging interval Trainer(log_every_n_steps=50). Set a lower value for log_every_n_steps if you want to see logs for the training epoch.\n" ] }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "2023-04-10 18:38:55,238 - INFO - Verified 'MedNIST.tar.gz', md5: 0bc7306e7427e00ad1c5526a6677552d.\n", - "2023-04-10 18:38:55,240 - INFO - File exists: /tmp/tmpa48mavq5/MedNIST.tar.gz, skipped downloading.\n", - "2023-04-10 18:38:55,242 - INFO - Non-empty folder exists in /tmp/tmpa48mavq5/MedNIST, skipped extracting.\n" - ] + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "a7a5ce61b3dd41b386312a100272db42", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Training: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" }, { - "name": "stderr", - "output_type": "stream", - "text": [ - "Loading dataset: 100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 5895/5895 [00:05<00:00, 1061.53it/s]\n", - "Loading dataset: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 7991/7991 [00:12<00:00, 637.95it/s]\n", - "Loading dataset: 100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 972/972 [00:02<00:00, 414.79it/s]" - ] + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "2023-04-10 18:39:16,217 - Missing logger folder: /tmp/tmpa48mavq5/lightning_logs\n" - ] + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" }, { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n", - "Checkpoint directory /tmp/tmpa48mavq5 exists and is not empty.\n" - ] + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "2023-04-10 18:39:16,255 - \n", - " | Name | Type | Params\n", - "---------------------------------------------------------\n", - "0 | autoencoderkl | AutoencoderKL | 75.1 M\n", - "1 | discriminator | PatchDiscriminator | 2.8 M \n", - "2 | perceptual_loss | PerceptualLoss | 2.5 M \n", - "3 | adv_loss | PatchAdversarialLoss | 0 \n", - "---------------------------------------------------------\n", - "77.8 M Trainable params\n", - "2.5 M Non-trainable params\n", - "80.3 M Total params\n", - "321.225 Total estimated model params size (MB)\n", - "Sanity Checking DataLoader 0: 50%|███████████████████████████████████████████████████████ | 1/2 [00:04<00:04, 4.34s/it]" - ] + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" }, { - "name": "stderr", - "output_type": "stream", - "text": [ - "Trying to infer the `batch_size` from an ambiguous collection. The batch size we found is 16. To avoid any miscalculations, use `self.log(..., batch_size=batch_size)`.\n" - ] + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "Epoch 0: 2%|█▎ | 8/500 [01:59<2:02:20, 14.92s/it, v_num=0, recons_loss=0.212, loss_g=0.215]" - ] + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" }, { - "name": "stderr", + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", "output_type": "stream", "text": [ - "Detected KeyboardInterrupt, attempting graceful shutdown...\n" + "2023-04-12 14:28:55,430 - `Trainer.fit` stopped: `max_epochs=75` reached.\n" ] } ], "source": [ - "n_epochs = 75\n", + "n_epochs = 75 \n", "val_interval = 10\n", "\n", " \n", @@ -549,6 +733,7 @@ "trainer = pl.Trainer(devices=1,\n", " max_epochs=n_epochs,\n", " check_val_every_n_epoch=val_interval,\n", + " num_sanity_val_steps=0,\n", " callbacks=checkpoint_callback,\n", " default_root_dir=root_dir)\n", "\n", @@ -568,7 +753,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 10, "id": "ccb6ba9f", "metadata": {}, "outputs": [ @@ -576,16 +761,24 @@ "name": "stdout", "output_type": "stream", "text": [ - "Scaling factor set to 0.3829643428325653\n" + "Scaling factor set to 0.5467963814735413\n" ] } ], "source": [ - "train_loader = ae_net.train_dataloader()\n", - "check_data = first(train_loader)\n", - "z = ae_net.autoencoderkl.train(mode=False).encode_stage_2_inputs(check_data[\"image\"].to(ae_net.device))\n", - "print(f\"Scaling factor set to {1/torch.std(z)}\")\n", - "scale_factor = 1 / torch.std(z)" + "def get_scaler_factor():\n", + " ae_net.eval()\n", + " device = torch.device(\"cuda:0\")\n", + " ae_net.to(device)\n", + "\n", + " train_loader = ae_net.train_dataloader()\n", + " check_data = first(train_loader)\n", + " z = ae_net.autoencoderkl.encode_stage_2_inputs(check_data[\"image\"].to(ae_net.device))\n", + " print(f\"Scaling factor set to {1/torch.std(z)}\")\n", + " scale_factor = 1 / torch.std(z)\n", + " return scale_factor\n", + "\n", + "scale_factor = get_scaler_factor()" ] }, { @@ -599,7 +792,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 11, "id": "731034ec", "metadata": { "lines_to_next_cell": 2 @@ -624,7 +817,7 @@ " beta_schedule=\"linear\",\n", " beta_start=0.0015,\n", " beta_end=0.0195)\n", - " self.z = ae_net.autoencoderkl.train(mode=False)\n", + " self.z = ae_net.autoencoderkl.eval()\n", "\n", "\n", " def forward(self, x, timesteps, low_res_timesteps):\n", @@ -632,68 +825,106 @@ " timesteps=timesteps,\n", " class_labels=low_res_timesteps)\n", " \n", - " \n", + " \n", " def prepare_data(self):\n", - " train_transforms = get_train_transforms()\n", - " val_transforms = get_val_transforms()\n", - " \n", - " train_data = MedNISTDataset(root_dir=self.data_dir, section=\"training\",\n", - " download=True, seed=0)\n", - " train_datalist = [{\"image\": item[\"image\"]} for item in train_data.data if item[\"class_name\"] == \"HeadCT\"]\n", - " val_data = MedNISTDataset(root_dir=self.data_dir, section=\"validation\",\n", - " download=True, seed=0)\n", - " val_datalist = [{\"image\": item[\"image\"]} for item in val_data.data if item[\"class_name\"] == \"HeadCT\"]\n", - " \n", - " self.train_ds = CacheDataset(data=train_datalist, transform=train_transforms)\n", - " self.val_ds = CacheDataset(data=val_datalist, transform=val_transforms)\n", + " self.train_ds, self.val_ds = get_datasets()\n", " \n", " def train_dataloader(self):\n", " return DataLoader(self.train_ds, batch_size=16, shuffle=True,\n", " num_workers=4, persistent_workers=True)\n", " \n", " def val_dataloader(self):\n", - " return DataLoader(self.val_ds, batch_size=16, shuffle=True,\n", + " return DataLoader(self.val_ds, batch_size=16, shuffle=False,\n", " num_workers=4)\n", " \n", - " def _calculate_loss(self, batch, batch_idx):\n", + " def _calculate_loss(self, batch, batch_idx, plt_image=False):\n", " images = batch[\"image\"]\n", - " low_res_image = batch[\"low_res_image\"] \n", - " latent = self.z.encode_stage_2_inputs(images) * scale_factor\n", - " latent = latent.detach() # avoid adding this to graph.\n", - " optimizer = self.optimizers()\n", + " low_res_image = batch[\"low_res_image\"] \n", + " with autocast(enabled=True):\n", + " with torch.no_grad():\n", + " latent = self.z.encode_stage_2_inputs(images) * scale_factor\n", + "# latent = latent.detach() # avoid adding this to graph.\n", " \n", - " # Noise augmentation\n", - " noise = torch.randn_like(latent)\n", - " low_res_noise = torch.randn_like(low_res_image)\n", - " timesteps = torch.randint(0, self.scheduler.num_train_timesteps, (latent.shape[0],),\n", - " device=latent.device).long()\n", - " low_res_timesteps = torch.randint(\n", - " 0, self.max_noise_level, (low_res_image.shape[0],), device=latent.device\n", - " ).long()\n", "\n", - " noisy_latent = self.scheduler.add_noise(original_samples=latent, \n", - " noise=noise, timesteps=timesteps)\n", - " noisy_low_res_image = self.scheduler.add_noise(\n", - " original_samples=low_res_image, noise=low_res_noise, \n", - " timesteps=low_res_timesteps\n", - " )\n", + " # Noise augmentation\n", + " noise = torch.randn_like(latent)\n", + " low_res_noise = torch.randn_like(low_res_image)\n", + " timesteps = torch.randint(0, self.scheduler.num_train_timesteps, (latent.shape[0],),\n", + " device=latent.device).long()\n", + " low_res_timesteps = torch.randint(\n", + " 0, self.max_noise_level, (low_res_image.shape[0],), device=latent.device\n", + " ).long()\n", + "\n", + " noisy_latent = self.scheduler.add_noise(original_samples=latent, \n", + " noise=noise, timesteps=timesteps)\n", + " noisy_low_res_image = self.scheduler.add_noise(\n", + " original_samples=low_res_image, noise=low_res_noise, \n", + " timesteps=low_res_timesteps\n", + " )\n", "\n", - " latent_model_input = torch.cat([noisy_latent, noisy_low_res_image], dim=1)\n", + " latent_model_input = torch.cat([noisy_latent, noisy_low_res_image], dim=1)\n", "\n", - " noise_pred = self.forward(latent_model_input, timesteps, low_res_timesteps)\n", - " loss = F.mse_loss(noise_pred.float(), noise.float())\n", + " noise_pred = self.forward(latent_model_input, timesteps, low_res_timesteps)\n", + " loss = F.mse_loss(noise_pred.float(), noise.float())\n", + " \n", + " if plt_image:\n", + " # Sampling image during training\n", + " sampling_image = low_res_image[0].unsqueeze(0)\n", + " latents = torch.randn((1, 3, 16, 16)).to(sampling_image.device)\n", + " low_res_noise = torch.randn((1, 1, 16, 16)).to(sampling_image.device)\n", + " noise_level = 20\n", + " noise_level = torch.Tensor((noise_level,)).long().to(sampling_image.device)\n", + " \n", + " noisy_low_res_image = self.scheduler.add_noise(\n", + " original_samples=sampling_image,\n", + " noise=low_res_noise,\n", + " timesteps=noise_level,\n", + " )\n", + " self.scheduler.set_timesteps(num_inference_steps=1000)\n", + " for t in tqdm(self.scheduler.timesteps, ncols=110):\n", + " with autocast(enabled=True):\n", + " with torch.no_grad():\n", + " latent_model_input = torch.cat([latents, noisy_low_res_image], dim=1)\n", + " noise_pred = self.forward(latent_model_input, \n", + " torch.Tensor((t,)).to(sampling_image.device)\n", + " , noise_level)\n", + " latents, _ = self.scheduler.step(noise_pred, t, latents)\n", + " with torch.no_grad():\n", + " decoded = self.z.decode_stage_2_outputs(latents / scale_factor)\n", + " low_res_bicubic = nn.functional.interpolate(sampling_image, (64, 64), mode=\"bicubic\")\n", + " # plot images\n", + " \n", + " self.images = images\n", + " self.low_res_bicubic = low_res_bicubic\n", + " self.decoded = decoded\n", + " \n", " return loss\n", + " \n", + " def _plot_image(self, images, low_res_bicubic, decoded):\n", + " plt.figure(figsize=(2, 2))\n", + " plt.style.use(\"default\")\n", + " plt.imshow(\n", + " torch.cat([images[0, 0].cpu(), low_res_bicubic[0, 0].cpu(), decoded[0, 0].cpu()], dim=1),\n", + " vmin=0,\n", + " vmax=1,\n", + " cmap=\"gray\",\n", + " )\n", + " plt.tight_layout()\n", + " plt.axis(\"off\")\n", + " plt.show()\n", "\n", " def training_step(self, batch, batch_idx):\n", " loss = self._calculate_loss(batch, batch_idx)\n", " self.log(\"train_loss\", loss, batch_size=16, prog_bar=True)\n", " return loss\n", - "\n", " \n", " def validation_step(self, batch, batch_idx):\n", - " loss = self._calculate_loss(batch, batch_idx)\n", + " loss = self._calculate_loss(batch, batch_idx, plt_image=True)\n", " self.log(\"val_loss\", loss, batch_size=16, prog_bar=True)\n", " return loss\n", + " \n", + " def on_validation_epoch_end(self):\n", + " self._plot_image(self.images, self.low_res_bicubic, self.decoded)\n", "\n", " def configure_optimizers(self):\n", " optimizer = torch.optim.Adam(self.unet.parameters(), lr=5e-5)\n", @@ -714,733 +945,587 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, "id": "936bbb9c", "metadata": { - "scrolled": true + "scrolled": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "2023-04-10 18:41:46,760 - GPU available: False, used: False\n", - "2023-04-10 18:41:46,761 - TPU available: False, using: 0 TPU cores\n", - "2023-04-10 18:41:46,762 - IPU available: False, using: 0 IPUs\n", - "2023-04-10 18:41:46,762 - HPU available: False, using: 0 HPUs\n", - "2023-04-10 18:41:46,869 - INFO - Verified 'MedNIST.tar.gz', md5: 0bc7306e7427e00ad1c5526a6677552d.\n", - "2023-04-10 18:41:46,869 - INFO - File exists: /tmp/tmpa48mavq5/MedNIST.tar.gz, skipped downloading.\n", - "2023-04-10 18:41:46,870 - INFO - Non-empty folder exists in /tmp/tmpa48mavq5/MedNIST, skipped extracting.\n" + "2023-04-12 14:29:00,910 - GPU available: True (cuda), used: True\n", + "2023-04-12 14:29:00,911 - TPU available: False, using: 0 TPU cores\n", + "2023-04-12 14:29:00,912 - IPU available: False, using: 0 IPUs\n", + "2023-04-12 14:29:00,912 - HPU available: False, using: 0 HPUs\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "\n", - "Loading dataset: 0%| | 0/47164 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" }, { - "name": "stderr", - "output_type": "stream", - "text": [ - "Loading dataset: 78%|███████████████████████████████████████████████████████████████████████████████████████▋ | 36587/47164 [00:34<00:08, 1279.91it/s]\u001b[A\n", - "Loading dataset: 78%|███████████████████████████████████████████████████████████████████████████████████████▉ | 36717/47164 [00:34<00:08, 1185.00it/s]\u001b[A\n", - "Loading dataset: 78%|████████████████████████████████████████████████████████████████████████████████████████▎ | 36838/47164 [00:35<00:08, 1167.00it/s]\u001b[A\n", - "Loading dataset: 78%|████████████████████████████████████████████████████████████████████████████████████████▌ | 36957/47164 [00:35<00:09, 1059.20it/s]\u001b[A\n", - "Loading dataset: 79%|████████████████████████████████████████████████████████████████████████████████████████▊ | 37075/47164 [00:35<00:09, 1090.10it/s]\u001b[A\n", - "Loading dataset: 79%|█████████████████████████████████████████████████████████████████████████████████████████ | 37198/47164 [00:35<00:08, 1124.17it/s]\u001b[A\n", - "Loading dataset: 79%|█████████████████████████████████████████████████████████████████████████████████████████▍ | 37339/47164 [00:35<00:08, 1202.85it/s]\u001b[A\n", - "Loading dataset: 79%|█████████████████████████████████████████████████████████████████████████████████████████▊ | 37462/47164 [00:35<00:08, 1207.10it/s]\u001b[A\n", - "Loading dataset: 80%|██████████████████████████████████████████████████████████████████████████████████████████ | 37584/47164 [00:35<00:08, 1156.27it/s]\u001b[A\n", - "Loading dataset: 80%|██████████████████████████████████████████████████████████████████████████████████████████▎ | 37701/47164 [00:35<00:08, 1155.89it/s]\u001b[A\n", - "Loading dataset: 80%|██████████████████████████████████████████████████████████████████████████████████████████▌ | 37818/47164 [00:35<00:08, 1107.98it/s]\u001b[A\n", - "Loading dataset: 80%|██████████████████████████████████████████████████████████████████████████████████████████▉ | 37930/47164 [00:36<00:08, 1090.45it/s]\u001b[A\n", - "Loading dataset: 81%|███████████████████████████████████████████████████████████████████████████████████████████▏ | 38046/47164 [00:36<00:08, 1109.90it/s]\u001b[A\n", - "Loading dataset: 81%|███████████████████████████████████████████████████████████████████████████████████████████▍ | 38186/47164 [00:36<00:07, 1192.48it/s]\u001b[A\n", - "Loading dataset: 81%|███████████████████████████████████████████████████████████████████████████████████████████▊ | 38329/47164 [00:36<00:07, 1259.49it/s]\u001b[A\n", - "Loading dataset: 82%|████████████████████████████████████████████████████████████████████████████████████████████▏ | 38493/47164 [00:36<00:06, 1367.57it/s]\u001b[A\n", - "Loading dataset: 82%|████████████████████████████████████████████████████████████████████████████████████████████▌ | 38631/47164 [00:36<00:06, 1363.53it/s]\u001b[A\n", - "Loading dataset: 82%|████████████████████████████████████████████████████████████████████████████████████████████▉ | 38775/47164 [00:36<00:06, 1381.61it/s]\u001b[A\n", - "Loading dataset: 83%|█████████████████████████████████████████████████████████████████████████████████████████████▏ | 38914/47164 [00:36<00:06, 1305.92it/s]\u001b[A\n", - "Loading dataset: 83%|█████████████████████████████████████████████████████████████████████████████████████████████▌ | 39046/47164 [00:36<00:06, 1237.02it/s]\u001b[A\n", - "Loading dataset: 83%|█████████████████████████████████████████████████████████████████████████████████████████████▊ | 39171/47164 [00:36<00:06, 1211.99it/s]\u001b[A\n", - "Loading dataset: 83%|██████████████████████████████████████████████████████████████████████████████████████████████▏ | 39294/47164 [00:37<00:06, 1211.58it/s]\u001b[A\n", - "Loading dataset: 84%|██████████████████████████████████████████████████████████████████████████████████████████████▍ | 39427/47164 [00:37<00:06, 1241.92it/s]\u001b[A\n", - "Loading dataset: 84%|██████████████████████████████████████████████████████████████████████████████████████████████▊ | 39571/47164 [00:37<00:05, 1296.83it/s]\u001b[A\n", - "Loading dataset: 84%|███████████████████████████████████████████████████████████████████████████████████████████████ | 39702/47164 [00:37<00:05, 1248.91it/s]\u001b[A\n", - "Loading dataset: 84%|███████████████████████████████████████████████████████████████████████████████████████████████▍ | 39850/47164 [00:37<00:05, 1313.20it/s]\u001b[A\n", - "Loading dataset: 85%|███████████████████████████████████████████████████████████████████████████████████████████████▊ | 39994/47164 [00:37<00:05, 1348.81it/s]\u001b[A\n", - "Loading dataset: 85%|████████████████████████████████████████████████████████████████████████████████████████████████▏ | 40130/47164 [00:37<00:05, 1343.40it/s]\u001b[A\n", - "Loading dataset: 85%|████████████████████████████████████████████████████████████████████████████████████████████████▍ | 40265/47164 [00:37<00:05, 1336.80it/s]\u001b[A\n", - "Loading dataset: 86%|████████████████████████████████████████████████████████████████████████████████████████████████▊ | 40400/47164 [00:37<00:05, 1274.75it/s]\u001b[A\n", - "Loading dataset: 86%|█████████████████████████████████████████████████████████████████████████████████████████████████ | 40529/47164 [00:37<00:05, 1262.63it/s]\u001b[A\n", - "Loading dataset: 86%|█████████████████████████████████████████████████████████████████████████████████████████████████▍ | 40656/47164 [00:38<00:05, 1219.01it/s]\u001b[A\n", - "Loading dataset: 86%|█████████████████████████████████████████████████████████████████████████████████████████████████▋ | 40782/47164 [00:38<00:05, 1230.44it/s]\u001b[A\n", - "Loading dataset: 87%|██████████████████████████████████████████████████████████████████████████████████████████████████ | 40906/47164 [00:38<00:05, 1155.58it/s]\u001b[A\n", - "Loading dataset: 87%|██████████████████████████████████████████████████████████████████████████████████████████████████▍ | 41065/47164 [00:38<00:04, 1275.07it/s]\u001b[A\n", - "Loading dataset: 87%|██████████████████████████████████████████████████████████████████████████████████████████████████▋ | 41195/47164 [00:38<00:04, 1240.89it/s]\u001b[A\n", - "Loading dataset: 88%|███████████████████████████████████████████████████████████████████████████████████████████████████ | 41327/47164 [00:38<00:04, 1260.73it/s]\u001b[A\n", - "Loading dataset: 88%|███████████████████████████████████████████████████████████████████████████████████████████████████▎ | 41456/47164 [00:38<00:04, 1267.25it/s]\u001b[A\n", - "Loading dataset: 88%|███████████████████████████████████████████████████████████████████████████████████████████████████▋ | 41584/47164 [00:38<00:04, 1212.46it/s]\u001b[A\n", - "Loading dataset: 88%|███████████████████████████████████████████████████████████████████████████████████████████████████▉ | 41707/47164 [00:38<00:04, 1148.96it/s]\u001b[A\n", - "Loading dataset: 89%|████████████████████████████████████████████████████████████████████████████████████████████████████▏ | 41823/47164 [00:39<00:04, 1123.91it/s]\u001b[A\n", - "Loading dataset: 89%|████████████████████████████████████████████████████████████████████████████████████████████████████▌ | 41964/47164 [00:39<00:04, 1200.57it/s]\u001b[A\n", - "Loading dataset: 89%|████████████████████████████████████████████████████████████████████████████████████████████████████▊ | 42086/47164 [00:39<00:04, 1192.99it/s]\u001b[A\n", - "Loading dataset: 89%|█████████████████████████████████████████████████████████████████████████████████████████████████████ | 42207/47164 [00:39<00:04, 1187.89it/s]\u001b[A\n", - "Loading dataset: 90%|█████████████████████████████████████████████████████████████████████████████████████████████████████▌ | 42371/47164 [00:39<00:03, 1318.23it/s]\u001b[A\n" - ] + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" }, { - "name": "stderr", - "output_type": "stream", - "text": [ - "Loading dataset: 90%|█████████████████████████████████████████████████████████████████████████████████████████████████████▊ | 42515/47164 [00:39<00:03, 1353.30it/s]\u001b[A\n", - "Loading dataset: 90%|██████████████████████████████████████████████████████████████████████████████████████████████████████▏ | 42653/47164 [00:39<00:03, 1359.09it/s]\u001b[A\n", - "Loading dataset: 91%|██████████████████████████████████████████████████████████████████████████████████████████████████████▌ | 42799/47164 [00:39<00:03, 1388.21it/s]\u001b[A\n", - "Loading dataset: 91%|██████████████████████████████████████████████████████████████████████████████████████████████████████▉ | 42961/47164 [00:39<00:02, 1454.33it/s]\u001b[A\n", - "Loading dataset: 91%|███████████████████████████████████████████████████████████████████████████████████████████████████████▎ | 43122/47164 [00:40<00:02, 1498.44it/s]\u001b[A\n", - "Loading dataset: 92%|███████████████████████████████████████████████████████████████████████████████████████████████████████▋ | 43284/47164 [00:40<00:02, 1533.08it/s]\u001b[A\n", - "Loading dataset: 92%|████████████████████████████████████████████████████████████████████████████████████████████████████████▏ | 43465/47164 [00:40<00:02, 1614.88it/s]\u001b[A\n", - "Loading dataset: 93%|████████████████████████████████████████████████████████████████████████████████████████████████████████▌ | 43640/47164 [00:40<00:02, 1655.19it/s]\u001b[A\n", - "Loading dataset: 93%|████████████████████████████████████████████████████████████████████████████████████████████████████████▉ | 43821/47164 [00:40<00:01, 1700.38it/s]\u001b[A\n", - "Loading dataset: 93%|█████████████████████████████████████████████████████████████████████████████████████████████████████████▍ | 43992/47164 [00:40<00:01, 1627.04it/s]\u001b[A\n", - "Loading dataset: 94%|█████████████████████████████████████████████████████████████████████████████████████████████████████████▊ | 44156/47164 [00:40<00:01, 1606.61it/s]\u001b[A\n", - "Loading dataset: 94%|██████████████████████████████████████████████████████████████████████████████████████████████████████████▏ | 44318/47164 [00:40<00:01, 1577.28it/s]\u001b[A\n", - "Loading dataset: 94%|██████████████████████████████████████████████████████████████████████████████████████████████████████████▌ | 44477/47164 [00:40<00:01, 1486.83it/s]\u001b[A\n", - "Loading dataset: 95%|██████████████████████████████████████████████████████████████████████████████████████████████████████████▉ | 44636/47164 [00:40<00:01, 1513.91it/s]\u001b[A\n", - "Loading dataset: 95%|███████████████████████████████████████████████████████████████████████████████████████████████████████████▎ | 44794/47164 [00:41<00:01, 1529.55it/s]\u001b[A\n", - "Loading dataset: 95%|███████████████████████████████████████████████████████████████████████████████████████████████████████████▋ | 44951/47164 [00:41<00:01, 1540.41it/s]\u001b[A\n", - "Loading dataset: 96%|████████████████████████████████████████████████████████████████████████████████████████████████████████████ | 45106/47164 [00:41<00:01, 1474.77it/s]\u001b[A\n", - "Loading dataset: 96%|████████████████████████████████████████████████████████████████████████████████████████████████████████████▍ | 45281/47164 [00:41<00:01, 1550.95it/s]\u001b[A\n", - "Loading dataset: 96%|████████████████████████████████████████████████████████████████████████████████████████████████████████████▊ | 45438/47164 [00:41<00:01, 1550.03it/s]\u001b[A\n", - "Loading dataset: 97%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████▏ | 45594/47164 [00:41<00:01, 1505.14it/s]\u001b[A\n", - "Loading dataset: 97%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████▌ | 45746/47164 [00:41<00:01, 1417.44it/s]\u001b[A\n", - "Loading dataset: 97%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████▉ | 45890/47164 [00:41<00:00, 1410.66it/s]\u001b[A\n", - "Loading dataset: 98%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████▎ | 46032/47164 [00:41<00:00, 1387.05it/s]\u001b[A\n", - "Loading dataset: 98%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████▌ | 46172/47164 [00:42<00:00, 1305.11it/s]\u001b[A\n", - "Loading dataset: 98%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████▉ | 46320/47164 [00:42<00:00, 1351.72it/s]\u001b[A\n", - "Loading dataset: 99%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████▎ | 46463/47164 [00:42<00:00, 1372.28it/s]\u001b[A\n", - "Loading dataset: 99%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████▋ | 46602/47164 [00:42<00:00, 1353.22it/s]\u001b[A\n", - "Loading dataset: 99%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████▉ | 46738/47164 [00:42<00:00, 1345.79it/s]\u001b[A\n", - "Loading dataset: 99%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████▎| 46874/47164 [00:42<00:00, 1304.99it/s]\u001b[A\n", - "Loading dataset: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████▋| 47014/47164 [00:42<00:00, 1329.76it/s]\u001b[A\n", - "Loading dataset: 100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 47164/47164 [00:42<00:00, 1102.27it/s]\u001b[A\n" - ] + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "e68a0826dfad4a2b933c1793ae5a5961", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/1000 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" }, { - "name": "stderr", - "output_type": "stream", - "text": [ - "Loading dataset: 89%|███████████████████████████████████████████████████████████████████████████████████████████████████████▎ | 5248/5895 [00:04<00:00, 989.63it/s]\u001b[A\n", - "Loading dataset: 91%|████████████████████████████████████████████████████████████████████████████████████████████████████████▋ | 5365/5895 [00:05<00:00, 1035.91it/s]\u001b[A\n", - "Loading dataset: 93%|██████████████████████████████████████████████████████████████████████████████████████████████████████████▋ | 5470/5895 [00:05<00:00, 1025.43it/s]\u001b[A\n", - "Loading dataset: 95%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████▋ | 5574/5895 [00:05<00:00, 962.79it/s]\u001b[A\n", - "Loading dataset: 96%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████▌ | 5672/5895 [00:05<00:00, 966.62it/s]\u001b[A\n", - "Loading dataset: 98%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████▋ | 5775/5895 [00:05<00:00, 984.30it/s]\u001b[A\n", - "Loading dataset: 100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 5895/5895 [00:05<00:00, 1060.59it/s]\u001b[A\n", - "\n", - "Loading dataset: 0%| | 0/7991 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "2023-04-10 18:42:51,417 - \n", - " | Name | Type | Params\n", - "-------------------------------------------------\n", - "0 | unet | DiffusionModelUNet | 266 M \n", - "1 | scheduler | DDPMScheduler | 0 \n", - "2 | z | AutoencoderKL | 75.1 M\n", - "-------------------------------------------------\n", - "342 M Trainable params\n", - "0 Non-trainable params\n", - "342 M Total params\n", - "1,368.189 Total estimated model params size (MB)\n", - "Sanity Checking: 0it [00:00, ?it/s]" - ] + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" }, { - "name": "stderr", - "output_type": "stream", - "text": [ - "Your `val_dataloader`'s sampler has shuffling enabled, it is strongly recommended that you turn shuffling off for val/test dataloaders.\n" - ] + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "a2dbfb54bcc8427682275ec8ca7717ee", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/1000 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "4a42ac2f90cb461fb9f0c82d544fb8d2", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/1000 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "c6d737f986a64c22895476a68c2b3e87", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/1000 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "7e79ff41ccf54a45885ea18dd5bfe401", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/1000 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "c23581c04d474a69a45d37fce99ec3f4", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/1000 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "009e46d5a9094efb96c33cbed7b09d93", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/1000 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "712d910c6b8a4d529c7b936c29f8c70a", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/1000 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch 0: 0%|▍ | 2/500 [00:16<1:08:40, 8.27s/it, v_num=1, train_loss=0.980]" + "2023-04-12 15:10:07,913 - `Trainer.fit` stopped: `max_epochs=200` reached.\n" ] } ], @@ -1461,6 +1546,7 @@ "trainer = pl.Trainer(devices=1,\n", " max_epochs=n_epochs,\n", " check_val_every_n_epoch=val_interval,\n", + " num_sanity_val_steps=0,\n", " callbacks=checkpoint_callback,\n", " default_root_dir=root_dir)\n", "\n", @@ -1478,57 +1564,82 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 13, "id": "155be091", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "2d9060b0533142ceac3699efbb441dc5", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/1000 [00:00 x_t-1\n", + " latents, _ = scheduler.step(noise_pred, t, latents)\n", "\n", - " # 2. compute previous image: x_t -> x_t-1\n", - " latents, _ = scheduler.step(noise_pred, t, latents)\n", + " with torch.no_grad():\n", + " decoded = ae_net.autoencoderkl.decode_stage_2_outputs(latents / scale_factor)\n", + " return sampling_image, images, decoded\n", "\n", - "with torch.no_grad():\n", - " decoded = ae_net.autoencoderkl.decode_stage_2_outputs(latents / scale_factor)" + "sampling_image, images, decoded = get_images_to_plot()" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 14, "id": "32e16e69", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "low_res_bicubic = nn.functional.interpolate(sampling_image, (64, 64), mode=\"bicubic\")\n", "fig, axs = plt.subplots(num_samples, 3, figsize=(8, 8))\n", @@ -1540,7 +1651,7 @@ " axs[i, 0].axis(\"off\")\n", " axs[i, 1].imshow(low_res_bicubic[i, 0].cpu(), vmin=0, vmax=1, cmap=\"gray\")\n", " axs[i, 1].axis(\"off\")\n", - " axs[i, 2].imshow(decoded[i, 0].cpu(), vmin=0, vmax=1, cmap=\"gray\")\n", + " axs[i, 2].imshow(decoded[i, 0].cpu().detach().numpy(), vmin=0, vmax=1, cmap=\"gray\")\n", " axs[i, 2].axis(\"off\")\n", "plt.tight_layout()" ] @@ -1555,7 +1666,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 15, "id": "3a6f6d5a", "metadata": {}, "outputs": [], diff --git a/tutorials/generative/2d_super_resolution/2d_stable_diffusion_v2_super_resolution-lightning.py b/tutorials/generative/2d_super_resolution/2d_stable_diffusion_v2_super_resolution-lightning.py index 14d36417..084404bc 100644 --- a/tutorials/generative/2d_super_resolution/2d_stable_diffusion_v2_super_resolution-lightning.py +++ b/tutorials/generative/2d_super_resolution/2d_stable_diffusion_v2_super_resolution-lightning.py @@ -56,6 +56,7 @@ import os import shutil import tempfile +from pathlib import Path import matplotlib.pyplot as plt import numpy as np @@ -64,11 +65,11 @@ from monai import transforms from monai.apps import MedNISTDataset from monai.config import print_config -from monai.data import CacheDataset, DataLoader +from monai.data import CacheDataset, ThreadDataLoader from monai.utils import first, set_determinism -from torch import nn from torch.cuda.amp import GradScaler, autocast -from tqdm import tqdm +from torch import nn +from tqdm.notebook import tqdm from generative.losses import PatchAdversarialLoss, PerceptualLoss from generative.networks.nets import AutoencoderKL, DiffusionModelUNet, PatchDiscriminator @@ -92,6 +93,14 @@ root_dir = tempfile.mkdtemp() if directory is None else directory print(root_dir) +# %% +train_data = MedNISTDataset(root_dir=root_dir, section="training", + download=True, seed=0) +train_datalist = [{"image": item["image"]} for item in train_data.data if item["class_name"] == "HeadCT"] +val_data = MedNISTDataset(root_dir=root_dir, section="validation", + download=True, seed=0) +val_datalist = [{"image": item["image"]} for item in val_data.data if item["class_name"] == "HeadCT"] + # %% [markdown] # ## Setup utils functions @@ -133,6 +142,14 @@ def get_val_transforms(): ) return val_transforms + +def get_datasets(): + train_transforms = get_train_transforms() + val_transforms = get_val_transforms() + train_ds = CacheDataset(data=train_datalist[:320], transform=train_transforms) + val_ds = CacheDataset(data=val_datalist[:32], transform=val_transforms) + return train_ds, val_ds + # %% [markdown] @@ -167,23 +184,14 @@ def forward(self, z): return self.autoencoderkl(z) def prepare_data(self): - train_transforms = get_train_transforms() - val_transforms = get_val_transforms() - - train_data = MedNISTDataset(root_dir=self.data_dir, section="training", download=True, seed=0) - train_datalist = [{"image": item["image"]} for item in train_data.data if item["class_name"] == "HeadCT"] - val_data = MedNISTDataset(root_dir=self.data_dir, section="validation", download=True, seed=0) - val_datalist = [{"image": item["image"]} for item in val_data.data if item["class_name"] == "HeadCT"] - - self.train_ds = CacheDataset(data=train_datalist, transform=train_transforms) - self.val_ds = CacheDataset(data=val_datalist, transform=val_transforms) - + self.train_ds, self.val_ds = get_datasets() + def train_dataloader(self): - return DataLoader(self.train_ds, batch_size=16, shuffle=True, + return ThreadDataLoader(self.train_ds, batch_size=16, shuffle=True, num_workers=4, persistent_workers=True) def val_dataloader(self): - return DataLoader(self.val_ds, batch_size=16, shuffle=False, + return ThreadDataLoader(self.val_ds, batch_size=16, shuffle=False, num_workers=4) def _compute_loss_generator(self, images, reconstruction, z_mu, z_sigma): @@ -194,11 +202,11 @@ def _compute_loss_generator(self, images, reconstruction, z_mu, z_sigma): loss_g = recons_loss + (self.kl_weight * kl_loss) + (self.perceptual_weight * p_loss) return loss_g,recons_loss - def _compute_loss_discriminator(self, reconstruction): - logits_fake = discriminator(reconstruction.contiguous().detach())[-1] + def _compute_loss_discriminator(self, images, reconstruction): + logits_fake = self.discriminator(reconstruction.contiguous().detach())[-1] loss_d_fake = self.adv_loss(logits_fake, target_is_real=False, for_discriminator=True) - logits_real = discriminator(images.contiguous().detach())[-1] - loss_d_real = adv_loss(logits_real, target_is_real=True, for_discriminator=True) + logits_real = self.discriminator(images.contiguous().detach())[-1] + loss_d_real = self.adv_loss(logits_real, target_is_real=True, for_discriminator=True) discriminator_loss = (loss_d_fake + loss_d_real) * 0.5 loss_d = self.adv_weight * discriminator_loss return loss_d, discriminator_loss @@ -211,9 +219,11 @@ def training_step(self, batch, batch_idx): self.log("recons_loss", recons_loss, batch_size=16, prog_bar=True) if self.current_epoch > self.autoencoder_warm_up_n_epochs: - logits_fake = discriminator(reconstruction.contiguous().float())[-1] - generator_loss = adv_loss(logits_fake, target_is_real=True, for_discriminator=False) - loss_g += adv_weight * generator_loss + logits_fake = self.discriminator(reconstruction.contiguous().float())[-1] + generator_loss = self.adv_loss(logits_fake, target_is_real=True, for_discriminator=False) + loss_g += self.adv_weight * generator_loss + self.log("gen_loss", generator_loss, batch_size=16, prog_bar=True) + self.log("loss_g", loss_g, batch_size=16, prog_bar=True) @@ -223,7 +233,8 @@ def training_step(self, batch, batch_idx): self.untoggle_optimizer(optimizer_g) if self.current_epoch > self.autoencoder_warm_up_n_epochs: - loss_d, discriminator_loss = self._compute_loss_discriminator(reconstruction) + loss_d, discriminator_loss = self._compute_loss_discriminator(images, reconstruction) + self.log("disc_loss", loss_d, batch_size=16, prog_bar=True) self.log("train_loss_d", loss_d, batch_size=16, prog_bar=True) self.manual_backward(loss_d) optimizer_d.step() @@ -231,19 +242,26 @@ def training_step(self, batch, batch_idx): self.untoggle_optimizer(optimizer_d) - if self.current_epoch > self.autoencoder_warm_up_n_epochs: - gen_epoch_loss += generator_loss.item() - disc_epoch_loss += discriminator_loss.item() - self.log("gen_loss", gen_loss, batch_size=16, prog_bar=True) - self.log("disc_loss", disc_loss, batch_size=16, prog_bar=True) - def validation_step(self, batch, batch_idx): images = batch["image"] reconstruction, z_mu, z_sigma = self.autoencoderkl(images) recons_loss = F.l1_loss(images.float(), reconstruction.float()) - self.log("val_loss_d", recons_loss, prog_bar=True) - + self.log("val_loss_d", recons_loss, batch_size=1, prog_bar=True) + self.images = images + self.reconstruction = reconstruction + + + def on_validation_epoch_end(self): + # ploting reconstruction + plt.figure(figsize=(2, 2)) + plt.imshow(torch.cat([self.images[0, 0].cpu(), + self.reconstruction[0, 0].cpu()], + dim=1), vmin=0, vmax=1, cmap="gray") + plt.tight_layout() + plt.axis("off") + plt.show() + def configure_optimizers(self): optimizer_g = torch.optim.Adam(self.autoencoderkl.parameters(), lr=5e-5) @@ -256,7 +274,7 @@ def configure_optimizers(self): # ## Train Autoencoder # %% -n_epochs = 75 +n_epochs = 75 val_interval = 10 @@ -272,23 +290,33 @@ def configure_optimizers(self): trainer = pl.Trainer(devices=1, max_epochs=n_epochs, check_val_every_n_epoch=val_interval, + num_sanity_val_steps=0, callbacks=checkpoint_callback, default_root_dir=root_dir) # train trainer.fit(ae_net) + # %% [markdown] # ## Rescaling factor # # As mentioned in Rombach et al. [1] Section 4.3.2 and D.1, the signal-to-noise ratio (induced by the scale of the latent space) became crucial in image-to-image translation models (such as the ones used for super-resolution). For this reason, we will compute the component-wise standard deviation to be used as scaling factor. # %% -train_loader = ae_net.train_dataloader() -check_data = first(train_loader) -z = ae_net.autoencoderkl.train(mode=False).encode_stage_2_inputs(check_data["image"].to(ae_net.device)) -print(f"Scaling factor set to {1/torch.std(z)}") -scale_factor = 1 / torch.std(z) +def get_scaler_factor(): + ae_net.eval() + device = torch.device("cuda:0") + ae_net.to(device) + + train_loader = ae_net.train_dataloader() + check_data = first(train_loader) + z = ae_net.autoencoderkl.encode_stage_2_inputs(check_data["image"].to(ae_net.device)) + print(f"Scaling factor set to {1/torch.std(z)}") + scale_factor = 1 / torch.std(z) + return scale_factor + +scale_factor = get_scaler_factor() # %% [markdown] @@ -314,7 +342,7 @@ def __init__(self): beta_schedule="linear", beta_start=0.0015, beta_end=0.0195) - self.z = ae_net.autoencoderkl.train(mode=False) + self.z = ae_net.autoencoderkl.eval() def forward(self, x, timesteps, low_res_timesteps): @@ -322,68 +350,106 @@ def forward(self, x, timesteps, low_res_timesteps): timesteps=timesteps, class_labels=low_res_timesteps) - + def prepare_data(self): - train_transforms = get_train_transforms() - val_transforms = get_val_transforms() - - train_data = MedNISTDataset(root_dir=self.data_dir, section="training", - download=True, seed=0) - train_datalist = [{"image": item["image"]} for item in train_data.data if item["class_name"] == "HeadCT"] - val_data = MedNISTDataset(root_dir=self.data_dir, section="validation", - download=True, seed=0) - val_datalist = [{"image": item["image"]} for item in val_data.data if item["class_name"] == "HeadCT"] - - self.train_ds = CacheDataset(data=train_datalist, transform=train_transforms) - self.val_ds = CacheDataset(data=val_datalist, transform=val_transforms) + self.train_ds, self.val_ds = get_datasets() def train_dataloader(self): return DataLoader(self.train_ds, batch_size=16, shuffle=True, num_workers=4, persistent_workers=True) def val_dataloader(self): - return DataLoader(self.val_ds, batch_size=16, shuffle=True, + return DataLoader(self.val_ds, batch_size=16, shuffle=False, num_workers=4) - def _calculate_loss(self, batch, batch_idx): + def _calculate_loss(self, batch, batch_idx, plt_image=False): images = batch["image"] - low_res_image = batch["low_res_image"] - latent = self.z.encode_stage_2_inputs(images) * scale_factor - latent = latent.detach() # avoid adding this to graph. - optimizer = self.optimizers() + low_res_image = batch["low_res_image"] + with autocast(enabled=True): + with torch.no_grad(): + latent = self.z.encode_stage_2_inputs(images) * scale_factor +# latent = latent.detach() # avoid adding this to graph. - # Noise augmentation - noise = torch.randn_like(latent) - low_res_noise = torch.randn_like(low_res_image) - timesteps = torch.randint(0, self.scheduler.num_train_timesteps, (latent.shape[0],), - device=latent.device).long() - low_res_timesteps = torch.randint( - 0, self.max_noise_level, (low_res_image.shape[0],), device=latent.device - ).long() - - noisy_latent = self.scheduler.add_noise(original_samples=latent, - noise=noise, timesteps=timesteps) - noisy_low_res_image = self.scheduler.add_noise( - original_samples=low_res_image, noise=low_res_noise, - timesteps=low_res_timesteps - ) - - latent_model_input = torch.cat([noisy_latent, noisy_low_res_image], dim=1) - noise_pred = self.forward(latent_model_input, timesteps, low_res_timesteps) - loss = F.mse_loss(noise_pred.float(), noise.float()) + # Noise augmentation + noise = torch.randn_like(latent) + low_res_noise = torch.randn_like(low_res_image) + timesteps = torch.randint(0, self.scheduler.num_train_timesteps, (latent.shape[0],), + device=latent.device).long() + low_res_timesteps = torch.randint( + 0, self.max_noise_level, (low_res_image.shape[0],), device=latent.device + ).long() + + noisy_latent = self.scheduler.add_noise(original_samples=latent, + noise=noise, timesteps=timesteps) + noisy_low_res_image = self.scheduler.add_noise( + original_samples=low_res_image, noise=low_res_noise, + timesteps=low_res_timesteps + ) + + latent_model_input = torch.cat([noisy_latent, noisy_low_res_image], dim=1) + + noise_pred = self.forward(latent_model_input, timesteps, low_res_timesteps) + loss = F.mse_loss(noise_pred.float(), noise.float()) + + if plt_image: + # Sampling image during training + sampling_image = low_res_image[0].unsqueeze(0) + latents = torch.randn((1, 3, 16, 16)).to(sampling_image.device) + low_res_noise = torch.randn((1, 1, 16, 16)).to(sampling_image.device) + noise_level = 20 + noise_level = torch.Tensor((noise_level,)).long().to(sampling_image.device) + + noisy_low_res_image = self.scheduler.add_noise( + original_samples=sampling_image, + noise=low_res_noise, + timesteps=noise_level, + ) + self.scheduler.set_timesteps(num_inference_steps=1000) + for t in tqdm(self.scheduler.timesteps, ncols=110): + with autocast(enabled=True): + with torch.no_grad(): + latent_model_input = torch.cat([latents, noisy_low_res_image], dim=1) + noise_pred = self.forward(latent_model_input, + torch.Tensor((t,)).to(sampling_image.device) + , noise_level) + latents, _ = self.scheduler.step(noise_pred, t, latents) + with torch.no_grad(): + decoded = self.z.decode_stage_2_outputs(latents / scale_factor) + low_res_bicubic = nn.functional.interpolate(sampling_image, (64, 64), mode="bicubic") + # plot images + + self.images = images + self.low_res_bicubic = low_res_bicubic + self.decoded = decoded + return loss + + def _plot_image(self, images, low_res_bicubic, decoded): + plt.figure(figsize=(2, 2)) + plt.style.use("default") + plt.imshow( + torch.cat([images[0, 0].cpu(), low_res_bicubic[0, 0].cpu(), decoded[0, 0].cpu()], dim=1), + vmin=0, + vmax=1, + cmap="gray", + ) + plt.tight_layout() + plt.axis("off") + plt.show() def training_step(self, batch, batch_idx): loss = self._calculate_loss(batch, batch_idx) self.log("train_loss", loss, batch_size=16, prog_bar=True) return loss - def validation_step(self, batch, batch_idx): - loss = self._calculate_loss(batch, batch_idx) + loss = self._calculate_loss(batch, batch_idx, plt_image=True) self.log("val_loss", loss, batch_size=16, prog_bar=True) return loss + + def on_validation_epoch_end(self): + self._plot_image(self.images, self.low_res_bicubic, self.decoded) def configure_optimizers(self): optimizer = torch.optim.Adam(self.unet.parameters(), lr=5e-5) @@ -414,6 +480,7 @@ def configure_optimizers(self): trainer = pl.Trainer(devices=1, max_epochs=n_epochs, check_val_every_n_epoch=val_interval, + num_sanity_val_steps=0, callbacks=checkpoint_callback, default_root_dir=root_dir) @@ -424,37 +491,43 @@ def configure_optimizers(self): # ### Plotting sampling example # %% -# Sampling image during training num_samples = 3 -val_loader = d_net.val_dataloader() -check_data = first(val_loader) -images = check_data["image"] -sampling_image = check_data["low_res_image"][:num_samples] +def get_images_to_plot(): + d_net.eval() + device = torch.device("cuda:0") + d_net.to(device) -# %% -latents = torch.randn((num_samples, 3, 16, 16)).to(images.device) -low_res_noise = torch.randn((num_samples, 1, 16, 16)).to(images.device) -noise_level = 10 -noise_level = torch.Tensor((noise_level,)).long().to(images.device) -scheduler = d_net.scheduler -noisy_low_res_image = scheduler.add_noise(original_samples=sampling_image, - noise=low_res_noise, - timesteps=torch.Tensor((noise_level,)).long()) - -scheduler.set_timesteps(num_inference_steps=1000) -for t in tqdm(scheduler.timesteps, ncols=110): - with torch.no_grad(): + + val_loader = d_net.val_dataloader() + check_data = first(val_loader) + images = check_data["image"].to(d_net.device) + + sampling_image = check_data["low_res_image"][:num_samples].to(d_net.device) + latents = torch.randn((num_samples, 3, 16, 16)).to(d_net.device) + low_res_noise = torch.randn((num_samples, 1, 16, 16)).to(d_net.device) + noise_level = 10 + noise_level = torch.Tensor((noise_level,)).long().to(d_net.device) + scheduler = d_net.scheduler + noisy_low_res_image = scheduler.add_noise(original_samples=sampling_image, + noise=low_res_noise, + timesteps=torch.Tensor((noise_level,)).long()) + + scheduler.set_timesteps(num_inference_steps=1000) + for t in tqdm(scheduler.timesteps, ncols=110): with autocast(enabled=True): - latent_model_input = torch.cat([latents, noisy_low_res_image], dim=1) - noise_pred = d_net.forward(x=latent_model_input, - timesteps=torch.Tensor((t,)), - low_res_timesteps=noise_level) + with torch.no_grad(): + latent_model_input = torch.cat([latents, noisy_low_res_image], dim=1) + noise_pred = d_net.forward(x=latent_model_input, + timesteps=torch.Tensor((t,)).to(d_net.device), + low_res_timesteps=noise_level) + # 2. compute previous image: x_t -> x_t-1 + latents, _ = scheduler.step(noise_pred, t, latents) - # 2. compute previous image: x_t -> x_t-1 - latents, _ = scheduler.step(noise_pred, t, latents) + with torch.no_grad(): + decoded = ae_net.autoencoderkl.decode_stage_2_outputs(latents / scale_factor) + return sampling_image, images, decoded -with torch.no_grad(): - decoded = ae_net.autoencoderkl.decode_stage_2_outputs(latents / scale_factor) +sampling_image, images, decoded = get_images_to_plot() # %% low_res_bicubic = nn.functional.interpolate(sampling_image, (64, 64), mode="bicubic") @@ -467,7 +540,7 @@ def configure_optimizers(self): axs[i, 0].axis("off") axs[i, 1].imshow(low_res_bicubic[i, 0].cpu(), vmin=0, vmax=1, cmap="gray") axs[i, 1].axis("off") - axs[i, 2].imshow(decoded[i, 0].cpu(), vmin=0, vmax=1, cmap="gray") + axs[i, 2].imshow(decoded[i, 0].cpu().detach().numpy(), vmin=0, vmax=1, cmap="gray") axs[i, 2].axis("off") plt.tight_layout() From 72158473b10f8885a80a701c6f7ab512cdf23869 Mon Sep 17 00:00:00 2001 From: OeslleLucena Date: Fri, 12 May 2023 18:28:02 +0100 Subject: [PATCH 05/13] revised tutorial --- ...fusion_v2_super_resolution-lightning.ipynb | 164 ++++++------ ...diffusion_v2_super_resolution-lightning.py | 246 +++++++++--------- 2 files changed, 199 insertions(+), 211 deletions(-) diff --git a/tutorials/generative/2d_super_resolution/2d_stable_diffusion_v2_super_resolution-lightning.ipynb b/tutorials/generative/2d_super_resolution/2d_stable_diffusion_v2_super_resolution-lightning.ipynb index 1b8251da..029889d1 100644 --- a/tutorials/generative/2d_super_resolution/2d_stable_diffusion_v2_super_resolution-lightning.ipynb +++ b/tutorials/generative/2d_super_resolution/2d_stable_diffusion_v2_super_resolution-lightning.ipynb @@ -54,6 +54,7 @@ "outputs": [], "source": [ "!python -c \"import monai\" || pip install -q \"monai-weekly[tqdm]\"\n", + "!python -c \"import pytorch_lightning\" || pip install pytorch-lightning\n", "!python -c \"import matplotlib\" || pip install -q matplotlib\n", "%matplotlib inline" ] @@ -76,14 +77,14 @@ "name": "stdout", "output_type": "stream", "text": [ - "2023-04-12 14:09:21,976 - WARNING[XFORMERS]: xFormers can't load C++/CUDA extensions. xFormers was built for:\n", + "2023-05-12 17:22:32,886 - WARNING[XFORMERS]: xFormers can't load C++/CUDA extensions. xFormers was built for:\n", " PyTorch 1.13.1+cu117 with CUDA 1107 (you have 1.12.1)\n", " Python 3.8.16 (you have 3.8.16)\n", " Please reinstall xformers (see https://github.com/facebookresearch/xformers#installing-xformers)\n", " Memory-efficient attention, SwiGLU, sparse and more won't be available.\n", " Set XFORMERS_MORE_DETAILS=1 for more details\n", - "2023-04-12 14:09:23,860 - Created a temporary directory at /tmp/tmpo49u4ma3\n", - "2023-04-12 14:09:23,864 - Writing /tmp/tmpo49u4ma3/_remote_module_non_scriptable.py\n", + "2023-05-12 17:22:35,069 - Created a temporary directory at /tmp/tmph4_v9gin\n", + "2023-05-12 17:22:35,071 - Writing /tmp/tmph4_v9gin/_remote_module_non_scriptable.py\n", "MONAI version: 1.2.dev2304\n", "Numpy version: 1.23.5\n", "Pytorch version: 1.12.1\n", @@ -174,7 +175,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "/tmp/tmpizuu167z\n" + "/tmp/tmphf3tvpfi\n" ] } ], @@ -194,14 +195,14 @@ "name": "stderr", "output_type": "stream", "text": [ - "MedNIST.tar.gz: 59.0MB [00:11, 5.17MB/s] " + "MedNIST.tar.gz: 59.0MB [00:01, 36.4MB/s] " ] }, { "name": "stdout", "output_type": "stream", "text": [ - "2023-04-12 14:09:35,992 - INFO - Downloaded: /tmp/tmpizuu167z/MedNIST.tar.gz\n" + "2023-05-12 17:22:36,915 - INFO - Downloaded: /tmp/tmphf3tvpfi/MedNIST.tar.gz\n" ] }, { @@ -215,31 +216,32 @@ "name": "stdout", "output_type": "stream", "text": [ - "2023-04-12 14:09:36,099 - INFO - Verified 'MedNIST.tar.gz', md5: 0bc7306e7427e00ad1c5526a6677552d.\n", - "2023-04-12 14:09:36,100 - INFO - Writing into directory: /tmp/tmpizuu167z.\n" + "2023-05-12 17:22:37,020 - INFO - Verified 'MedNIST.tar.gz', md5: 0bc7306e7427e00ad1c5526a6677552d.\n", + "2023-05-12 17:22:37,022 - INFO - Writing into directory: /tmp/tmphf3tvpfi.\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "Loading dataset: 100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████| 47164/47164 [00:35<00:00, 1335.82it/s]\n" + "Loading dataset: 100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████| 47164/47164 [00:35<00:00, 1323.43it/s]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "2023-04-12 14:10:20,302 - INFO - Verified 'MedNIST.tar.gz', md5: 0bc7306e7427e00ad1c5526a6677552d.\n", - "2023-04-12 14:10:20,303 - INFO - File exists: /tmp/tmpizuu167z/MedNIST.tar.gz, skipped downloading.\n", - "2023-04-12 14:10:20,304 - INFO - Non-empty folder exists in /tmp/tmpizuu167z/MedNIST, skipped extracting.\n" + "2023-05-12 17:23:21,457 - INFO - Verified 'MedNIST.tar.gz', md5: 0bc7306e7427e00ad1c5526a6677552d.\n", + "2023-05-12 17:23:21,459 - INFO - File exists: /tmp/tmphf3tvpfi/MedNIST.tar.gz, skipped downloading.\n", + "2023-05-12 17:23:21,460 - INFO - Non-empty folder exists in /tmp/tmphf3tvpfi/MedNIST, skipped extracting.\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "Loading dataset: 100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████| 5895/5895 [00:04<00:00, 1332.80it/s]\n" + "\n", + "Loading dataset: 100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████| 5895/5895 [00:04<00:00, 1319.58it/s]\n" ] } ], @@ -319,7 +321,7 @@ "metadata": {}, "source": [ "## Define the LightningModule for AutoEncoder (transforms, network, loaders, etc)\n", - "The LightningModule contains a refactoring of your training code. The following module is a reformatiing of the code in 2d_stable_diffusion_v2_super_resolution.\n" + "The LightningModule contains a refactoring of your training code. The following module is a reformating of the code in 2d_stable_diffusion_v2_super_resolution.\n" ] }, { @@ -471,25 +473,25 @@ "name": "stdout", "output_type": "stream", "text": [ - "2023-04-12 14:10:27,910 - GPU available: True (cuda), used: True\n", - "2023-04-12 14:10:27,911 - TPU available: False, using: 0 TPU cores\n", - "2023-04-12 14:10:27,912 - IPU available: False, using: 0 IPUs\n", - "2023-04-12 14:10:27,913 - HPU available: False, using: 0 HPUs\n" + "2023-05-12 17:23:29,608 - GPU available: True (cuda), used: True\n", + "2023-05-12 17:23:29,609 - TPU available: False, using: 0 TPU cores\n", + "2023-05-12 17:23:29,610 - IPU available: False, using: 0 IPUs\n", + "2023-05-12 17:23:29,611 - HPU available: False, using: 0 HPUs\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "Loading dataset: 100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████| 320/320 [00:00<00:00, 892.62it/s]\n", - "Loading dataset: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 32/32 [00:00<00:00, 413.74it/s]" + "Loading dataset: 100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████| 320/320 [00:00<00:00, 858.75it/s]\n", + "Loading dataset: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 32/32 [00:00<00:00, 284.05it/s]" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "2023-04-12 14:10:28,377 - Missing logger folder: /tmp/tmpizuu167z/lightning_logs\n" + "2023-05-12 17:23:30,118 - Missing logger folder: /tmp/tmphf3tvpfi/lightning_logs\n" ] }, { @@ -497,15 +499,15 @@ "output_type": "stream", "text": [ "\n", - "Checkpoint directory /tmp/tmpizuu167z exists and is not empty.\n" + "Checkpoint directory /tmp/tmphf3tvpfi exists and is not empty.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "2023-04-12 14:10:29,835 - LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0,1]\n", - "2023-04-12 14:10:29,850 - \n", + "2023-05-12 17:23:31,637 - LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0,1]\n", + "2023-05-12 17:23:31,652 - \n", " | Name | Type | Params\n", "---------------------------------------------------------\n", "0 | autoencoderkl | AutoencoderKL | 75.1 M\n", @@ -529,7 +531,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "a7a5ce61b3dd41b386312a100272db42", + "model_id": "e345b86c597145adad868d37e0416041", "version_major": 2, "version_minor": 0 }, @@ -556,7 +558,7 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAKIAAABbCAYAAADwb17KAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAkVElEQVR4nO19229cV9n+M+fzeTw+JnbixKnaJq2qFtqUQr+UXoIqVKlCSAhV6gUXXPBP8CdwhSohIW4QQgipFwgoagulaYuUJnFquUkcx4fxeOw5n0/fhX/Pm3dW9njGfE5qfppXGnkOe6+99lrPeg/P+65tW6/X62EsY/maxf51d2AsYwHGQBzLCZExEMdyImQMxLGcCBkDcSwnQsZAHMuJkDEQx3IiZAzEsZwIGQNxLCdCnKMeODMz8yj78V8tnU4HvV4PDocDAGCz2XCUhJXNZgMA9Ho9ec/vrdrq9XrysjqX5/FcfX632+07ly+2AQB2ux12u10+6/N1e2zDPM5sL5PJDB2DkYE4lsGiwQPgIeCYE6PfW/2mj9Hg0ADUv2kwdLvdPiCZIOl2u3K8zWZDt9u1vAcCdlDf+L0J/sPG4TAZA/GYxJwELVYToo83NaE+R/+mtZlux0or6mO19rPqqxVg9XFWC0trzEH3ddiYmDIG4jGINoGDzOyw87WYGg/o11AUu93eBwrTFJtak8fZ7faHrtvr9UQ7DgOvlRY0v+N1RtWKYyAes4wy8KZvZQLCfDkcDgGJnlyaYA2sbrf7EGgJQl5HH6+vrbVop9MRM28FxkEadJCGHiZjID4isQKZKWYgYmowsx1zovVnh8MhE2+329HpdB5ql1rPZrOh3W4LiE2AdjodS59P+5PDTPhRqwvHQDwmsYpurUBoFQmbJt08dlBAwPedTgftdrsPaHxP8GgQ1et1AarD4RAwmpE2WQD2yypa5nGm9vuvAOJRVPbX0d5/2odB35mmjWDR3xE42jfTPl273e4DmVX0zPdayzmdTgEb26Y21ONGCop90i/dnvYlDwt+Bo3JIHnsQLTZbCgUCgiFQggEAqhUKmg2m3C5XPB6vbK63W43ut0u2u02HA4HbDZb38rXK77dbiMUCsHlcqFWq6HdbsPpdMJut6PRaMDhcMDtdlvSHZxkj8cDm82GSqUCAPD5fOKbceCH3Zdu20o7mpxbr9eD03kwBfTH+JsOROivcQzYhtPphMfjkfvj+U6nE263G263G06nE16vFy6Xq4/CaTQaqNfrqFQqqNfrqNfraDabAvhWqyVtc/zb7bZcX98P+6ZpIXNcho5fb0TYHheh7Xa74fV6USwW0Wg04PP54HQ60W630Ww2ZfJ54+12G8CBCfF6vQiFQohEInC73VhYWMDS0hISiQTC4TDcbjccDgd8Ph/sdju2t7fR6XSwvLyMDz/8EOvr6+h0OrDb7XA4HHA6nbDZbGg2m+j1evB4PLDb7Wi1Wmi1WgIIbaKsxMqv04CzIoj1ObxnrRV5nPbl7Ha7gMvtdsPv9yMYDCIUCsHr9cpi4qL2eDzy4sLk9VqtFqrVKorFIgqFAkqlEnK5HHK5HPb391EulwEcLFSXyyXnM5Cx2+2ySF0u18Ax6fV62NnZGYqLxwpEPbAA+kDBm+x2uwgGg4hEIpiZmcHi4iLm5+cxMTGBUCiEYDCIcDiMSCQCr9cLr9cr5kc73dSGpVIJANBqtfDRRx/hj3/8I7744guUy2W5ptZ89Hf0Kh/lvkw/T2sN0/fSv5vks9Z4bIug8vl8CIfDMgbRaBSxWAzxeBx+vx+BQADAA+3rcDjgcrlEOxLEPp8P3W4XzWYTlUoFhUIB2WwWmUwG6XQaq6ur2NraQi6XQ6PRkAXgcrlkUWrLpE23OS4ARgLiYzfNnU4HgUAAzWbzoANOp6yqU6dO4YUXXsClS5cwPT2NWCwmA0/AOZ1OuFwuWYXdblfMmyk+n08m0W63IxQK4amnnsJnn32GP//5z/j0009RqVRkkKkd7Xa7aEsrMztMTKd9kNm2cjHoBhBEfr8fkUgEiUQCsVgMExMTAsJEIoFoNIpoNAqfzwe/3y+anFreZrPJQiUYg8GgLD6CsVQqYX9/Hzs7OwiHw/D5fFhdXcX+/j7a7ba0q8FIt8HKHB/Vb3/sQHQ4HH0gjEajOHfuHC5evIinnnoK586dw/z8POLxOJxOpwBD+4nNZlN8Pw5EpVJBq9WC1+uF2+0WE0UQ9no9mcjZ2VlMTk4imUzigw8+wN7eHrrdLvx+f59p5KofZpqtxNSOZjRMTQIcLE76v1xYXq8X4XAYExMTmJqawtzcHFKpFFKpFCKRCEKhkPjZXq9XfLlarYZGowEAaDQafSByu93weDzo9Xrw+/1wu90IBAIIBoOYmJjAzMwMZmZmxEK1Wi10u13k83m0Wi0Za5fLJZqc0beV/23FJAySxwpEm80Gr9eLUqmESCSC06dP4+LFi3j11Vfx0ksvYW5uDu12W1Zxu93Gzs6OBB8EcblcRr1el1Xtdruxv7+PZrOJRCKBYDAIAAiFQpiYmBB/hoMyOTmJ1157DclkEjabDX//+9+xubkJj8cDl8slANQUxyj3ZhU9DjLXGpxaE9J0JpNJTE9PY35+HvPz85ibm0MymUQsFkMgEBC/j221Wi0JPCqVCiqVCqrVKur1uoCIGpEgpwsUCATEtPv9fjSbTaF52DdqRgr9UZN20vd4FHnsGtFut8Pn82FxcRFvvPEGXn/9dSwsLMDr9YoWAw4mJ5PJYHl5GblcTrRip9NBpVJBNptFp9NBvV5HLBZDvV5Hr9dDKpWC1+tFtVpFOBzG5cuXEYlEJDKn+Hw+XLp0CT/84Q9Rr9fx3nvvoVqtwuv1AsB/rAkpVhpR+1SaBtGaxu/3Y2JiAvPz8zh79iyWlpYwPz+PyclJ+P1+0Ua892aziXq9jnK5jGq1ina7LSDkd41GA51OR851uVwIBAKIRCJIJpOIx+OIx+OIRqNwOp0SD5RKJTSbTYmmC4WCaFcuAvNe9P2fWI3Y7XaxtbWFK1eu4Gc/+xmuXLkCv98vZkmbrHQ6jX/9619YXV1Fu92G3+8XOgEAwuGwmONwOAyPxyNmaXd3F3fv3kWz2UStVkMikcD29jai0SguXbqE2dlZuN1u+Hw+PP/882i326jX63j//ffRaDTE5+Rg6yyFlZjajt/ZbLaHJkj/BkCoGYfDgWAwiKmpKZw5cwZPPPEElpaWsLi4iKmpKUSjUXS7XQFdqVRCoVBAsViUz5VKBd1uF7VaTdwXglVfj9bF5/MhFAohFothenoas7OziMViiEajmJubExaDgLt79y729vbQarXQbDalHfq4ml80yfhh8liB6HA4cOnSJfz85z/H66+/LhpOa8JGo4G1tTVsbGygWCwiEAiIaW00GhLN0rlvNBrI5/PY3d1FrVZDKpWC2+1GOBxGuVzG/fv3sbe3hw8++ABra2t444038KMf/Qjnz58Xrfed73wHrVYLa2trWF9fh9PpRKPREP+UvtxRRZt3CqNZ+oXdbhcejwfhcBhzc3M4c+YMLly4gCeffBJnz57FzMwM/H4/AKBcLiOXyyGfz2Nvbw/7+/tCvVSrVVQqFQm42D6pKM35ORwOWfherxe5XE6ATD80Go1idnZWFiLbajabqFarojy4aHlffD+I7B4kx07fkJ7hBDDKarfbCAQC+OUvf4lvf/vb8Hq9fZqhVqshm83i3r17+Oqrr2T18+bpeDP642/k1GiKbDYbQqEQfD6fDPDs7CwSiQRWV1dRLpdx8eJFvPLKK7hw4YK0Vy6X8dFHH+Htt98Wv5MTasWTaTF5Qa0hdVSph1pnSmKxGKampvDEE0/Ia2lpCdPT03A6neh0Otjd3cXe3h7S6TRyuVwfAMnBMrgAHgRAFM0yOBwOVKvVPorK6XQiHo8jmUxibm4O58+fx/T0NDqdDtbW1nDt2jVcvXoVn3/+Oba2tsTn5PyahRZkHgBgc3NzKG6OTSPSYfb7/Wg0GuKP0OxFIhH85Cc/wQsvvCAZFEaIxWIRd+7cwc2bN5FOpzE/P49arYZWq4VSqSQDrVNULpcLrVZLIkSaGpoIOtq1Wg17e3sAIJO1u7uLGzduwOFw4OLFiwAOfMYXXngB3//+9/GnP/1JJuko2lBrASszpf3EbreLTqcDv98Pn8+HeDyOiYkJTExMIBKJ9EXAuVxOeL1cLodisSj3R0CT62s2m9J3mlWdHel0OpIcoFXhHO3t7Um7jLCTySRmZmZQqVSwv7+PdDqNUqmEfD7fB2RqeV1KprNFw+RYTbP2j7hKOp0OfD4fLl68iDfffBORSKSvszdv3sSNGzeQTqfhcDgQiUSwv7+PRqMhPiBwsKI5cPV6XSabwNR94ICQxuGEkuZot9vY2tpCIBAQv8jhcCAWi+Gtt97C9evXsba2dqSAxTRBg3wkps9oGjnZp06dEoomEAhIpLq/vy9EM4MPLkqCD3jA6fEvgwpNlGtQEoidTkeCmU6ng1KpJHMWiUQQDAYRCAQwMzODhYUFbGxsYG9vD41GQ6Jxp9P5EAlvRVsdJscGRJvNBrfbLf4IfQgAOHXqFL773e9iYWFBBq1areLevXu4ffs2crmctFEul2UgebMA+lJUmo4gsLRZ4rEARBOQO6M/2mw2sbGxgRs3buDll18W7uy5557DN7/5TWxtbaFSqQjhPkwGcWcEolVhq8vl6uPwpqenEY1GYbfbUSqVUCqVsLm5id3dXeTzecmj63ukaSTvp/1SPSa0PqZWpmtCa8Eomb5ouVwW2odRdjQaRSaTkWiayQCOuVkdPoocq0Ykz0dw9HoH+dvTp0/jlVdekcR7sVjEZ599htu3b8ugAhAtAUAGk6DkSuYA6kCCQYumRnQErs0501ykI27fvo1nn31WuMdIJIKXX34Z77//vhRAHEVMXk0L+87fvF4votEopqamMDk5iVgsJm4LA7DNzU3s7++LyaRW0wUSvE8C09zfQj9V57OB/v0t2oKRAioUCigUCvB6vbDb7QgGg0gkEkgkEvD7/aI0GLSYrMHXBkSuMGpEr9crlMS5c+cAHExUJpPBJ598gu3tbSSTSQQCgb4BZSDCz2aEplNiTGcRuAQdB5wrlb6T9ll6vR5KpRLS6TQWFhZkAV26dAlzc3PIZDIja0MzlWdFbmtNZLPZxPwlk0kkEgkEAgFxJfb39yVAKRaLAB5sDdBt65SgDjz4G6/Jyhkeyz5pK6LBWq/XUSgUsL+/D7/fD6/XC7/fj3g8jlQqhXA4LLnoVqvVV2RrJhBGkWMNVlhNQ97K5XIhFouJ38MOrq+vo1gsCmVCDs3n80kU2Ol0EA6HxZdhWhA4mBBqDgJMF04QiOwDzSv7xcli1Hfnzh1MTU0J5TM9PY0zZ87gyy+/RLFYHMlPNM3xYUUA7Jvb7RYej9VD7XZbaJpcLodyuYxmsymanJZB59dNzcOI1ePx9B1jVvjonDDHSi/yYrGI/f19hMNhaTMcDiMejwt3S/9SbysYtBX1MDlWjaide6fTKVmPc+fOSYfq9To++OAD3L59GwsLC/B4PLLqHQ6HFCHQv2GKjjeo91vQ7HBy+D3NhDZhOm1HGoiR3t27d/Hkk09KORUAnD17FtFoFPl8fuQU3yDf0CpwYcAQjUYxOTmJeDwutBTNYrFYlAXIIgjdBkFFUNI08xhz3MiNAuhzbThOfBGIlUoF+Xwe+XwePp8PLpcL4XAYyWQSqVQK6+vrKBQKYtL1eOt7H0WONVjReVqXy4VcLodIJIInnnhC/DuPx4PXXnsNzWYTHo8H58+fR6VSwfb2Nur1OhYXF7G7u4tMJoNisSimlkUJwWBQgg1W4gDoI25Z7MCVSopCB1FctdVqFU6nE3t7e4hGowiHw+h2u5icnEQoFBppIA8zw6bPxOM9Hg/8fr8ULvh8PjmffdTcKfDAlzYrXkzNpkvi9F/tK2oTrr8nwc6axVqtJpkaLhwS3sFgENlsVhINJmX1tZhm4IF59vv9yOfziMViOHXqFEKhkNxwt9vFN77xDXz66acSHXY6HSSTyb69D36/X3KaOipmJMuJI2Xh9XqFR6R5q9VqCIfD8Pv9sk+DpWQcLBaW/uUvf8Hi4qLcx+LiIpLJ5EO+jlXGwKQugOHbP1lfSJeEkStzxzR5pJxYCqdzxmYmQ/uzus6R/h+r3oF+gpsvTYkxVcgCilqtJn0g8Z1IJJDJZGRuBqUzR5Fj5xEZXLCUKRAISMEmV2C5XIbf70cul5PaQgYd9XodPp9PtBb9JlI2HHRdPm+Kjh4ZDRKAZm60UqkIf5bNZhEKheBwOJBIJBCPx2Xyh4kGoO4HAy5eT5dNcdHRn3O73ajVagiFQlKmpfuuKRIdHOg0HOdB01a8DseFfdHRtS5u1dfQkXS32xWtGIvFEIvF4PP5UCwWjxQhW8mxAlFXYnAgyNDThwAOALm0tIQvvvhCBk3zXybdoEVHgbymdo454H6/XyiGUqkkkZ3H4+mrWaxWqyiVSigWi1hZWcH09DR8Ph9SqRRmZ2eFYB8mVqbIBJ3pwHPidWDB+kBGqtVqtS9DwsDL1Lx0TXRRg150etuFru/U/eA8WI01lYDH45HKnUAgIAtej4PGwdfGI9JPI2VSr9dFc+lo8emnn8b9+/fFNOs0FU0T0E/VaA3I4zUlo1c+0O836s1Q2uyFQiHUajX4fD7UarWHAoBRtCGvTRnkH1lxeeyvznjQd6RLoyN87TNrv45A02Op+VldZMHr6gDKDFzYnqZ9WN1tt9vFr6VyYT+0Bh41UAEeQfWNjp5qtZqw8/F4XLSezWYThp7FnHr/CtBfuaJJWV3VzChdR6Y8nj4OnX1uqDJztFwYpCRoAnXR6VHFKlDQf7WW0WVgPp8PnU4HkUgE4XAYgUBA0pkavDyP48O0IQGpo1/+rnlXrRS0ZjX3nuhrcDGwWEUvDJ6v595sf5gce7DCGyLHxzzp/Py8HANA8srZbLavEpi/af/Gyv/QK5t/OZDa59EaUvtGrHBmTtrj8SAej/eZrP/k/nUfrKJabbZ01QwAyWBUKhVEIhEJ+phb1kDkePE7vZlJaz49Xjozo+dCg5GBih53ugT050n96Ovqdihfm0aktmOHWOC6srKCZ599Vkrx+XsymZT9IqQItPm18g/1IHEidG6ZQjOnuUMOGle2WRXOwIhlUnQr/lOxmhjdT7ou3NsNHJTgRyIR2ZficrlQrVal5I05ZR1wsY+DFi1/0wtDMxTmwjEDK80xciER7Pr6WqOabQ6TYzfNLpdLzKbH48H29jb++c9/4sUXX8TS0pJ0EgCmp6exu7srfhwAKYEH0EdUAw98HVPt6/QfAUoqRO9e0+ezIsflckmUzswOC2NH9Q9NsSKw9XfsI9No2WwWxWIRyWRSshcTExPY2dmBz+dDoVBArVZ7KD2prYJ+bwZDg/qiF5kV90dXSdccsjbUVBxmAGT2YZgce9TMFUwCOpvN4vPPP8edO3ewuLgonW40GrKtUWsrmgGPxyN0AakdVnsw+tMRutaSeg8IABk8PTA8hzSTzWbDmTNnZEKKxSLS6TQKhcLQzIoJPNNh1xqLfQMOaKxMJoN79+4J3zo5OQkAsoGevi0jY72lwgwKdNRrAlIHdCYFRJ7RZrMJOU2Np6u8uU2Bm/LL5bL0x/Qv9diMIsceNbNsSBe+bm9v49e//jVefPFFhMNhABBKZ3Z2VgouC4WCBAn66QL0kXSeVVfkMAvBhUDzT6DxdzrYJL8JVKfTiVdffVXI4k6ngzt37iCXyw2M/qxoDv2d6W+Zvmy73ZaCi/v37+POnTuIRqMCQObpo9Eo9vb2ZEOUFbhoahksWGlAzo/uM/1lU5txoeuHIXBLBgtos9msFMdynjS3aV57mBzrw9ypncx8Z6PRwK1bt/C73/1OPtMXCwaDwtSnUilMTEzA7XYjGo0CgFRoc6BZmaOByoHUDxyiVmVEzp1q3DxOkx2Px+FyuTAzM4NCoQDgYMK412XUqE8HRmaUrH/XmorlXpubm1hZWcGtW7dw+/Zt7O7uotvt9j3ZgYtIt0WAE2AaaNpc6gIJHs8x4pgBkIVL4fZSjle73UY+n0c6nUY6nZYCZrbJdvXcjyrHHjWbfhBvYGNjA7///e9x5swZXL58WbIGLC3a3d2V560ABxFkuVxGq9VCIBCQyLZarcpN6uDF5MEIWpvtIF3I0nt+pslrNpu4cOECotGomL9yuYzPP/8c6XR65ME0/TFtPjk2FC6gTudga+ydO3fE/FUqFZw9exapVAoulwvxeByzs7Po9XrIZrMoFArim2lXxBSOA8211nh6rPS57COtSiQSkZIvpiDz+Tzu37+P7e1t5PP5PpLc9DG1GzBMjj3FR5pA17653W5UKhV8+eWX+MUvfiFbSZnKIlD0/hNdKaKpB2YgCCqm/0y/iUCMRCISfLBttgkcbEu9cOFC32R9+OGHWF5e7lsYw2QQiWtqB5N3o99LMh+APAYkkUjAZjvYDJZIJGRhc6+yDr500KD5Wl5bv3TErCNgk9OcnJzEzMwMYrGY7C3KZDLY3NxENpuV7asm5TUocj9MHgkQTRrH4XBI7dry8jLeffddVCoVvP7660Jsp1IpbGxsYG1tTTSV3W6Xujft5NtsNikGYGTMQebvdLJZjtbtHpSUcVdct9uVyqCJiQlpv9Pp4K9//Suy2eyRqBvTHJuANwMaHTzU63Xs7+/3BSWkdWKxGADIPha3241SqSRFHeQhdZ5ZayJGu9p0UhPqPLJWHIFAAPF4HNPT05ienpY94+VyGTs7O9je3sbe3p5YJyu34yjUDfAI6Bt2RqfI6EMQIP/4xz/EvHzrW99CKpXCwsKCbAxaW1tDPp/H1NQUUqkUut0uSqVSX+qNpV5ut1uegwP0//sGgqBarUqQwsEJBoM4deoUlpaW+srXbt68iWvXrske4aOsbKvIUWcZzMWpn2rBqmwAsnekXC7j9OnTsqsvEomI2aSPXK/XUavVHuIVGYjoPS6cHzMTo49hdQ330CSTyb4AZXt7Gzs7O5K/18/BsaKORpVHslVAUwJcrVyJrK759NNPUSgUkMvl8Nprr+H06dO4fPkynnnmGbz33nu4f/++8GmFQkHKv1isUCgUxJSZ1A2B7/P5+rIGfHRJPB6Xx3mwMojpv9/85jcy0HTmj2pm2CdzMnR0TWZAf8/IlHRVPp9HpVLB3NycPHqOVd3kP7mf2+v1Stk+WQarsen1en3bc/kdxzYSiWB6ehqnTp3C5OQkXC4XstksdnZ2sLGxIZu5uPjNJ9LymkeVY9tgz5ti2RRXiOa+HA4H4vE4stmsDFA8HseVK1fwgx/8AC+++KKsSt5wpVLB1tYW0um0FNM6HA5kMhnEYjExbTTn2t+iZmCFTafTwczMDJ577jk8++yzmJyclD28+Xwen3zyCX76058CAHK5nGjcYcS2ziTp77TfqgGoJ01nKHTkzWroqakpeRrY5OSkPBeSFoDatFarIZfL9T14yaR6uKj0Dkum7gKBAGKxGJLJJM6fPy9PzCgUCrh+/Tpu3LiBmzdvYnV1Fel0WsaNDIl5r3os0un0UHwdKxAbjQbC4bCYCr2jjCahXC4jlUrJXgz6f4lEAv/zP/+Dd955B88880yfP1UsFvHVV1/JAyRZzJBMJgFAsg7UCDabTUqUGPRwE9CVK1fwzDPPIBQKSYBSr9dx9epVvPXWW8JP8hmO9DOH3TuAh7QC79kqmtRFBvTZdPUMACm5CgaDEjjMzMwgHo/LtgbuTOz1Dh7NR9+Rlojt6v7wRa3KfSjcSTg5OQmPx4NsNov19XVcvXoV165dw+rqKtbX11GtVuVZRCxGpma1WpTb29tD8fXYH108TPx+P773ve/h7bffxsWLFwVcfK5fJpPB6uqq/H+3XC6HWq0mgQu3EDidTpTLZfh8PkSjUZw+fRrnzp3D3NycZG3a7YPH3v3qV7/Cb3/7W+zv78vCMPfCHCZW2QxdpmamvfheO/n0n3WeV+d6+dQubj2dmJhAIpFAMplEJBIRQNhsD559Q2CwLX5Pk0qQRyIR2SZBi7a9vY1bt25heXkZ//73v7GysoKdnR0h1flYF9Jz2gVgn3m/j1UjHpfwZlKpFH784x/jnXfeQTgclqda0XTT11lZWcHdu3f7NuOzMpzP2Z6ZmZGHnbM8bW9vDx9//DHeffddrK6uYmdnR4pmj0o/WGVPtAbSbdFM0pfVkT6Bq7UY75NFGtFoVMr0E4mEAJJPj/X7/bIQWWHE67NNu/3B1grWZOqtrOvr67h9+zauXr2KmzdvYmVlBdvb27LPm76kWQDB+QP+P9CIwAPKwe1246WXXsKbb76Jl156CalUSswZV3atVkOhUHhoUGiyuNmqXq/L1tRPPvkEf/jDH/C3v/0NGxsbAB78Gwhd2Kt9t8NEg83MepigNtvW+06AhzfhayoLgACSJpXP0E6lUpiensbExIQ861BrOfrMWkvr3Y693sEe70wmgxs3buD69evy6BVqQuABW6H3vGjOUt8n7+e/EohaC7CUa2ZmBs8//zwuX76Mp59+WrZf0nfjNgBTA+lC23q9jlu3buHjjz/GRx99hGvXrmFnZ+eh/DUpCb23Y9Q+A/0TcBgQtVM/7FgGe7rAgNwsEwKRSEQCm5mZGQEm/+MCq7110kFX01QqFezu7mJ7exvLy8tYXl7G7du3hS/s9R48+pi+vybBTZ5Uuyn/tUDUVcaMwCORCGZnZ3H27FksLCzgwoULSKVSmJyclK2NLFjQ/zdkZ2cH9+7dw+bmJpaXl3Hjxg1sbW2hWq2KVtBaj3s+ONCjELNWQNS/6b9m9sUkgbVo0BKI2g/j78w4MWc/PT0toOTWz2g0KpqP4GM6kw/9zGQyyGQy2NjYwMbGhhQtc0xYTkftrP1Q09/VsrW1NXTeTyQQO52ORIIcbA6cw+FANBqVp2fNz88jlUohFovJ02eZBeDj7lZWVrC1tYVyuSxVOvSf6MRTw9CxHxQBDurzMCDyvRWoraJqfq9LtnRAoIMaakr6xvF4XAIZ/jeCcDgsLk+tVpNiW24cKxaL8uAl/v8VHW2T5tEZIZ1B04vCvKdRgHgi/xcfNSGftcjyMG7c4QOKrl+/LtqLOW2aa5obgozBCydSTzKzHHpbK/tx1AyBlZjpP22K9fdaTC1Jqomi88L8ncW+LLjNZDKybzsYDIpWbbfbkq9mjSGtCKtpOG6asDZ5UvP+rPo/8hidRI0IQPg9m+1gE3zv/xHXrVZLiNRer9dXPs8XB9vpdMq/rGCmJBQKSWqMQYDOxVK78JF3XPnD+qzBpf8C/eZYk768V6vsjdVE6708+hhN99Bf5v1wgTELRU1KztLcxKU1my5mMBcR29LFuOZxlFF8xBOpEYGDFe/z+WCz2eQ/BnCFcuC5evUzDBnVccK4mj0eT98WSQCSodATSj8IgBRLDCO0KdpXAg7fVqrf64IFq2NoIfRnvnhNml3t23Jh6jywLnY1r8XjdLbkMB7U/I6fj6oNgRMIRD0ZeoLMqJJRHMWsPtbcmRZzEqy0nTbNo9TTaY2oPw/yCc2oWbczyOEHHlTyWFX0UAOa2pYa0AwqzGpqqzSdrsjRWtBccOZY6P5+LfWIY7H2jQZpCZ19AAZH1CY4NaXE881MkAaeBoNOLZrtmiCy6qPWwlZitjWqjz0G4iMQK05Q/2Zlsq0+DwKeacJNf9T83nQXdD/0sVaAM8/Rv+tsihU9Ncg1sZIxEI9BBpmoQebLPGcQuKyONyfXDJDMc6z81kHXMd2LQfd3FICNKmMgPiI5Cu1jRtlW5x828WZEa5WW1BrLDDQGaehRzexh9zrWiI9ZBhHVVjIKj2geP+iag4Ikfd5hmtnsq1XwYvbbvP5R+20lYyAeo1hptkEyTMMdpq3MNgaZcatjrKLYQf7dYf01XQWrex91LIAxEB+pWPlbVjIoqNF/rY47DICDPmuf8TAiWgc7VvyhVR8HtTmKjIF4DHKYWR7FPJk+nlW7JoBMkFhpJav2zIh+ELjNds0+HMYhHtb+IBkD8RhkEHdovh8UkVppIf27/qvPMa+htyVYmdbDovPDtPKgz/+XIMaUMRCPQawAZsXtmccPake3YbZldewovpiVT3ccMixIG2vExyij8nr6mFHECphWmtGMmq36x2N1enGQRhslmre61ihadZCMgXjMYuWzaTkuTWS2OUpANIrvZuUWjMIx/l9lDMRjkmGE9KjnDTp/GFVjFUCYFNCg/g3r9yDC+zA56oIbA/EY5DAzd9g5+q8WK/M+SvtWfqN53mHZkuPW1uNg5TELI1ZNFh+WVTHfH8W8DYqITa03zFwP69+o3Oco9zmKjIH4CGWQH2UVZOjjKaNO5mHgG8QpWn036vWs2IFB2Zxx1PwYRT9yw2br/zcbhzn1h2UtBomVuR3l/GHR9qBjR/neqg2CkM+lHCYj71kZy1gepRzrM7THMpb/VMZAHMuJkDEQx3IiZAzEsZwIGQNxLCdCxkAcy4mQMRDHciJkDMSxnAgZA3EsJ0L+F5NxjDvk6hXCAAAAAElFTkSuQmCC", + "image/png": "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", "text/plain": [ "
" ] @@ -580,7 +582,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -604,7 +606,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -628,7 +630,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -652,7 +654,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -676,7 +678,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -700,7 +702,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -712,7 +714,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "2023-04-12 14:28:55,430 - `Trainer.fit` stopped: `max_epochs=75` reached.\n" + "2023-05-12 17:41:32,347 - `Trainer.fit` stopped: `max_epochs=75` reached.\n" ] } ], @@ -761,7 +763,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Scaling factor set to 0.5467963814735413\n" + "Scaling factor set to 0.5302040576934814\n" ] } ], @@ -787,7 +789,7 @@ "metadata": {}, "source": [ "## Define the LightningModule for DiffusionModelUnet (transforms, network, loaders, etc)\n", - "The LightningModule contains a refactoring of your training code. The following module is a reformatiing of the code in 2d_stable_diffusion_v2_super_resolution." + "The LightningModule contains a refactoring of your training code. The following module is a reformating of the code in 2d_stable_diffusion_v2_super_resolution." ] }, { @@ -830,11 +832,11 @@ " self.train_ds, self.val_ds = get_datasets()\n", " \n", " def train_dataloader(self):\n", - " return DataLoader(self.train_ds, batch_size=16, shuffle=True,\n", + " return ThreadDataLoader(self.train_ds, batch_size=16, shuffle=True,\n", " num_workers=4, persistent_workers=True)\n", " \n", " def val_dataloader(self):\n", - " return DataLoader(self.val_ds, batch_size=16, shuffle=False,\n", + " return ThreadDataLoader(self.val_ds, batch_size=16, shuffle=False,\n", " num_workers=4)\n", " \n", " def _calculate_loss(self, batch, batch_idx, plt_image=False):\n", @@ -843,9 +845,7 @@ " with autocast(enabled=True):\n", " with torch.no_grad():\n", " latent = self.z.encode_stage_2_inputs(images) * scale_factor\n", - "# latent = latent.detach() # avoid adding this to graph.\n", " \n", - "\n", " # Noise augmentation\n", " noise = torch.randn_like(latent)\n", " low_res_noise = torch.randn_like(low_res_image)\n", @@ -948,33 +948,33 @@ "execution_count": 12, "id": "936bbb9c", "metadata": { - "scrolled": false + "scrolled": true }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "2023-04-12 14:29:00,910 - GPU available: True (cuda), used: True\n", - "2023-04-12 14:29:00,911 - TPU available: False, using: 0 TPU cores\n", - "2023-04-12 14:29:00,912 - IPU available: False, using: 0 IPUs\n", - "2023-04-12 14:29:00,912 - HPU available: False, using: 0 HPUs\n" + "2023-05-12 17:41:38,503 - GPU available: True (cuda), used: True\n", + "2023-05-12 17:41:38,503 - TPU available: False, using: 0 TPU cores\n", + "2023-05-12 17:41:38,504 - IPU available: False, using: 0 IPUs\n", + "2023-05-12 17:41:38,504 - HPU available: False, using: 0 HPUs\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "Loading dataset: 100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████| 320/320 [00:00<00:00, 881.71it/s]\n", - "Loading dataset: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 32/32 [00:00<00:00, 432.94it/s]\n" + "Loading dataset: 100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████| 320/320 [00:00<00:00, 773.44it/s]\n", + "Loading dataset: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 32/32 [00:00<00:00, 495.25it/s]\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "2023-04-12 14:29:01,593 - LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0,1]\n", - "2023-04-12 14:29:01,624 - \n", + "2023-05-12 17:41:39,194 - LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0,1]\n", + "2023-05-12 17:41:39,226 - \n", " | Name | Type | Params\n", "-------------------------------------------------\n", "0 | unet | DiffusionModelUNet | 266 M \n", @@ -990,7 +990,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "982fa79bf5f14929a0c3fd70493f04f2", + "model_id": "71e4d5d2e391477aac58bfb05ecefb85", "version_major": 2, "version_minor": 0 }, @@ -1018,7 +1018,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "853963627ed142b78baae63ae84ed458", + "model_id": "be43a3c9e09a4405a067d9fc887e151a", "version_major": 2, "version_minor": 0 }, @@ -1032,7 +1032,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "debc57241c794afc9c724d59047c9c6b", + "model_id": "bc6fe02c06e848a48a3cff1662788638", "version_major": 2, "version_minor": 0 }, @@ -1045,7 +1045,7 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAKIAAABDCAYAAAAf6t48AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAa/klEQVR4nO1dS2xbWfn/+b58/X7GTuMmTdLQhmnIdErpzFTVgIpaxALxGIkFQqxYjIRAsAKJgQViARJbFrNgg4TEHipGaATTogJ9MG3pJG3akjZx0thO/L62r6/vtVnk/50e3147TpsOgb8/KXJyfR/nnvP7vu/3PU7r6nQ6HQxlKP9hEf7TAxjKUIAhEIeyT2QIxKHsCxkCcSj7QoZAHMq+kCEQh7IvZAjEoewLGQJxKPtCpEFPHBsbe5HjGEofaTabEIQnNoNqEC6Xq+s8Ot6rRuFyubqusV9v/9vpu37n2J/TbrfRarWwtbW14zUDA3EovRd4tzLIYvKiKMqur+n37H5AtUsv0Pe6J3+eIAhdCtRPhkAcQHhL0+l00G63nzru9Ak8sQ4ul+uphdkNuHot9rNIr+udQLrTs/p9vxvFHQJxQCEA0g+BstcPCQFQFEWIoghg21LsFoT02WtxO51O1z2dznN65m5B7aQM/LPa7XbXOElpd5IhEB2k1yKKoghJktjf/HeD3M8O0mexcM9iDekaO1h3OnfQ652sdT+lcZIXBkR+YDtNgJM76OcinLR/rzgUb9Usy4JlWeh0OpAkCW63G6qqQlVVyLIMSZLYJ/2Iotjlfk3TRL1eR61Wg6ZpaDQaaLVa7BkE8Bfpbvnf7UCzK4ZTANRvfp3Axl8z6Hu9UItoWRZUVYWu65AkiUVSLpcLpmkyV0WL6PV6oSgKQqEQWq0WJEmCruuo1+sol8vQdf0p8isIAlqtFmRZ3rUW9hJyv6ZpwjAMdDodCIIAWZYRDAYRi8Xg9Xrh8Xjg8/kYOOmH3rXT6UDXdWxubiKbzWJjYwOZTAamacI0TViWxYA7iKLaQTSodbNbtJ2CFf7+O3FT3srzz9utYr0wIBIxr9frUFWVLa6qqgiHwzh48CBSqRQikQiSySTi8ThSqRSi0ShUVYUoinC73cjn88jn81hYWMAf//hH3Lp1i/EO+nS73Wi1WrvmXrzwi0OcTlEU+Hw+yLKMUCiESCSCaDSKkZERBsBgMAiPxwNVVdkxSZLYWBqNBrLZLCKRCHw+HyRJQrFYRLVaRb1ed3z+oFyun6Uihe0FlH735u/LW7ZeY7AHb89EHwZtjN1NHpEGJ8syTNOEoigIBoP4whe+gLNnz+LAgQMIh8Pw+/2QJAmKokCSJLTbbWYl6YVM02RaubGxgffeew8/+9nPkM/nGcBN04Qsy+zZuxUaL1k+QRCgKAoikQhisRji8TiSySSCwSC8Xi/8fj9kWWbKIssyFEWB2+2G2+3uctGWZaFaraJarWJzcxPLy8tYXV3F48ePkc1moes6ez4FNjsBcSfQ8sedIngeMDzvtSwLgiB0BRg8yHhQ0zjJwNB97crRarWQy+V2XIMXAkT+BaampvClL30J3/jGNxCNRpnbyuVycLlckCQJpVIJhmEwLd7c3EQikYDb7UY0GoXf74dlWezFr1y5gp/85Ce4fv06/H4/m4xmswm3272rcQLbk0y8jUAVDAYxMzODl156CUeOHMHExAQURWFu1TAMtFotmKbJAMynaWRZZj+KokBRFLRaLaTTaSwtLWFhYQH37t1DoVCArutoNptwuVyQZfkp+kH3p995cbJcvbgefy9RFOH1ehGLxTAyMgJFUdj96Np6vY56vQ5d19FqtaBpGnRdZ+9M/Lkfnx8UiC/ENdPLvvbaa/j2t7+N119/nb1ou93Gw4cP8fe//x26rkNVVTSbTVQqFdRqNYTDYTSbTUSjUeRyOaRSKXzyk59Eq9VCIpFAJBLBiRMn8L3vfQ8///nPsbCwAEmS0Ol0oKrqM1tEWjyPx4NwOIxUKoW5uTm88sorOHr0KA4ePIh2u41yuYxSqQRN06BpGgNju92GZVlMAclaejweRKNRBAKBLovZ6XSYJc9ms2g2mwNzN/vYnYIQJ/fLp5KCwSDm5+fx6quvYmJigo1JEAQ2xkajgUqlglKphFwuh+XlZTx8+BBbW1toNpvQdZ0FdPZnOaWy+smeAZHXQkEQcOrUKfzoRz/Cyy+/zAZnGAYePnyIxcVFVvapVCrMBVuWBcMwkM/nIQgC44fFYhEffPABDhw4gO985ztIJBL4zGc+A13X8eMf/xj5fJ5ZzEH5idMECYKAUCiEmZkZfPzjH8eJEycwMzODRCIBSZLQbDZhmiYLoBqNBur1OlqtFqMIZCXI5TUaDXb/YDAISZKQSqXYWEVRRK1WQ6VSeSqSdQKTnb85HadjvFslgPn9foyMjODkyZP49Kc/jfHxcZimiUajAUmSEAqF4Pf7mfWnYA0AisUi7t+/j+vXr2NhYQGPHz+GpmmM6/J8sd88O8lzu2b+ZWlyJycn8atf/QpHjx5lk5PJZLCwsIBMJoN6vc5SGYZhQFVVGIbBeGW1WkWn00EoFMLm5ia8Xi9CoRAePXqEl19+GW+++Sbi8Th0XcdvfvMb/PSnP0W73Yau64wr7iS8xgqCANM04Xa7MTs7i9OnT+PUqVOYm5uDqqpoNBqo1WqoVqsol8soFouo1+vMKhC/tFtFAJBlmQUzBIJkMglFUfDgwQNcuXIFly5dwtLSElqtFhRFeSpqpd/5eXZ6H6eggjh4MBjE+Pg4jh07hvn5eczMzKDdbmN1dZVF8oqiIBaLIRwOQxRFlqlQVRWJRIJRK8MwsLq6ir/+9a+4ePEis+j8u9OnYRgvvtbMT5gkSSwl861vfQsf+9jH4HK50Gw2sbi4iIWFBVQqFXg8HtTrdVSrVWZFNE1jgQ3l7AhY7XYbpVKJPSOTyeDq1as4d+4cPB4Pzp07hz/96U+4dOlSV6AziBCAKHUUDAYxNjaGqakpTE9PIx6PQ9M0bG5uYn19HZVKhY3dMAxmAfn54EFJi0Hg8Hq9aLfbSCQSSCQS6HQ6yGazWFpaQiaTQa1WY3z1WVIgPGjJIgeDQUxPT2Nubo4BMBKJwDAM3L9/H+vr64wWmKYJQRDQaDTQ6XRYzpOMQz6fRyAQQCAQwOTkJPx+PyqVCi5fvsxA6KQ4g8hzAZE4h2maALajrrNnz+LcuXMQRRG6rmNhYQE3btxg5L5Wq0HXdRacSJLEuBalYYi4A9tci1Iz8XgciqLg7t27mJycxLFjxzA+Po4vf/nLuHz5MotSBxEi28C21YhEIhgdHUUqlUI4HIYgCNA0DVtbW9jY2MD6+jo0TeviRvbUiB2IvIUggGmaBsMw4HK54PP5EI/HMTY2hmw2i1wuh1qthmazCaA7BdMrge+UkhEEgaXJ3njjDZw/fx5jY2NQFIWtV7FYRKFQYJkKStgHAgG02202Thq/ruvI5/PQNA3FYhGpVAqpVApnz57FyspKF7Xg52NQ2ROO6HK50Gq1EAqF8NnPfhaRSAT1eh0XLlzAtWvXGA8hoJD2NRoNyLIMy7IYmAmwBEC6Ttd1eDweANvR3P379zE5OQmPx4PTp0/j0KFDWF5e3tW4CYiyLCMej2NychKjo6MAgMePH2NjYwPFYhGZTAb5fJ4BkCy3k8Vysoh8SsQwDJRKJWxubsKyLLjdbhw4cAC5XA6WZTEvAOxcMXKyOoIgwOPxIBaL4dSpUzh//jyCwSAWFhawsbEBSZIQCASgKArq9TqL7MkjKIqCQqEAwzAYP+S5K42RkvsvvfQSXnnlFTx69IitHZ3rxBl7yXO7ZtKodruNaDSK8fFxyLKMtbU1LC4uotls4ubNm/B4PDAMA5ZlsYmixSKXSjk14nnkFkRRhGmaqNVqEEURHo8HhUIB2WwWU1NTiMfjOH78OJaWllhObNCxk2uORqNIpVJIJpOQZRnlchm1Wg2lUgmlUgm1Wq2rNAfgKU5mtwhUuqPfRVGEYRgoFAospSNJEkZHR5HP51GtVpHNZlngxd+LF7vbJsBSDlQURRw5cgSnT59GIBDAysoKFhcXUavV4PF4UKvVoKoqC7IoOFEUBZZldfE9suzNZhOGYQDY9lKdTgc+nw8zMzM4fvw4/vKXv6BarT7lBT6yqJlMMFUipqenAYBpmSAIGB8fRzqdht/vR6FQQLFYZBZPVVV4vV5m+Yg3AujKEfIWU5IkZLNZrK+vI5VKQVEUHD16dNdjJyCKogi/3494PM4iZHI19o4bJ7GnUPj0Bf1Nous6SqUSS6HIsoxoNIpEIoG1tTXGj/tVO/i/6Rmk0LIsY3Z2Fl/5ylcwPT3NeDUB1LIsFumTUPRPnoqoEZ1PBoTehSJqQRAQjUYxPT2N2dlZrK2t9cwt7iTPzREty4Isy6jX65ienkY4HEan00EymcSxY8ewtLQEADh06BDTvnq9DkVRmObpus6iRUmSoKoq00LTNOH3+wE8Kb2ZpolIJIJ//OMfmJ+fh9vtxvz8PARBcCxn9QMQ3ZeiW7/fD1VVGT8jJeBTGfbImISvitjdEj2r1WqhWq0y4EYiEXi9XgQCAaa4/RaxV4WFON7MzAy+/vWv48yZMyxAoii32Wyi1WrBMAxWmyfO6HK5oGkaGzMFYpQjpesAsOS8IAjY2NjA3Nwczpw5g6tXr0LX9Z5j7yfPbRHJTMuyDJ/PB7fbzQAzMjKCpaUlZvIrlQpkWYaqquw8mgSyeLQQLpeLAYKy+ZIksTJUPp9Hs9nE6uoqPvGJT2BiYgKxWAyFQuGZ34UUgerLRDkoQAGepCX44ITGbXfVPDekT8uy0Gg0WGUjEomwxDd1Yg9iTXiFo/lWVRUnT57E/Pw86wySZZlVm6rVKlNu+k5VVXg8HrTbbRZE8a6e5pzegRSRQFqtVmGaJlKpFLxeb9fYdiPPDUSabFEUuxKbgiDg2LFjuHfvHorFIjqdDtxuN8rlMhqNBizLQqvVYnyIXCTdj9I15BapkYA6cMidF4tFWJaFQCAwcFs6Ce9CW60W44BUN3a5tpsWSGns1sjeIMvzNKdolhaRrEu73WYRrr1rxz5Gp6CFB77L5YLf78fhw4fR6XRQKpXg9/tRrVaxsrKCXC6HSqXCAkAqJwYCAfj9fgSDQWYVeS5s9xoAulrg+EzFblM2vDw3EHn3k06nUSgU4Pf7YZomfD4fkskkKwnRQpH28akWenngSecOuQVy1/ziuVwuJBIJJJNJNim7FVpAogfVapXl8ki7vV4vs/o8eScuxHNHHoi8heR5HL2fvX9xN3nDXslt6hDSNA35fB5utxu6rmNlZQWapgEAs2T0SUHUxMQEVFXFgwcPsLGxwTwUn0bjLS9VaUKhEFNYWh+n6s9O8tzbSfkH5XI53Lx5k1VIXC4Xc5l+v7+rAZQmnvgHEWWyknw+kU/7kEuha4mvVCqVgVMF9HzeAlcqFWQyGWQyGWiaxviV1+uF2+1+quHVPgfEG/lo007aCYAUoKmqylJfxN/sHLcfv7VXh4hnkqJTx0+lUumyvGTRaM5N02Q1dj6dxiepyUPRPahaRApLVRh+vLsJWp4biAQuy7JQLpfx3nvvMatiWRaSySRzbXzrFDWW8q33ZGloIihlwAPUsizUajXGGROJBERRRLFYRLlc3tXY+eAnn89jdXUVq6urKBQKLD3h9/vh8XhYIwCBkRSEt2Q8h+KtJw8u4tJ8cNJsNplFsUfgJPZ8Hi90LllZegY1FlOCnKJqUmSa51qtxsqWBDxemeyUgw9eKHdIbv9Z3DKwRxvs+VTCu+++ixs3bjAt9Xq9SCaTrKWIUiXEh0jL6FMQBEaa+a5ry7JYzXRkZAR+vx+vvvoqO+f27duM+/SKLHnhc3u09/bRo0dYXl5GNptlAQVpPQUTBEZ+QxRVJvhKCJ/Q5gMcql5Eo1H4fD4AgKZpKJfLDAhOPYn29+LdPs0PX5UBwBo0KF9oz2lSN5DL5WLPp9o0BY30boqisOCNUlCbm5vY2NjA5uYm0ul0V4PER5q+oQdKksTC+UKhgHfeeQeTk5MYGxuDKIoYHR1FPB5nYDRNk3FJYHsDObVwUVWFOB/lq3w+H8thUcf0xMQEOp0ODMPAlStXdv3ylEgn69tsNhkYk8kkgO0cG7lpAjoAZul4C27PNRJIyGu43W74fD5Eo1HEYjGIoohqtYpcLodMJoNKpcLet1dJjz8GdKepyuUyNjc3cfDgQcY/+feka/hgjKwnsK0w1GVOAOaBS+9DNALY5vbFYhHZbLZL4XYre1LiI55BbuHixYv4wQ9+gO9///uYm5tDLBaDJEmo1WoA0FVLpQ5nvnzGc0LLsuD1etkeFrIY09PTiEajcLvduHLlCi5fvryrCeDPJU5lmiY2NjawsLAAURRRKpXg8/lgmibC4TCzjtVqlbk8uwXi78lzLL43MZlMYnR0FPV6HZlMBul0Go8ePcLW1hYLIHq9C++6CViUeSiXy7h9+zZmZmZYO1coFGLNuXQeWXqyfMTz+LSSkzunBDfxR6/Xi3A4jHK5jPX1dZZnfBbZEyBScEIRLgC8//77SKfTePvtt3HmzBmcOHECv/vd7/Cvf/0LiqLgyJEjLKEtiiIikQiAJ/+8BmkXtWB5PB4kEgnouo5Dhw7hU5/6FGtV+v3vf498Ps9AOqjwi03jrlaruHPnDkqlEjKZDKampnDgwAHW3EoWo1qtdiWA7a6TOC1RFFmW4ff7EYlEMDIyglgsxrjVysoKHj16hGKx2LWprJcV7LUGtVoNf/vb3zAyMoLXX38dsVgMqVSKWdtms8lSLmTlXK7tPlGqJFEQQgB2ubabhWljW6fTYUFWKBSCpml4//33ce/eva5Iu1fKqZfsiWsmHkG5OOJLS0tL+OEPf4i33noLX/ziF/HWW2/h2rVrLLWwsrKCdrvNFpZ4CADGCSnZ2mg0kMvlMDs7i9dee42Vma5evYp3330X5XIZPp9v4O4bXshKANvAT6fTyOVyKJfL0DQNlmUxDgtsb9aiiaZghyow5L6oEtNut1nFJhQKMQqiaRpyuRzW19eRTqeRyWTQbDa7XOqg80+fRHmuXr3KNnjFYjEcPXqUWXFKUFMgSMEH8CTYop2UHo+HpbIo8U6WUtM0rK2t4Z///Cdu3brFmjXIGHykHJFIOUVnlBagl1IUBSsrK/jFL36BP//5z/jud7+LN954g0VaDx48wO3bt1EsFqEoCsvZkUvzeDxsI1O5XMb09DTr7mm321hcXMTbb7+N1dVV+Hw+GIax655EEtJewzCg6zoqlcr2BP1fmqPRaCAQCLAaOu3aIwtMkT25LbKGvFsmS0LB0J07d3Dnzh1ks1mWabCnuOxjtKdE7C6aeO4HH3yAWCyGSCSCyclJNudUXSGLDWwnqA3DYFWXQCCAUCjE1oM4ayaTwb1797C0tIRCoYBKpYKtrS3GbfkxD1ohYu/RGfDsnTZP2U0xH0nTcZ/PhzfffBNf/epXMTs7y/YkLy8vY2tri0ViFDxQ00MymcTU1BQOHz4Mn8+Hra0tXLhwAb/85S+RTqcZeAftvOk1fgBdls3j8SAQCLAtr+FwmC3s+Pg4C8Io8qbFJKtB5TXeBWazWTx+/BgPHz7E3bt3sb6+zqwvXQM8XZGhYIEfqz3XyCecU6kUTp8+jXPnzmFiYgKWZeH+/fus0kVNr9TN5PF4WEKcmj+ILq2uruLy5cu4fv06crkc61Wk/CffxsePi/oaq9XqjvO/Z3tWnLTXflzTNPz617/GxYsX8c1vfhOf//znEY1GMT8/j06ng0qlgnQ6zawKNXcmk0mW6rl16xbeeecd/OEPf2D9dABYauF5x08WGNi2MPl8HoVCAblcDsFgEKOjo3C5XGxPM3FAUgK+3EcBAbnNWq2GtbU1LCws4MMPP8TDhw9ZEti+jdY+tl5W0H4+VYmouBCLxaAoCkZHRzEzMwNBEJjiU+RLCepgMMh2TXY6HRSLRSwvL+PSpUu4ceMGSqVSVzrInmuk93ea1x3nf68s4iBCUTCw/fJzc3P42te+htOnTyOVSnXtbaZz+S2mFy5cwG9/+1vcvHmTRXE0mW63u0sr92KslIej/SyUejl8+DCmpqYwPj7Oiv18BYjv/Aa2AxfqcCar9ODBA2SzWTYXverTJE7HnLwO8ESZvF4vDh8+jM997nM4c+YMRkZG0Gq1UCgUsL6+zrayqqqKeDyOSCQCRVFYX+TS0hJu3ryJlZUVNBoN5tL5eR4kgCKa008+ciCS9hOhrdfrSCaTOH78ONtDnEgkmDVKp9O4cuUKPvzwQ+TzeeYy+QYFvu6728aHfmMlN833+pGVpuAjHA6zSNrj8XQl4QnItVoNjUaDbT2gKlC9XmeWvh8I7cedlsx+PZ90HxkZwZkzZ3D+/HnMzs4iGAwyWkRBC21yun37Nq5du4bl5WUUi0W2rYP3NnzVqNeYqXIzqGv+yIEIgEWaVDsmq0YRI6VCaIKAJ/yHvqOcGBFtimCfxz33Gi+JEwemf5jJ7/ezsh1FptRIQRvTKRjoVcbrJ3wk2sst8+Oy92aqqorZ2VmcPHkS09PTLIKn0uzKygru3r2Lu3fvsn/wgMZqfxYp6U50Yd8D0Z6QJaGAg0/B8PVgupa3fMTRRFFEs9l85qh5kLETXaDAhKgDRcXUVMvvQqzVaqjX6+x8Uh6qXQ8qvQBH3w0SyJBFp5wgpdna7Tb7F8uIivD50V7pGCdF5Y/9R4KVQWQn90IvbHev9j0c/Pe8G9wrt9xLaFEoKUxVE+K0tIj0HfFF2kbBW6tnKYP1EifLxAOS/iYrR6kiMgh0jn3TFq98ThbcDjz7mu4mfbOv/qHO512cvVxcp3uTkvBRMi9O+5yBJ10xeyF2r8If6zd2+/X2fGQ/QA36nH7j3Un2FRD3u/SKXJ1+eGvDg+ZFKhv/XDvQ+HN63XcnV9uPmz6vDIG4B9KvmrAXILSnZ/jjTuPoF1U73depWtPr915cdKdn7SRDID6n9Erk73Rsr8SpomX/fqfrBzk2yBh4UO/2nYdA3CN5kWDjpRdwdmN1+9WBd1sjdkop0d+7uc/wv0D7L5F+i7oT+OwRbz+36gSgXhGz/W87Tx5kbCRDi/g/IP2CiJ2CGycZBDyDuPyhRfx/KE4J753O4d253eo5Rfu9gph+YxpaxP8h6bWg/axfv5p1P045iJvvdZ7TvYdA/B+SXi7OKTrtVeLbizHwz3Oq3tiP8+PYSYZA/C8Qvuevl8sdNE3jBF67lXP6dIqO7b/bz6H9z4PIwE0PQxnKi5RhsDKUfSFDIA5lX8gQiEPZFzIE4lD2hQyBOJR9IUMgDmVfyBCIQ9kXMgTiUPaFDIE4lH0h/waRXl0E6lnDfgAAAABJRU5ErkJggg==", + "image/png": "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", "text/plain": [ "
" ] @@ -1070,7 +1070,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "e68a0826dfad4a2b933c1793ae5a5961", + "model_id": "5aa3448de1094d0f82f2808b8131bb9e", "version_major": 2, "version_minor": 0 }, @@ -1084,7 +1084,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "f7b5d62453ce4440986f2a966f993691", + "model_id": "d3db0817d9674e5f9fb7027521b9e032", "version_major": 2, "version_minor": 0 }, @@ -1097,7 +1097,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1122,7 +1122,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "82a45e1e568f4af68ed20bf170a32569", + "model_id": "9b9fad73a311409082600b576378c2b7", "version_major": 2, "version_minor": 0 }, @@ -1136,7 +1136,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "f7ebd03b89314e0f92c65c1095b6a4e4", + "model_id": "4fee43bf923247019574f67cc2aa7c0d", "version_major": 2, "version_minor": 0 }, @@ -1149,7 +1149,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1174,7 +1174,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "a2dbfb54bcc8427682275ec8ca7717ee", + "model_id": "323be58fabcb4ab4a9a128d9f6cc9b52", "version_major": 2, "version_minor": 0 }, @@ -1188,7 +1188,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "8d3152112c4747c3a14274f8f9169661", + "model_id": "b80e5eb10ac04eb6a3f90ac7415ab681", "version_major": 2, "version_minor": 0 }, @@ -1201,7 +1201,7 @@ }, { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAKIAAABDCAYAAAAf6t48AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAcBUlEQVR4nO1dW4wbZ9l+ZsYez9je9WnW3l1ns4ekybZJQ0lpCQmkBxohLlCpihBCiCsuKiEQXIFE4QKBBBK3XPSWK+5AgogIVdBUKiINLTntpttsssl6Dz6fZzy2Z+z/Iv/78Xky3vUe2i7Ij2RtfJr5vm+e7z087zuO0O12uxhiiE8Y4ic9gCGGAIZEHOKAYEjEIQ4EhkQc4kBgSMQhDgSGRBziQGBIxCEOBIZEHOJAwDPoBycnJz/KcQyxBZrNJgRBQLfbZQ8Ars8J3W6XfYcgCAL7S+9vh37Hd0IQBPbgz2XbNur1+rbnGZiIQ2x9IXaCQQjAw+v1PvIdJ9HcCEevOQlJ5BJFse+c3Ejs/Ox28+h0Omg2m9tND8CQiAPBaYE6nc4jr7v9BXothSiKEEWx571B4LQyPCncjsFbO+e/ncftZ+3czgmAzX2rsTvXaxAMiTggiID04N2i24NABJQkCZIkAQBEUdyxVeQ/77Ru/cbLu0q34/Djo3/T3PqB30g8iKBu4xgEQyK6wG3xBEGAJEnweDzsOf/eIMdzknQrq9bvGG4u0g28JRNF8RGiSJLE5iTLMnPTlmXBtm32Odp4/HFpHjxxO51Oj+V3eo/t8JER0blwg5hywnbxiPN4gwbeg4C3arZtw7ZtdLtdeDwe+Hw+KIoCRVHg9Xrh8XjYX3pIktRjNSzLgmEY0HUd9XodjUYD7Xa752ISKQYd304+R2ShedBmGhkZQTQaxfj4OGZmZqBpGjweD6rVKrLZLAqFAvL5PGq1GtrtNiOnJEk9hLUsq4dwNDfCJ05E4GHGpCgKTNOEx+NhiyIIAizLYq6KLqLf74csywiFQmi32/B4PDBNE4ZhoFKpwDTNR1yDKIpot9ssoN+PhIKsgGVZaLVaLLD3er0YHR1FLBaD3++HqqoIBAKMnPSguXa7XZimiVwuh0wmg83NTaTTaViWxS4kEXe7jeqM1ZyvO5/zRBRFEbIsQ1EUjI6OIhQKYW5uDidPnsThw4cRCoUgSRJs24au67AsC6IoolqtYnl5Gaurq8hkMqhWqzAMA6ZpotVqod1uo9VqAXiYUCmKAlEUexKUT9w1U2BuGAYURWEXV1EUhMNhHDp0CMlkEpFIBIlEApqmIZlMIhqNQlEUSJIEn8+HQqGAQqGAhYUF/PWvf8X169fZLqO/Pp8P7XZ7V7EXgV8wiulkWUYgEIDX60UoFEIkEkE0GsXY2Bgj4OjoKFRVhaIo7DWPx8PG0mg0kMlkEIlEEAgE4PF4UCqVUKvVYBiG6/nd4ji3ebnFjU7XL0kSRkdHEQ6HMTIywqy63++HZVnY3NzE8vIydF2HbdtotVrweDwIBALw+/3w+Xzw+/3weDzsfdM0mZXkLSHvxvuNuR8+EiKSWyO3JYoiwuEwvvKVr+DFF1/ExMQEwuEwgsEgPB4PZFmGx+NBp9NhVpImMzExAUEQ8Nxzz+GVV17Bm2++iV/96lcoFAqM4GQR6dy7GS/FOrSBZFlGJBJBLBaDpmlIJBIYHR2F3+9HMBiE1+tlm8Xr9UKWZfh8Pvh8vh4XTd/RNA3j4+OIxWJYXV3FxsYGMpkMTNNk68UnDm5jdMuE3TJiZ+zGk5Q8TavVQrVaRbVaha7rzKWSp6rX68zCeTweqKrKYklJktButwH8x1XT8Z1x7ydqEWk3WJaF2dlZfPWrX8W3v/1tRKNR5ray2SyazSZs20Ymk0Gr1WIXIZfLIR6Pw+fzIRqNIhgMwrZtTE5O4lvf+hYee+wx/PznP8e//vUvBINBFow3m034fL5djZliKFr4YDCI6elpPPHEEzh27BgOHz4MWZaZWyXXRDGSIAjsOblxesRiMUxMTGB2dhYTExPQNI1Z8WKxCNM0YVkWBEFw1Qx5bKXtkRXmPQNZalVVWZwbDAYRDAahKArbBMBDq0YbiDa2JEkIBAKIRqNoNBpoNpuwLAvNZrNvUudMcAbBR2YRRVHEmTNn8L3vfQ+f+9znIMsygIfudGVlBf/85z9hmiYURUGz2WQ7MxwOo9lsIhqNIpvNIplM4umnn0a73UY8HkckEsHp06fxwx/+EL/+9a+xsLAAj8eDbrfLFnY34yUyqaqKcDiMZDKJkydP4tOf/jSOHz+OQ4cOodPpoFKpoFwuo16vo16vM/JRQkAXgKylqqqIRqPMLZLFJOvj9XqRyWT6Xtjtxk3gdT56XZIkKIqCWCyGsbEx+P1+BAIBlqgEg0E0Gg1GHEEQGCl5Qnu9XkSj0Z5NaJomS+ac43Gz3Nth34jIn1QURTz77LP46U9/ik996lNscK1WCysrK1hcXEQ+nwcAVKtVZj0pBikUChBFkcWHpVIJ77//PiYmJvD9738f8Xgczz//PEzTxM9+9jMUCgXm2vaSfYqiiFAohKNHj+Lxxx/H6dOncfToUcTjcXg8HmYNKIFqNBowDIPFRzQHPjttNBrs+KOjo/B4PEgmk2yskiRB13VUq9VH4rxBZCE3OQUADh8+jCNHjuD48eOYmZlBIBCALMtQVZVtCFEUUalUsLGxgUKhgEajwYhGG4vGGQwGWcxomiaz4k6Bmx9Lv3V2w56JyFcZaNDT09P45S9/iePHj7PPbW5uYmFhAel0GoZhwLZtNBoNtFotKIrCJk9Z28bGBkKhEHK5HDY2NnD8+HHcv38ff/jDH/Dqq69C0zR86UtfQj6fxy9+8QtIkgTTNJlLGQR8qYviQk3T8Pjjj+PZZ5/FyZMnoSgKdF1HNptFrVZDpVJBqVSCYRhoNpswTbMnHuOtIvAwmyyXy9jY2EAwGMTY2BgSiQTm5+cZuTc3N5HL5dBut/vWh2m8bq9TbE1r/9JLL+GFF15AOBxmVpl326IowrIsJiX5/X40Gg0IgoBms4lOp8PUAtu22Xc1TWMei4jIW0VRFHss5E6wJyLyO9fj8bBA97vf/S4ee+wxNrHFxUUsLCygWq1CVVUYhoFarcasSL1eh9frZfEWJS50kcvlMjtHOp3Gu+++iwsXLkBVVVy4cAF/+9vf8Pbbb/ckOoOACETS0ejoKCYnJzE7O4u5uTlomoZ6vY5cLof19XUmX9RqNbRarUfEXz45cMsg/X4/Op0O4vE44vE4ut0uMpkMlpaWkE6noes6SygGse68NQQATdPwjW98Ay+99BLC4XCPmwXArF2z2WQhRq1WY1ohEY+Ox8+h3W7DNE0EAgFMT08jm82iXq8zA9LpdB5JtD62rJl2mGVZAB4G/C+++CIuXLjALNTCwgL+/e9/s+Be13WmQ1FiQLEWBfDUbQKAZWiiKELTNMiyjA8++AAzMzM4ceIEpqam8Morr+Cdd97Z0Y7kg3SPx4NIJILx8XEkk0mEw2GIooh6vY58Po/NzU2sr6+jXq8za0AXzCnc97OORDC6eIIgIBAIQNM0TE5OIpPJIJvNQtd1psO5XVjeHfNrJAgCzp49i3PnzsHn88G2baiqyojX6XRgGAYKhQKy2SwqlQqazSba7XaP9OLUB/nXG40GZFlGMplk60AbcreyDWFfYkTKGEOhEL74xS8iEonAMAxcvHgRV69exdTUFMsm6QKSa/B6vUyhB8AWgghI3zNNE6qqAgAMw8CdO3cwMzMDVVVx9uxZTE9P4969ezsaNxHR6/VC0zTMzMxgfHwcALCxsYHNzU2USiWk02kUCgVGQD5TdsLNIvIltlarhXK5jFwuB9u24fP5MDExgWw2C9u2mRcA+gvWRFCKRQVBwNjYGJ5//nmEQiGWYHS7XUbEVqvF5lSpVJgF5DcMEc5pFcmSyrKMZrMJv9+Pz3zmM1BVFZcuXWJunK/Bu41/K+zZNVN80ul0EI1GMTU1Ba/Xi7W1NSwuLqLZbOLatWtsd9JOjcVibPLkUklToziP9EFJkmBZFnRdhyRJUFUVxWIRmUwGs7Oz0DQNTz31FJaWllgteNCxk2uORqNIJpNIJBLwer2oVCrQdR3lchnlcrlHa+OtIG8BnDEckYT+LUkSWq0WisUiZFlm+un4+DgKhQJqtRoymQxLEvqNG0CPO/R6vXjmmWcwPz/PEj7e1eq6jkql0kNCnnw8IflYnyeSaZpsDhRmHDt2DIuLi8jlcsyQUPbNl0oHwZ4tIp2UKhFzc3MAHloZv98PURQxNTWFVCqFYDCIYrGIUqnELB6v8pPloEkFg8GechsApvxnMhmsr68jmUxCluWexGhQ0EWQJAnBYBCaprEMmbJYZ8eNG/iLx6+JW/ZrmibK5TKreJA0Eo/Hsba2xuLjfkTkSU9JxNjYGM6dOwdJkrC0tMRII8syvF4vTNNEpVJhZVJKMHiLzR+fNg5pmwCYtSbv1263MTIygrGxMZbAOD3FTtz0nmNEqqAYhoG5uTmEw2F0u10kEgmcOHECS0tLAIDp6Wl0Oh0Eg0EYhsHMPE1QlmVmnRRFgW3bbHLBYJAtGC1QJBLBe++9h1OnTsHn8+HUqVM9jZ5OUriBXieroqoqE3rp4tAm4OvOzsyYwAvJfCMAf652u41arcYuUiQSgd/vx8jICNu4W1kRfnOQQH369GlMT0/j/fffx40bNyDLMqsAKYoCAMw901x4EtKDr8g4rSJdawodWq0WdF2HKIqIxWLMY+xUyCbs2SJSicfr9SIQCDB9SpIkjI2NYWlpCbIsw7ZtVKtVVhynz9GuI4tHF0IQBEYIkgqo3kkaY7PZxOrqKp588kkcPnwYsVgMxWJx13OhjUD1ZQo5KDAHehtDebLRheStAB8b0l+SrSRJgt/vRyQSYRKLLMt9N46THHR8RVFw6NAhGIaB5eVlNJtNJgvxa0kEdMvoycXz1s8tDia3TO8Roam+7hwnPR8EeyYiLbYkSayIT27jxIkT+PDDD1EqldDtduHz+VCpVNBoNGDbNotVePdOxyO5ht/9REpRFJk7L5VKsG0bIyMjfeu0/cC7UHI33W6X1Y0F4WHTAm0aZ+LgbJDldTreIvPfoXmT7EFkcnbtOMfIH4uPP2njUNmNDAORybIs5qJps/OtWnyrmzOuc5KKuqREUezJqokHOyUfj30TtAEglUqhWCwiGAzCsiwEAgEkEgnk83kmyRDRKHEh8IvDi65EQl70pknH43EkEgnWF7hTOF1OrVZjWp7f7wcA+P1+dnFpU/AXj48deSLyFpJPMGh+zv7F3cge1GYXDAYxMjKCUCiEfD7fkwDSBifrDoBZL56AlCjyWblb7EiNLCSS5/N5JuPwSdag1SHCnm8n5dmfzWZx7do1dDodVrwnlxkMBnsaQGli1D1Dpp6sJK8n8rIPNRLQd2VZRrvdRrVa3VF8QlaFNka1WkU6nUY6nUa9XmeZIZW1nA2vzjWguNGZjfLrQwSkBE1RFBb8k6bnvID9rAuNPxQKsda0EydOIBKJsHOJoghVVVnDA32Hb+jlwwlaa0mS2DrzTb/0GoUUmqZBkiTXRGWn2LcY0bIsVCoVvPnmm3jhhRcwMjKCTqeDRCLBXBvfOkWdLLSbyDLRIvOCM5GOLq6u66z2GY/HIUkSSqUSKpXKjsZOxLIsC4VCAaurq0gkEpicnEQikWBdKlSfpeSKxuSUOMhaO0V1/p4QiqX55KTZbLJyp9MdEvhzEKEAIBQKIRwOw+PxYH5+HqFQCDdv3mQaLcW7VJLkLRdZZACPrDcPGhNPYFoTajThhfbdYF8EbX4Qly5dwte+9jV84QtfYLFcIpFAKpViQjXJMrZts5iDOlFIB6O4hiclNWkGAgFIkoTPfvaz7DM3b95kEpBzbG7gL2a73WYuLRaLYXZ2FjMzMwiFQsx6qarKpA+eWPSXNgud003MFgQBPp+Pdb8EAgEAQL1eR6VSgWEYjyQO/Hn4cxGoGVcQBIRCISSTSfj9fiwsLMCyLNazSdoiXyTgrSRtIKci4CbFkNHh+xKdlabt1t+JPRORMk0qwxWLRbzxxhuYmZnB5OQkJEnC+Pg4NE2DYRgwDAOWZbFYEngoLdDOIrJSzEeLFggEIAgCI2goFMLhw4dZ9eDKlSs73o1ERAr0m80m7t+/j3v37iGRSAAAawag5IjPLGmDUGLg1BrpwlBI4vP5WG9fLBaDJEmo1WrIZrNIp9OoVqtsvlu5OJ7ovAVtNBpQFAXRaBSTk5PI5XJotVqsusKPk/5Ss6sz/iV4vV7m5om4VBUj78T3ZfJj3An2xSJSdkam+/Lly/jxj3+MH/3oRzh58iRisRg8Hg90XQeAnloqdTjz5TM+JrRtG36/n3UWk8WYm5tDNBqFz+fDlStX8M477+woPuE/SxaDWucXFhYgSRLK5TLLSMPhMLOOtVoNpmky8vLrwB+TrAuRkHoTE4kExsfHYRgG0uk0UqkU7t+/j3w+zxpH3ObCWxwiTrFYZO1blmWxvs5ms4l8Po96vc7Wk+I//lh8WMRXR2iN+klJRGRd19n5+Wyb/n4sgjaBkhPKcAHgrbfeQiqVwuuvv47Pf/7zOH36NP70pz/h7t27kGUZx44dY7tUkiQWZJP+RYvRaDSg6zpUVUU8HodpmpiensYzzzwDSZJQqVTw5z//GYVCwbUDZCvwi0TjrtVquH37NsrlMtLpNOuqpuZWcoW1Wg31er1vsZ+SLpKyvF4vgsEgIpEIxsbGEIvFWJL14MED3L9/H6VSqeemMqf0Q68RiTqdDjY2NvDgwQMkEgmW9KTTaaysrGB1dRWdToclRoqi9IQYZMGpi4g2jVMLJaJSTElJC1VsarUas6JOMg6KfXHNlIlRDEJx39LSEn7yk5/gtddew8svv4zXXnsNV69eRaFQgM/nw4MHD5ggWqvVIMsyuwi2bbNGzk6ng0ajgWw2i/n5eZw5c4YlO++++y4uXbqESqWCQCCwq344Pl5sNBpIpVKsQ6Ver7OLQFUKn8/HdjtVesjdEUn4BlOq2FDM2e12Ua/Xkc1msb6+jlQqhXQ6zcTordrZeMmp2+0im83i7bffZjFttVpFJpNBLpdjlQ/KegVBwOjoKILBIBPpybLTHEjq4evkdF46FiVAa2tryGazzE079U/ixyDYl6YHuu2TMioALP548OABfvOb3+Dvf/87fvCDH+D8+fMscF5eXsbNmzdRKpVYWYpua6QLSA2rlUoFc3NzrLun0+lgcXERr7/+OlZXVxEIBNBqtXbck0ighaM2+Gq1+nCB/r+tv9FoYGRkhMkXdC8In3lTrMTrjLxbpqQik8mg0Wjg9u3buH37NjKZDNMvnRKX25oTKci1/uMf/0AikcDLL78MWZZZLE4Wj8pyVBIkF03HcFZaeK/CZ8QAWLwuiiLS6TSLQ7dz59thz7Vmkm94d8pPwuv1olar4a233sLVq1fx6quv4utf/zrm5+fx5JNPYn5+Hvfu3UM+n2ftUeSeKLuemZnB7Owsjhw5gkAggHw+j4sXL+K3v/0tUqkU07IG7bzZCkR8usipVAr1eh2bm5sIh8OIRCKYmZnB1NQUNE1jWhpVS/i40ev1Mg1SEB7eKpHJZHD37l2srKzggw8+wPr6Omq12iPu2E2+cbo9+k61WsUf//hHdLtdnDt3Du12m92ySuQnD1KtVnvcLV9L55MWWgveSlJ5VpZlNn5d13s6gfqNeTvs2z0r/XQv/vV6vY7f/e53uHz5Mr7zne/gy1/+MqLRKE6dOoVut4tqtYpUKsWsCt0DnUgkmI51/fp1vPHGG/jLX/4CwzB67jbbbcGdHycREXgYHhQKBRSLRWSzWYyOjmJ8fByCILB7mmkT8rVWsiB00chV67qOtbU1LCws4NatW1hZWWEVDedttDycQT+vX9L5qtUqLl68iHw+j3g8zm6oJ1dKfYrkgp2dTmQl+WMTCfn3qM5//fp1rK+vs2vF90juxiIK3QG/tR+/j8iLpoqi4OTJk/jmN7+Js2fPIplM9tzbTJ+lCeZyOVy8eBG///3vce3aNSaOk47l8/l6stb9GCsJ7pZl9UgvR44cwezsLKampphux1eA+M5v4D9t9oVCAXfu3MGHH36I5eVlZDIZthb96tM0Fj7mcloa2gzkRSYmJpBMJqFpGsbGxjA7OwtVVZHP55FOp9mtCABYZcvNPZMKQi1lFOMuLi7i8uXLSKfTj4jwvDFot9us/3E7fOxEpN1P8YlhGEgkEnjqqafYPcTxeJxZo1QqhStXruDWrVsoFArodrtQVbWnQYGv++608WGrsfJ6G++a6McBqKpBmbSqqj0iPBGZJA669YCqQIZhMEu/VVzYb3z011miCwQCiEQimJ2dxdNPP43z588jEomgUqngxo0bPXEdzZPkGyIWZfl09x9Vlu7evYv33nsPa2trPbd08NeXj7cPLBEBsEyTJkwDpYyRFpXEWKDXdVB8QyUz0sL26p77jZfgXHRKRPjGA/7nOaiRol6v92Sn/cp4uxkT/zqtD5X2NE3D0aNHcf78eVb+W19fx507d5hUxOuJfK+ioiisjq2qKsrlMm7evInFxUV2Jya/8Z3xK12/QYn4ifwsHe9++U4R/iYsAkk6vNvlXTZVYihh2W3W7AYn8chyUGJC46CsmBpR+bsQdV2HYRg9NV5KYnaaXPUTl/l/89a4Uqng7t27aLfbWF1dxRNPPIFoNApN09BqtVCr1XrIRwkL9QPQL0Touo6FhQXcuHEDxWKR/RiAW9y6W3ysRHQTaHmQu3a6V+c9HM72JFr4/XLL/UCuj8pefAMCySR89knxIsVYvPSyG2tIYyA4dTs+BidXW6/XkU6n2XvT09PMclN4QGSkTaKqKvx+P8rlMhYWFrC2tsbud6EixE51wu1woH6oc7cXZ7++v92xaZPwWTIPt/ucgf80lO7HGNzGxD/nhXXSDW3bZo0Vm5ubrETp/L1GsuSNRgPpdBqrq6tIp9NoNBostOgX+riJ2Tu5HgeKiAcdW9V/nQ8+gXBWKPYCN5fIv0dEIctMMR7Fz5VKhVWN+OoQWW9d15HP55HL5VCtVnt+0YE8AD/vvbpkwpCI+wCeZG4Jzl5J6JRF+ITA+TmyatT0IMsyzpw5g0OHDqFSqWB1dRXlcpndN0NtaZIkoVgsYn19HaVSicWBfHtXvw2wVeY86JyHRNwj+gn52732UYCPQYmMa2truHXrFiYnJ6FpGpaXl1EqldhtudSwYpom+8liXtrZqonBSU63zwyJ+DHjoySbUzN0O5/zOZGRavq1Wg1Hjx4FAHY/Dn2PGiXo51CchQG+99F5LicZd4shEf9L4EbAfsSg18ilN5tN1uFDv/+oaRoURUGj0cCDBw9QKpXY593CAP48zvNuFSMOLeL/MAa98OSmycVSmx79HuPIyAgajQbK5XLPbb1u7niQEGTQMbphSMT/Arh13mwFPpt1fpesXrlcZjeb8e87v0vn54+zE1c8tIj/Y3ATr93eo+fO9/lEhrJhN3ff70b57eJDt/HR+QbBkIj/BdgqG3WSzk1W4T/Lt/Tz5OI1wn5WrJ9muFXmPCTi/xBIShkkOeBFdedzErydWbDz827xYD9x3kle/ruUtQ+Cgbtvhhjio8Twf7Af4kBgSMQhDgSGRBziQGBIxCEOBIZEHOJAYEjEIQ4EhkQc4kBgSMQhDgSGRBziQOD/ACF9j6TBlDGkAAAAAElFTkSuQmCC", "text/plain": [ "
" ] @@ -1226,7 +1226,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "4a42ac2f90cb461fb9f0c82d544fb8d2", + "model_id": "4b79fa6a38cd49f7bb65fc6ad327af73", "version_major": 2, "version_minor": 0 }, @@ -1240,7 +1240,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "c8e20b5bfbc64b28a910c9d11ef6851c", + "model_id": "05dfeb5eed1b44bfa4d3986dd0f97e1f", "version_major": 2, "version_minor": 0 }, @@ -1253,7 +1253,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1278,7 +1278,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "c6d737f986a64c22895476a68c2b3e87", + "model_id": "02c9a151f246464da9eebd015e6beb9d", "version_major": 2, "version_minor": 0 }, @@ -1292,7 +1292,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "b1743b884fbf4ae4bebf051ea1f5bf23", + "model_id": "233d0384d2c54aeca65d790b19565232", "version_major": 2, "version_minor": 0 }, @@ -1305,7 +1305,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1330,7 +1330,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "7e79ff41ccf54a45885ea18dd5bfe401", + "model_id": "cbaf0368cb304e6bbfa8ceac20f5a247", "version_major": 2, "version_minor": 0 }, @@ -1344,7 +1344,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "3dd47e394441481da5c2e8b8af54a451", + "model_id": "5bbc10ac52ca4835a55e13b73e1fb263", "version_major": 2, "version_minor": 0 }, @@ -1357,7 +1357,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1382,7 +1382,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "c23581c04d474a69a45d37fce99ec3f4", + "model_id": "2a95535f104048b2ac1756ff1db454f8", "version_major": 2, "version_minor": 0 }, @@ -1396,7 +1396,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "96313db64cb54ee991281b16c1276823", + "model_id": "319034a2b62d49cbb3e4ca25a30bc76a", "version_major": 2, "version_minor": 0 }, @@ -1409,7 +1409,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1434,7 +1434,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "009e46d5a9094efb96c33cbed7b09d93", + "model_id": "8959e5f59fb14792abea3737d90363ee", "version_major": 2, "version_minor": 0 }, @@ -1448,7 +1448,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "d28bcf839d3f438bb525f98f15c31092", + "model_id": "e4c2571d928941b4850869d0d0a86ea9", "version_major": 2, "version_minor": 0 }, @@ -1461,7 +1461,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1486,7 +1486,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "712d910c6b8a4d529c7b936c29f8c70a", + "model_id": "40b8269d8e05404da709e1f212edc47c", "version_major": 2, "version_minor": 0 }, @@ -1500,7 +1500,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "eb338a4be9044e6b899b95847c926ba8", + "model_id": "371f42e9994942a489b04ef0d2b2e022", "version_major": 2, "version_minor": 0 }, @@ -1513,7 +1513,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1525,7 +1525,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "2023-04-12 15:10:07,913 - `Trainer.fit` stopped: `max_epochs=200` reached.\n" + "2023-05-12 18:22:06,851 - `Trainer.fit` stopped: `max_epochs=200` reached.\n" ] } ], @@ -1571,7 +1571,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "2d9060b0533142ceac3699efbb441dc5", + "model_id": "631635b665454a2884dc88d7d466c50b", "version_major": 2, "version_minor": 0 }, @@ -1631,7 +1631,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] diff --git a/tutorials/generative/2d_super_resolution/2d_stable_diffusion_v2_super_resolution-lightning.py b/tutorials/generative/2d_super_resolution/2d_stable_diffusion_v2_super_resolution-lightning.py index 084404bc..2a430db5 100644 --- a/tutorials/generative/2d_super_resolution/2d_stable_diffusion_v2_super_resolution-lightning.py +++ b/tutorials/generative/2d_super_resolution/2d_stable_diffusion_v2_super_resolution-lightning.py @@ -46,6 +46,7 @@ # %% # !python -c "import monai" || pip install -q "monai-weekly[tqdm]" +# !python -c "import pytorch_lightning" || pip install pytorch-lightning # !python -c "import matplotlib" || pip install -q matplotlib # %matplotlib inline @@ -94,55 +95,53 @@ print(root_dir) # %% -train_data = MedNISTDataset(root_dir=root_dir, section="training", - download=True, seed=0) +train_data = MedNISTDataset(root_dir=root_dir, section="training", download=True, seed=0) train_datalist = [{"image": item["image"]} for item in train_data.data if item["class_name"] == "HeadCT"] -val_data = MedNISTDataset(root_dir=root_dir, section="validation", - download=True, seed=0) +val_data = MedNISTDataset(root_dir=root_dir, section="validation", download=True, seed=0) val_datalist = [{"image": item["image"]} for item in val_data.data if item["class_name"] == "HeadCT"] # %% [markdown] # ## Setup utils functions + # %% def get_train_transforms(): image_size = 64 train_transforms = transforms.Compose( - [ - transforms.LoadImaged(keys=["image"]), - transforms.EnsureChannelFirstd(keys=["image"]), - transforms.ScaleIntensityRanged(keys=["image"], a_min=0.0, a_max=255.0, b_min=0.0, - b_max=1.0, clip=True), - transforms.RandAffined( - keys=["image"], - rotate_range=[(-np.pi / 36, np.pi / 36), (-np.pi / 36, np.pi / 36)], - translate_range=[(-1, 1), (-1, 1)], - scale_range=[(-0.05, 0.05), (-0.05, 0.05)], - spatial_size=[image_size, image_size], - padding_mode="zeros", - prob=0.5, - ), - transforms.CopyItemsd(keys=["image"], times=1, names=["low_res_image"]), - transforms.Resized(keys=["low_res_image"], spatial_size=(16, 16)), - ] + [ + transforms.LoadImaged(keys=["image"]), + transforms.EnsureChannelFirstd(keys=["image"]), + transforms.ScaleIntensityRanged(keys=["image"], a_min=0.0, a_max=255.0, b_min=0.0, b_max=1.0, clip=True), + transforms.RandAffined( + keys=["image"], + rotate_range=[(-np.pi / 36, np.pi / 36), (-np.pi / 36, np.pi / 36)], + translate_range=[(-1, 1), (-1, 1)], + scale_range=[(-0.05, 0.05), (-0.05, 0.05)], + spatial_size=[image_size, image_size], + padding_mode="zeros", + prob=0.5, + ), + transforms.CopyItemsd(keys=["image"], times=1, names=["low_res_image"]), + transforms.Resized(keys=["low_res_image"], spatial_size=(16, 16)), + ] ) return train_transforms + def get_val_transforms(): val_transforms = transforms.Compose( [ transforms.LoadImaged(keys=["image"]), transforms.EnsureChannelFirstd(keys=["image"]), - transforms.ScaleIntensityRanged(keys=["image"], a_min=0.0, a_max=255.0, b_min=0.0, - b_max=1.0, clip=True), + transforms.ScaleIntensityRanged(keys=["image"], a_min=0.0, a_max=255.0, b_min=0.0, b_max=1.0, clip=True), transforms.CopyItemsd(keys=["image"], times=1, names=["low_res_image"]), transforms.Resized(keys=["low_res_image"], spatial_size=(16, 16)), ] ) return val_transforms - + def get_datasets(): train_transforms = get_train_transforms() val_transforms = get_val_transforms() @@ -151,27 +150,28 @@ def get_datasets(): return train_ds, val_ds - # %% [markdown] # ## Define the LightningModule for AutoEncoder (transforms, network, loaders, etc) -# The LightningModule contains a refactoring of your training code. The following module is a reformatiing of the code in 2d_stable_diffusion_v2_super_resolution. +# The LightningModule contains a refactoring of your training code. The following module is a reformating of the code in 2d_stable_diffusion_v2_super_resolution. # + # %% class AutoEnconder(pl.LightningModule): def __init__(self): super().__init__() self.data_dir = root_dir - self.autoencoderkl = AutoencoderKL(spatial_dims=2, - in_channels=1, - out_channels=1, - num_channels=(256, 512, 512), - latent_channels=3, - num_res_blocks=2, - norm_num_groups=32, - attention_levels=(False, False, True)) - self.discriminator = PatchDiscriminator(spatial_dims=2, in_channels=1, - num_layers_d=3, num_channels=64) + self.autoencoderkl = AutoencoderKL( + spatial_dims=2, + in_channels=1, + out_channels=1, + num_channels=(256, 512, 512), + latent_channels=3, + num_res_blocks=2, + norm_num_groups=32, + attention_levels=(False, False, True), + ) + self.discriminator = PatchDiscriminator(spatial_dims=2, in_channels=1, num_layers_d=3, num_channels=64) self.perceptual_loss = PerceptualLoss(spatial_dims=2, network_type="alex") self.perceptual_weight = 0.002 self.autoencoder_warm_up_n_epochs = 10 @@ -179,29 +179,27 @@ def __init__(self): self.adv_loss = PatchAdversarialLoss(criterion="least_squares") self.adv_weight = 0.005 self.kl_weight = 1e-6 - + def forward(self, z): return self.autoencoderkl(z) def prepare_data(self): self.train_ds, self.val_ds = get_datasets() - + def train_dataloader(self): - return ThreadDataLoader(self.train_ds, batch_size=16, shuffle=True, - num_workers=4, persistent_workers=True) - + return ThreadDataLoader(self.train_ds, batch_size=16, shuffle=True, num_workers=4, persistent_workers=True) + def val_dataloader(self): - return ThreadDataLoader(self.val_ds, batch_size=16, shuffle=False, - num_workers=4) - + return ThreadDataLoader(self.val_ds, batch_size=16, shuffle=False, num_workers=4) + def _compute_loss_generator(self, images, reconstruction, z_mu, z_sigma): recons_loss = F.l1_loss(reconstruction.float(), images.float()) p_loss = self.perceptual_loss(reconstruction.float(), images.float()) kl_loss = 0.5 * torch.sum(z_mu.pow(2) + z_sigma.pow(2) - torch.log(z_sigma.pow(2)) - 1, dim=[1, 2, 3]) kl_loss = torch.sum(kl_loss) / kl_loss.shape[0] loss_g = recons_loss + (self.kl_weight * kl_loss) + (self.perceptual_weight * p_loss) - return loss_g,recons_loss - + return loss_g, recons_loss + def _compute_loss_discriminator(self, images, reconstruction): logits_fake = self.discriminator(reconstruction.contiguous().detach())[-1] loss_d_fake = self.adv_loss(logits_fake, target_is_real=False, for_discriminator=True) @@ -210,7 +208,7 @@ def _compute_loss_discriminator(self, images, reconstruction): discriminator_loss = (loss_d_fake + loss_d_real) * 0.5 loss_d = self.adv_weight * discriminator_loss return loss_d, discriminator_loss - + def training_step(self, batch, batch_idx): optimizer_g, optimizer_d = self.optimizers() images = batch["image"] @@ -223,8 +221,6 @@ def training_step(self, batch, batch_idx): generator_loss = self.adv_loss(logits_fake, target_is_real=True, for_discriminator=False) loss_g += self.adv_weight * generator_loss self.log("gen_loss", generator_loss, batch_size=16, prog_bar=True) - - self.log("loss_g", loss_g, batch_size=16, prog_bar=True) self.manual_backward(loss_g) @@ -241,8 +237,6 @@ def training_step(self, batch, batch_idx): optimizer_d.zero_grad() self.untoggle_optimizer(optimizer_d) - - def validation_step(self, batch, batch_idx): images = batch["image"] reconstruction, z_mu, z_sigma = self.autoencoderkl(images) @@ -251,33 +245,30 @@ def validation_step(self, batch, batch_idx): self.images = images self.reconstruction = reconstruction - def on_validation_epoch_end(self): # ploting reconstruction plt.figure(figsize=(2, 2)) - plt.imshow(torch.cat([self.images[0, 0].cpu(), - self.reconstruction[0, 0].cpu()], - dim=1), vmin=0, vmax=1, cmap="gray") + plt.imshow( + torch.cat([self.images[0, 0].cpu(), self.reconstruction[0, 0].cpu()], dim=1), vmin=0, vmax=1, cmap="gray" + ) plt.tight_layout() plt.axis("off") plt.show() - def configure_optimizers(self): optimizer_g = torch.optim.Adam(self.autoencoderkl.parameters(), lr=5e-5) optimizer_d = torch.optim.Adam(self.discriminator.parameters(), lr=1e-4) return [optimizer_g, optimizer_d], [] - # %% [markdown] # ## Train Autoencoder # %% -n_epochs = 75 +n_epochs = 75 val_interval = 10 - + # initialise the LightningModule ae_net = AutoEnconder() @@ -285,14 +276,16 @@ def configure_optimizers(self): checkpoint_callback = ModelCheckpoint(dirpath=root_dir, filename="best_metric_model") - + # initialise Lightning's trainer. -trainer = pl.Trainer(devices=1, - max_epochs=n_epochs, - check_val_every_n_epoch=val_interval, - num_sanity_val_steps=0, - callbacks=checkpoint_callback, - default_root_dir=root_dir) +trainer = pl.Trainer( + devices=1, + max_epochs=n_epochs, + check_val_every_n_epoch=val_interval, + num_sanity_val_steps=0, + callbacks=checkpoint_callback, + default_root_dir=root_dir, +) # train trainer.fit(ae_net) @@ -303,6 +296,7 @@ def configure_optimizers(self): # # As mentioned in Rombach et al. [1] Section 4.3.2 and D.1, the signal-to-noise ratio (induced by the scale of the latent space) became crucial in image-to-image translation models (such as the ones used for super-resolution). For this reason, we will compute the component-wise standard deviation to be used as scaling factor. + # %% def get_scaler_factor(): ae_net.eval() @@ -316,12 +310,14 @@ def get_scaler_factor(): scale_factor = 1 / torch.std(z) return scale_factor + scale_factor = get_scaler_factor() # %% [markdown] # ## Define the LightningModule for DiffusionModelUnet (transforms, network, loaders, etc) -# The LightningModule contains a refactoring of your training code. The following module is a reformatiing of the code in 2d_stable_diffusion_v2_super_resolution. +# The LightningModule contains a refactoring of your training code. The following module is a reformating of the code in 2d_stable_diffusion_v2_super_resolution. + # %% class DiffusionUNET(pl.LightningModule): @@ -329,69 +325,59 @@ def __init__(self): super().__init__() self.data_dir = root_dir self.unet = DiffusionModelUNet( - spatial_dims=2, - in_channels=4, - out_channels=3, - num_res_blocks=2, - num_channels=(256, 256, 512, 1024), - attention_levels=(False, False, True, True), - num_head_channels=(0, 0, 64, 64), - ) + spatial_dims=2, + in_channels=4, + out_channels=3, + num_res_blocks=2, + num_channels=(256, 256, 512, 1024), + attention_levels=(False, False, True, True), + num_head_channels=(0, 0, 64, 64), + ) self.max_noise_level = 350 - self.scheduler = DDPMScheduler(num_train_timesteps=1000, - beta_schedule="linear", - beta_start=0.0015, - beta_end=0.0195) + self.scheduler = DDPMScheduler( + num_train_timesteps=1000, beta_schedule="linear", beta_start=0.0015, beta_end=0.0195 + ) self.z = ae_net.autoencoderkl.eval() - def forward(self, x, timesteps, low_res_timesteps): - return self.unet(x=x, - timesteps=timesteps, - class_labels=low_res_timesteps) - - + return self.unet(x=x, timesteps=timesteps, class_labels=low_res_timesteps) + def prepare_data(self): self.train_ds, self.val_ds = get_datasets() - + def train_dataloader(self): - return DataLoader(self.train_ds, batch_size=16, shuffle=True, - num_workers=4, persistent_workers=True) - + return ThreadDataLoader(self.train_ds, batch_size=16, shuffle=True, num_workers=4, persistent_workers=True) + def val_dataloader(self): - return DataLoader(self.val_ds, batch_size=16, shuffle=False, - num_workers=4) - + return ThreadDataLoader(self.val_ds, batch_size=16, shuffle=False, num_workers=4) + def _calculate_loss(self, batch, batch_idx, plt_image=False): images = batch["image"] - low_res_image = batch["low_res_image"] + low_res_image = batch["low_res_image"] with autocast(enabled=True): with torch.no_grad(): latent = self.z.encode_stage_2_inputs(images) * scale_factor -# latent = latent.detach() # avoid adding this to graph. - # Noise augmentation noise = torch.randn_like(latent) low_res_noise = torch.randn_like(low_res_image) - timesteps = torch.randint(0, self.scheduler.num_train_timesteps, (latent.shape[0],), - device=latent.device).long() + timesteps = torch.randint( + 0, self.scheduler.num_train_timesteps, (latent.shape[0],), device=latent.device + ).long() low_res_timesteps = torch.randint( 0, self.max_noise_level, (low_res_image.shape[0],), device=latent.device ).long() - noisy_latent = self.scheduler.add_noise(original_samples=latent, - noise=noise, timesteps=timesteps) + noisy_latent = self.scheduler.add_noise(original_samples=latent, noise=noise, timesteps=timesteps) noisy_low_res_image = self.scheduler.add_noise( - original_samples=low_res_image, noise=low_res_noise, - timesteps=low_res_timesteps + original_samples=low_res_image, noise=low_res_noise, timesteps=low_res_timesteps ) latent_model_input = torch.cat([noisy_latent, noisy_low_res_image], dim=1) noise_pred = self.forward(latent_model_input, timesteps, low_res_timesteps) loss = F.mse_loss(noise_pred.float(), noise.float()) - + if plt_image: # Sampling image during training sampling_image = low_res_image[0].unsqueeze(0) @@ -399,32 +385,30 @@ def _calculate_loss(self, batch, batch_idx, plt_image=False): low_res_noise = torch.randn((1, 1, 16, 16)).to(sampling_image.device) noise_level = 20 noise_level = torch.Tensor((noise_level,)).long().to(sampling_image.device) - + noisy_low_res_image = self.scheduler.add_noise( - original_samples=sampling_image, - noise=low_res_noise, - timesteps=noise_level, + original_samples=sampling_image, noise=low_res_noise, timesteps=noise_level ) self.scheduler.set_timesteps(num_inference_steps=1000) for t in tqdm(self.scheduler.timesteps, ncols=110): with autocast(enabled=True): with torch.no_grad(): latent_model_input = torch.cat([latents, noisy_low_res_image], dim=1) - noise_pred = self.forward(latent_model_input, - torch.Tensor((t,)).to(sampling_image.device) - , noise_level) + noise_pred = self.forward( + latent_model_input, torch.Tensor((t,)).to(sampling_image.device), noise_level + ) latents, _ = self.scheduler.step(noise_pred, t, latents) with torch.no_grad(): decoded = self.z.decode_stage_2_outputs(latents / scale_factor) low_res_bicubic = nn.functional.interpolate(sampling_image, (64, 64), mode="bicubic") # plot images - + self.images = images self.low_res_bicubic = low_res_bicubic self.decoded = decoded - + return loss - + def _plot_image(self, images, low_res_bicubic, decoded): plt.figure(figsize=(2, 2)) plt.style.use("default") @@ -442,12 +426,12 @@ def training_step(self, batch, batch_idx): loss = self._calculate_loss(batch, batch_idx) self.log("train_loss", loss, batch_size=16, prog_bar=True) return loss - + def validation_step(self, batch, batch_idx): loss = self._calculate_loss(batch, batch_idx, plt_image=True) self.log("val_loss", loss, batch_size=16, prog_bar=True) return loss - + def on_validation_epoch_end(self): self._plot_image(self.images, self.low_res_bicubic, self.decoded) @@ -467,7 +451,7 @@ def configure_optimizers(self): n_epochs = 200 val_interval = 20 - + # initialise the LightningModule d_net = DiffusionUNET() @@ -475,14 +459,16 @@ def configure_optimizers(self): checkpoint_callback = ModelCheckpoint(dirpath=root_dir, filename="best_metric_model_dunet") - + # initialise Lightning's trainer. -trainer = pl.Trainer(devices=1, - max_epochs=n_epochs, - check_val_every_n_epoch=val_interval, - num_sanity_val_steps=0, - callbacks=checkpoint_callback, - default_root_dir=root_dir) +trainer = pl.Trainer( + devices=1, + max_epochs=n_epochs, + check_val_every_n_epoch=val_interval, + num_sanity_val_steps=0, + callbacks=checkpoint_callback, + default_root_dir=root_dir, +) # train trainer.fit(d_net) @@ -492,12 +478,13 @@ def configure_optimizers(self): # %% num_samples = 3 + + def get_images_to_plot(): d_net.eval() device = torch.device("cuda:0") d_net.to(device) - val_loader = d_net.val_dataloader() check_data = first(val_loader) images = check_data["image"].to(d_net.device) @@ -508,18 +495,18 @@ def get_images_to_plot(): noise_level = 10 noise_level = torch.Tensor((noise_level,)).long().to(d_net.device) scheduler = d_net.scheduler - noisy_low_res_image = scheduler.add_noise(original_samples=sampling_image, - noise=low_res_noise, - timesteps=torch.Tensor((noise_level,)).long()) + noisy_low_res_image = scheduler.add_noise( + original_samples=sampling_image, noise=low_res_noise, timesteps=torch.Tensor((noise_level,)).long() + ) scheduler.set_timesteps(num_inference_steps=1000) for t in tqdm(scheduler.timesteps, ncols=110): with autocast(enabled=True): with torch.no_grad(): latent_model_input = torch.cat([latents, noisy_low_res_image], dim=1) - noise_pred = d_net.forward(x=latent_model_input, - timesteps=torch.Tensor((t,)).to(d_net.device), - low_res_timesteps=noise_level) + noise_pred = d_net.forward( + x=latent_model_input, timesteps=torch.Tensor((t,)).to(d_net.device), low_res_timesteps=noise_level + ) # 2. compute previous image: x_t -> x_t-1 latents, _ = scheduler.step(noise_pred, t, latents) @@ -527,6 +514,7 @@ def get_images_to_plot(): decoded = ae_net.autoencoderkl.decode_stage_2_outputs(latents / scale_factor) return sampling_image, images, decoded + sampling_image, images, decoded = get_images_to_plot() # %% From 5876ccd2bf918a64b72cc8fa3a3904ca063ec5d4 Mon Sep 17 00:00:00 2001 From: Oeslle Lucena Date: Mon, 15 May 2023 11:48:04 +0100 Subject: [PATCH 06/13] Update tutorials/generative/2d_super_resolution/2d_stable_diffusion_v2_super_resolution-lightning.ipynb Co-authored-by: Eric Kerfoot <17726042+ericspod@users.noreply.github.com> Signed-off-by: Oeslle Lucena --- .../2d_stable_diffusion_v2_super_resolution-lightning.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tutorials/generative/2d_super_resolution/2d_stable_diffusion_v2_super_resolution-lightning.ipynb b/tutorials/generative/2d_super_resolution/2d_stable_diffusion_v2_super_resolution-lightning.ipynb index 029889d1..32b1d389 100644 --- a/tutorials/generative/2d_super_resolution/2d_stable_diffusion_v2_super_resolution-lightning.ipynb +++ b/tutorials/generative/2d_super_resolution/2d_stable_diffusion_v2_super_resolution-lightning.ipynb @@ -333,7 +333,7 @@ }, "outputs": [], "source": [ - "class AutoEnconder(pl.LightningModule):\n", + "class AutoEncoder(pl.LightningModule):\n", " def __init__(self):\n", " super().__init__()\n", " self.data_dir = root_dir\n", From 156c9141fa2e5c8e0bfa72d3376c47597a38a24c Mon Sep 17 00:00:00 2001 From: Oeslle Lucena Date: Mon, 15 May 2023 11:49:14 +0100 Subject: [PATCH 07/13] Update tutorials/generative/2d_super_resolution/2d_stable_diffusion_v2_super_resolution-lightning.py Co-authored-by: Eric Kerfoot <17726042+ericspod@users.noreply.github.com> Signed-off-by: Oeslle Lucena --- .../2d_stable_diffusion_v2_super_resolution-lightning.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tutorials/generative/2d_super_resolution/2d_stable_diffusion_v2_super_resolution-lightning.py b/tutorials/generative/2d_super_resolution/2d_stable_diffusion_v2_super_resolution-lightning.py index 2a430db5..5af91135 100644 --- a/tutorials/generative/2d_super_resolution/2d_stable_diffusion_v2_super_resolution-lightning.py +++ b/tutorials/generative/2d_super_resolution/2d_stable_diffusion_v2_super_resolution-lightning.py @@ -270,7 +270,7 @@ def configure_optimizers(self): # initialise the LightningModule -ae_net = AutoEnconder() +ae_net = AutoEncoder() # set up checkpoints From 1e5e5323f86868d2d909a91a8456023582113c63 Mon Sep 17 00:00:00 2001 From: Oeslle Lucena Date: Mon, 15 May 2023 11:49:28 +0100 Subject: [PATCH 08/13] Update tutorials/generative/2d_super_resolution/2d_stable_diffusion_v2_super_resolution-lightning.py Co-authored-by: Eric Kerfoot <17726042+ericspod@users.noreply.github.com> Signed-off-by: Oeslle Lucena --- .../2d_stable_diffusion_v2_super_resolution-lightning.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tutorials/generative/2d_super_resolution/2d_stable_diffusion_v2_super_resolution-lightning.py b/tutorials/generative/2d_super_resolution/2d_stable_diffusion_v2_super_resolution-lightning.py index 5af91135..ef18bc83 100644 --- a/tutorials/generative/2d_super_resolution/2d_stable_diffusion_v2_super_resolution-lightning.py +++ b/tutorials/generative/2d_super_resolution/2d_stable_diffusion_v2_super_resolution-lightning.py @@ -157,7 +157,7 @@ def get_datasets(): # %% -class AutoEnconder(pl.LightningModule): +class AutoEncoder(pl.LightningModule): def __init__(self): super().__init__() self.data_dir = root_dir From 41ce2e985b09e48e776b6f828430e7495a7f0c14 Mon Sep 17 00:00:00 2001 From: Oeslle Lucena Date: Mon, 15 May 2023 13:15:07 +0100 Subject: [PATCH 09/13] Update tutorials/generative/2d_super_resolution/2d_stable_diffusion_v2_super_resolution-lightning.py Co-authored-by: Eric Kerfoot <17726042+ericspod@users.noreply.github.com> Signed-off-by: Oeslle Lucena --- .../2d_stable_diffusion_v2_super_resolution-lightning.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tutorials/generative/2d_super_resolution/2d_stable_diffusion_v2_super_resolution-lightning.py b/tutorials/generative/2d_super_resolution/2d_stable_diffusion_v2_super_resolution-lightning.py index ef18bc83..19c0984a 100644 --- a/tutorials/generative/2d_super_resolution/2d_stable_diffusion_v2_super_resolution-lightning.py +++ b/tutorials/generative/2d_super_resolution/2d_stable_diffusion_v2_super_resolution-lightning.py @@ -298,7 +298,7 @@ def configure_optimizers(self): # %% -def get_scaler_factor(): +def get_scale_factor(): ae_net.eval() device = torch.device("cuda:0") ae_net.to(device) From 2c95ddeb2fe5adf9f165d90a91c0cee3dd30208a Mon Sep 17 00:00:00 2001 From: Oeslle Lucena Date: Mon, 15 May 2023 13:15:26 +0100 Subject: [PATCH 10/13] Update tutorials/generative/2d_super_resolution/2d_stable_diffusion_v2_super_resolution-lightning.ipynb Co-authored-by: Eric Kerfoot <17726042+ericspod@users.noreply.github.com> Signed-off-by: Oeslle Lucena --- .../2d_stable_diffusion_v2_super_resolution-lightning.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tutorials/generative/2d_super_resolution/2d_stable_diffusion_v2_super_resolution-lightning.ipynb b/tutorials/generative/2d_super_resolution/2d_stable_diffusion_v2_super_resolution-lightning.ipynb index 32b1d389..e76ef085 100644 --- a/tutorials/generative/2d_super_resolution/2d_stable_diffusion_v2_super_resolution-lightning.ipynb +++ b/tutorials/generative/2d_super_resolution/2d_stable_diffusion_v2_super_resolution-lightning.ipynb @@ -724,7 +724,7 @@ "\n", " \n", "# initialise the LightningModule\n", - "ae_net = AutoEnconder()\n", + "ae_net = AutoEncoder()\n", "\n", "# set up checkpoints\n", "\n", From 1ccba15644eb44b75275d2b7d70278e701a56681 Mon Sep 17 00:00:00 2001 From: Oeslle Lucena Date: Mon, 15 May 2023 13:16:00 +0100 Subject: [PATCH 11/13] Update tutorials/generative/2d_super_resolution/2d_stable_diffusion_v2_super_resolution-lightning.ipynb Co-authored-by: Eric Kerfoot <17726042+ericspod@users.noreply.github.com> Signed-off-by: Oeslle Lucena --- .../2d_stable_diffusion_v2_super_resolution-lightning.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tutorials/generative/2d_super_resolution/2d_stable_diffusion_v2_super_resolution-lightning.ipynb b/tutorials/generative/2d_super_resolution/2d_stable_diffusion_v2_super_resolution-lightning.ipynb index e76ef085..e3f57762 100644 --- a/tutorials/generative/2d_super_resolution/2d_stable_diffusion_v2_super_resolution-lightning.ipynb +++ b/tutorials/generative/2d_super_resolution/2d_stable_diffusion_v2_super_resolution-lightning.ipynb @@ -768,7 +768,7 @@ } ], "source": [ - "def get_scaler_factor():\n", + "def get_scale_factor():\n", " ae_net.eval()\n", " device = torch.device(\"cuda:0\")\n", " ae_net.to(device)\n", From ee5c8ee25e8076a4cac830dc20287e2f878ff9a4 Mon Sep 17 00:00:00 2001 From: Oeslle Lucena Date: Mon, 15 May 2023 13:16:10 +0100 Subject: [PATCH 12/13] Update tutorials/generative/2d_super_resolution/2d_stable_diffusion_v2_super_resolution-lightning.ipynb Co-authored-by: Eric Kerfoot <17726042+ericspod@users.noreply.github.com> Signed-off-by: Oeslle Lucena --- .../2d_stable_diffusion_v2_super_resolution-lightning.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tutorials/generative/2d_super_resolution/2d_stable_diffusion_v2_super_resolution-lightning.ipynb b/tutorials/generative/2d_super_resolution/2d_stable_diffusion_v2_super_resolution-lightning.ipynb index e3f57762..dfc9d932 100644 --- a/tutorials/generative/2d_super_resolution/2d_stable_diffusion_v2_super_resolution-lightning.ipynb +++ b/tutorials/generative/2d_super_resolution/2d_stable_diffusion_v2_super_resolution-lightning.ipynb @@ -780,7 +780,7 @@ " scale_factor = 1 / torch.std(z)\n", " return scale_factor\n", "\n", - "scale_factor = get_scaler_factor()" + "scale_factor = get_scale_factor()" ] }, { From 5e8272050b4d02067b2250a3d66cca25320aaef1 Mon Sep 17 00:00:00 2001 From: Oeslle Lucena Date: Mon, 15 May 2023 13:16:18 +0100 Subject: [PATCH 13/13] Update tutorials/generative/2d_super_resolution/2d_stable_diffusion_v2_super_resolution-lightning.py Co-authored-by: Eric Kerfoot <17726042+ericspod@users.noreply.github.com> Signed-off-by: Oeslle Lucena --- .../2d_stable_diffusion_v2_super_resolution-lightning.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tutorials/generative/2d_super_resolution/2d_stable_diffusion_v2_super_resolution-lightning.py b/tutorials/generative/2d_super_resolution/2d_stable_diffusion_v2_super_resolution-lightning.py index 19c0984a..34c8c8f0 100644 --- a/tutorials/generative/2d_super_resolution/2d_stable_diffusion_v2_super_resolution-lightning.py +++ b/tutorials/generative/2d_super_resolution/2d_stable_diffusion_v2_super_resolution-lightning.py @@ -311,7 +311,7 @@ def get_scale_factor(): return scale_factor -scale_factor = get_scaler_factor() +scale_factor = get_scale_factor() # %% [markdown]