From 9e994f466a0cb7e2ea21e2aca4cac6fb4b3c37dd Mon Sep 17 00:00:00 2001 From: Eric Kerfoot Date: Thu, 5 Sep 2024 15:01:18 +0100 Subject: [PATCH] Removing 3D tutorial, this one still needs work Signed-off-by: Eric Kerfoot --- .../2d_ddpm/2d_ddpm_compare_schedulers.ipynb | 30 +- generation/2d_ddpm/2d_ddpm_inpainting.ipynb | 30 +- generation/2d_ddpm/2d_ddpm_tutorial.ipynb | 30 +- .../2d_ddpm/2d_ddpm_tutorial_ignite.ipynb | 30 +- .../2d_ddpm_tutorial_v_prediction.ipynb | 30 +- generation/3d_ddpm/3d_ddpm_tutorial.ipynb | 1049 ----------------- 6 files changed, 55 insertions(+), 1144 deletions(-) delete mode 100644 generation/3d_ddpm/3d_ddpm_tutorial.ipynb diff --git a/generation/2d_ddpm/2d_ddpm_compare_schedulers.ipynb b/generation/2d_ddpm/2d_ddpm_compare_schedulers.ipynb index 50e36b1d4..802f9db10 100644 --- a/generation/2d_ddpm/2d_ddpm_compare_schedulers.ipynb +++ b/generation/2d_ddpm/2d_ddpm_compare_schedulers.ipynb @@ -1,29 +1,21 @@ { "cells": [ - { - "cell_type": "code", - "execution_count": null, - "id": "6bbe8286", - "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": "d462dbf4", "metadata": {}, "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.\n", + "\n", "# Denoising Diffusion Probabilistic Models with MedNIST Dataset\n", "\n", "This tutorial compares the different schedulers available for sampling from a trained model with a reduced number of timesteps. The schedulers we will compare are:\n", diff --git a/generation/2d_ddpm/2d_ddpm_inpainting.ipynb b/generation/2d_ddpm/2d_ddpm_inpainting.ipynb index 608d9a9a2..48004948d 100644 --- a/generation/2d_ddpm/2d_ddpm_inpainting.ipynb +++ b/generation/2d_ddpm/2d_ddpm_inpainting.ipynb @@ -1,29 +1,21 @@ { "cells": [ - { - "cell_type": "code", - "execution_count": null, - "id": "4c8ec6e8", - "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": "9d71306f", "metadata": {}, "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.\n", + "\n", "# Inpainting with Denoising Diffusion Probabilistic Models\n", "\n", "This tutorial illustrates how to use MONAI for training a denoising diffusion probabilistic model (DDPM)[1] to inpaint 2D images.\n", diff --git a/generation/2d_ddpm/2d_ddpm_tutorial.ipynb b/generation/2d_ddpm/2d_ddpm_tutorial.ipynb index 93d0e1177..4307f8637 100644 --- a/generation/2d_ddpm/2d_ddpm_tutorial.ipynb +++ b/generation/2d_ddpm/2d_ddpm_tutorial.ipynb @@ -1,29 +1,21 @@ { "cells": [ - { - "cell_type": "code", - "execution_count": null, - "id": "375b97e1", - "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": "9d71306f", "metadata": {}, "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.\n", + "\n", "# Denoising Diffusion Probabilistic Models with MedNIST Dataset\n", "\n", "This tutorial illustrates how to use MONAI for training a denoising diffusion probabilistic model (DDPM)[1] to create\n", diff --git a/generation/2d_ddpm/2d_ddpm_tutorial_ignite.ipynb b/generation/2d_ddpm/2d_ddpm_tutorial_ignite.ipynb index 626842f7e..36b46dcb3 100644 --- a/generation/2d_ddpm/2d_ddpm_tutorial_ignite.ipynb +++ b/generation/2d_ddpm/2d_ddpm_tutorial_ignite.ipynb @@ -1,29 +1,21 @@ { "cells": [ - { - "cell_type": "code", - "execution_count": null, - "id": "f5cbf8da", - "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": "53c8dfc0", "metadata": {}, "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.\n", + "\n", "# Denoising Diffusion Probabilistic Models with MedNIST Dataset\n", "\n", "This tutorial illustrates how to use MONAI for training a denoising diffusion probabilistic model (DDPM)[1] to create\n", diff --git a/generation/2d_ddpm/2d_ddpm_tutorial_v_prediction.ipynb b/generation/2d_ddpm/2d_ddpm_tutorial_v_prediction.ipynb index 5d7e966d6..b7e3769ac 100644 --- a/generation/2d_ddpm/2d_ddpm_tutorial_v_prediction.ipynb +++ b/generation/2d_ddpm/2d_ddpm_tutorial_v_prediction.ipynb @@ -1,29 +1,21 @@ { "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "id": "a33dc913", - "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": "a1851245", "metadata": {}, "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.\n", + "\n", "# Denoising Diffusion Probabilistic Models using v-prediction parameterization\n", "\n", "This tutorial illustrates how to use MONAI for training a denoising diffusion probabilistic model (DDPM)[1] to create synthetic 2D images using v-prediction parameterization (Section 2.4 from [2]).\n", diff --git a/generation/3d_ddpm/3d_ddpm_tutorial.ipynb b/generation/3d_ddpm/3d_ddpm_tutorial.ipynb deleted file mode 100644 index 2d681a1f6..000000000 --- a/generation/3d_ddpm/3d_ddpm_tutorial.ipynb +++ /dev/null @@ -1,1049 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "id": "fa57bdf5", - "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": "6286986e", - "metadata": {}, - "source": [ - "# Denoising Diffusion Probabilistic Model on 3D data\n", - "\n", - "This tutorial illustrates how to use MONAI for training a denoising diffusion probabilistic model (DDPM)[1] to create synthetic 3D images.\n", - "\n", - "[1] - [Ho et al. \"Denoising Diffusion Probabilistic Models\"](https://arxiv.org/abs/2006.11239)\n", - "\n", - "\n", - "## Setup environment" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "f96b6f31", - "metadata": {}, - "outputs": [], - "source": [ - "!python -c \"import monai\" || pip install -q \"monai-weekly[nibabel, tqdm]\"\n", - "!python -c \"import matplotlib\" || pip install -q matplotlib\n", - "%matplotlib inline" - ] - }, - { - "cell_type": "markdown", - "id": "cbc01d24", - "metadata": {}, - "source": [ - "## Setup imports" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "cdea37d5", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "MONAI version: 1.4.0rc6\n", - "Numpy version: 1.26.4\n", - "Pytorch version: 2.3.1+cu121\n", - "MONAI flags: HAS_EXT = False, USE_COMPILED = False, USE_META_DICT = False\n", - "MONAI rev id: 6a0e1b043ba2890e1463fa49df76f66e56a68b08\n", - "MONAI __file__: /home//miniconda3/envs/monai/lib/python3.11/site-packages/monai/__init__.py\n", - "\n", - "Optional dependencies:\n", - "Pytorch Ignite version: 0.4.11\n", - "ITK version: 5.4.0\n", - "Nibabel version: 5.2.1\n", - "scikit-image version: 0.23.2\n", - "scipy version: 1.13.1\n", - "Pillow version: 10.3.0\n", - "Tensorboard version: 2.17.0\n", - "gdown version: 5.2.0\n", - "TorchVision version: 0.18.1+cu121\n", - "tqdm version: 4.66.4\n", - "lmdb version: 1.4.1\n", - "psutil version: 5.9.0\n", - "pandas version: 2.2.2\n", - "einops version: 0.8.0\n", - "transformers version: NOT INSTALLED or UNKNOWN VERSION.\n", - "mlflow version: 2.14.0\n", - "pynrrd version: 1.0.0\n", - "clearml version: 1.16.2rc0\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 tempfile\n", - "import time\n", - "\n", - "import matplotlib.pyplot as plt\n", - "import numpy as np\n", - "import torch\n", - "import torch.nn.functional as F\n", - "from torch.amp import GradScaler, autocast\n", - "from tqdm import tqdm\n", - "\n", - "from monai.apps import DecathlonDataset\n", - "from monai.config import print_config\n", - "from monai.data import DataLoader\n", - "from monai.transforms import (\n", - " EnsureChannelFirstd,\n", - " CenterSpatialCropd,\n", - " Compose,\n", - " Lambdad,\n", - " LoadImaged,\n", - " Resized,\n", - " ScaleIntensityd,\n", - ")\n", - "from monai.utils import set_determinism\n", - "from monai.inferers import DiffusionInferer\n", - "from monai.networks.nets import DiffusionModelUNet\n", - "from monai.networks.schedulers import DDPMScheduler, DDIMScheduler\n", - "\n", - "print_config()" - ] - }, - { - "cell_type": "markdown", - "id": "50e37a43", - "metadata": {}, - "source": [ - "## Setup data directory\n", - "\n", - "You can specify a directory with the MONAI_DATA_DIRECTORY environment variable.\n", - "\n", - "This allows you to save results and reuse downloads.\n", - "\n", - "If not specified a temporary directory will be used." - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "c38b4c33", - "metadata": {}, - "outputs": [], - "source": [ - "directory = os.path.abspath(\"./data\") # 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": "41af1391", - "metadata": {}, - "source": [ - "## Set deterministic training for reproducibility" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "515d8583", - "metadata": {}, - "outputs": [], - "source": [ - "set_determinism(42)" - ] - }, - { - "cell_type": "markdown", - "id": "29d8c601", - "metadata": {}, - "source": [ - "## Setup Decathlon Dataset and training and validation data loaders\n", - "\n", - "In this tutorial, we will use the 3D T1 weighted brain images from the [2016 and 2017 Brain Tumor Segmentation (BraTS) challenges](https://www.med.upenn.edu/sbia/brats2017/data.html). This dataset can be easily downloaded using the [DecathlonDataset](https://docs.monai.io/en/stable/apps.html#monai.apps.DecathlonDataset) from MONAI (`task=\"Task01_BrainTumour\"`). To load the training and validation images, we are using the `data_transform` transformations that are responsible for the following:\n", - "\n", - "1. `LoadImaged`: Loads the brain images from files.\n", - "2. `Lambdad`: Choose channel 1 of the image, which is the T1-weighted image.\n", - "3. `EnsureChannelFirstd`: Add the channel dimension of the input data.\n", - "4. `ScaleIntensityd`: Apply a min-max scaling in the intensity values of each image to be in the `[0, 1]` range.\n", - "5. `CenterSpatialCropd`: Crop the background of the images using a roi of size `[160, 200, 155]`.\n", - "6. `Resized`: Resize the images to a volume with size `[32, 40, 32]`.\n", - "\n", - "For the data loader, we are using mini-batches of 8 images, which consumes about 21GB of GPU memory during training. Please, reduce this value to run on smaller GPUs." - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "f640d7ac", - "metadata": {}, - "outputs": [], - "source": [ - "data_transform = Compose(\n", - " [\n", - " LoadImaged(keys=[\"image\"]),\n", - " Lambdad(keys=\"image\", func=lambda x: x[:, :, :, 1]),\n", - " EnsureChannelFirstd(keys=[\"image\"], channel_dim=\"no_channel\"),\n", - " ScaleIntensityd(keys=[\"image\"]),\n", - " CenterSpatialCropd(keys=[\"image\"], roi_size=[160, 200, 155]),\n", - " Resized(keys=[\"image\"], spatial_size=(32, 40, 32)),\n", - " ]\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "ddd61e60", - "metadata": { - "lines_to_next_cell": 2 - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2024-09-03 18:10:10,352 - INFO - Verified 'Task01_BrainTumour.tar', md5: 240a19d752f0d9e9101544901065d872.\n", - "2024-09-03 18:10:10,355 - INFO - File exists: /home/ek10/tutorials_mine/generation/3d_ddpm/data/Task01_BrainTumour.tar, skipped downloading.\n", - "2024-09-03 18:10:10,357 - INFO - Non-empty folder exists in /home/ek10/tutorials_mine/generation/3d_ddpm/data/Task01_BrainTumour, skipped extracting.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Loading dataset: 100%|██████████| 388/388 [04:49<00:00, 1.34it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2024-09-03 18:15:14,606 - INFO - Verified 'Task01_BrainTumour.tar', md5: 240a19d752f0d9e9101544901065d872.\n", - "2024-09-03 18:15:14,607 - INFO - File exists: /home/ek10/tutorials_mine/generation/3d_ddpm/data/Task01_BrainTumour.tar, skipped downloading.\n", - "2024-09-03 18:15:14,609 - INFO - Non-empty folder exists in /home/ek10/tutorials_mine/generation/3d_ddpm/data/Task01_BrainTumour, skipped extracting.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Loading dataset: 100%|██████████| 96/96 [01:13<00:00, 1.30it/s]\n" - ] - } - ], - "source": [ - "batch_size = 8\n", - "num_workers = 8\n", - "\n", - "train_ds = DecathlonDataset(\n", - " root_dir=root_dir, task=\"Task01_BrainTumour\", transform=data_transform, section=\"training\", download=True\n", - ")\n", - "\n", - "train_loader = DataLoader(\n", - " train_ds, batch_size=batch_size, shuffle=True, num_workers=num_workers, persistent_workers=True\n", - ")\n", - "\n", - "val_ds = DecathlonDataset(\n", - " root_dir=root_dir, task=\"Task01_BrainTumour\", transform=data_transform, section=\"validation\", download=True\n", - ")\n", - "\n", - "val_loader = DataLoader(val_ds, batch_size=batch_size, shuffle=False, num_workers=num_workers, persistent_workers=True)" - ] - }, - { - "cell_type": "markdown", - "id": "50efe5ef", - "metadata": {}, - "source": [ - "### Visualization of the training images" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "bffb4abc", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plt.subplots(1, 4, figsize=(10, 6))\n", - "for i in range(4):\n", - " plt.subplot(1, 4, i + 1)\n", - " plt.imshow(train_ds[i * 20][\"image\"][0, :, :, 15].detach().cpu(), vmin=0, vmax=1, cmap=\"gray\")\n", - " plt.axis(\"off\")\n", - "plt.tight_layout()\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "d22296e5", - "metadata": {}, - "source": [ - "### Define network, scheduler, optimizer, and inferer\n", - "\n", - "We will use a DDPM in this example; for that, we need to define a `DiffusionModelUNet` network that will have as input the noisy images and the values for the timestep `t`, and it will predict the noise that is present in the image.\n", - "\n", - "In this example, we have a network with three levels (with 256, 256, and 512 channels in each). In every level, we will have two residual blocks, and only the last one will have an attention block with a single attention head (with 512 channels)." - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "d499f7b1", - "metadata": { - "lines_to_next_cell": 2 - }, - "outputs": [], - "source": [ - "device = torch.device(\"cuda\")\n", - "\n", - "model = DiffusionModelUNet(\n", - " spatial_dims=3,\n", - " in_channels=1,\n", - " out_channels=1,\n", - " channels=[256, 256, 512],\n", - " attention_levels=[False, False, True],\n", - " num_head_channels=[0, 0, 512],\n", - " num_res_blocks=2,\n", - ").to(device)" - ] - }, - { - "cell_type": "markdown", - "id": "47ad91ff", - "metadata": {}, - "source": [ - "Together with our U-net, we need to define the Noise Scheduler for the diffusion model. This scheduler is responsible for defining the amount of noise that should be added in each timestep `t` of the diffusion model's Markov chain. Besides that, it has the operations to perform the reverse process, which will remove the noise of the images (a.k.a. denoising process). In this case, we are using a `DDPMScheduler`. Here we are using 1000 timesteps and a `scaled_linear` profile for the beta values (proposed in [Rombach et al. \"High-Resolution Image Synthesis with Latent Diffusion Models\"](https://arxiv.org/abs/2112.10752)). This profile had better results than the `linear, proposed in the original DDPM's paper. In `beta_start` and `beta_end`, we define the limits for the beta values. These are important to determine how accentuated is the addition of noise in the image." - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "6c1de5ad", - "metadata": {}, - "outputs": [], - "source": [ - "num_train_timesteps = 1000\n", - "scheduler = DDPMScheduler(\n", - " num_train_timesteps=num_train_timesteps, schedule=\"scaled_linear_beta\", beta_start=0.0005, beta_end=0.0195\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "id": "36d3e99a", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0, 0.5, 'alpha cumprod')" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plt.plot(scheduler.alphas_cumprod.cpu(), color=(2 / 255, 163 / 255, 163 / 255), linewidth=2)\n", - "plt.xlabel(\"Timestep [t]\")\n", - "plt.ylabel(\"alpha cumprod\")" - ] - }, - { - "cell_type": "markdown", - "id": "9125f7c8", - "metadata": {}, - "source": [ - "Finally, we define the Inferer, which contains functions that will help during the training and sampling of the model, and the optimizer." - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "id": "8685da6e", - "metadata": {}, - "outputs": [], - "source": [ - "inferer = DiffusionInferer(scheduler)\n", - "optimizer = torch.optim.Adam(params=model.parameters(), lr=5e-5)" - ] - }, - { - "cell_type": "markdown", - "id": "9f371ad8", - "metadata": {}, - "source": [ - "## Model training\n", - "\n", - "In this part, we will train the diffusion model to predict the noise added to the images. For this, we are using an MSE loss between the prediction and the original noise. During the training, we are also sampling brain images to evaluate the evolution of the model. In this training, we use Automatic Mixed Precision to save memory and speed up the training." - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "id": "bd10b595", - "metadata": { - "lines_to_next_cell": 0 - }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Epoch 0: 100%|████████████| 49/49 [00:44<00:00, 1.10it/s, loss=0.263]\n", - "Epoch 1: 100%|███████████| 49/49 [00:44<00:00, 1.11it/s, loss=0.0263]\n", - "Epoch 2: 100%|███████████| 49/49 [00:44<00:00, 1.11it/s, loss=0.0137]\n", - "Epoch 3: 100%|███████████| 49/49 [00:44<00:00, 1.11it/s, loss=0.0132]\n", - "Epoch 4: 100%|███████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.0114]\n", - "Epoch 5: 100%|███████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.0114]\n", - "Epoch 6: 100%|██████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.00695]\n", - "Epoch 7: 100%|██████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.00771]\n", - "Epoch 8: 100%|███████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.0106]\n", - "Epoch 9: 100%|██████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.00995]\n", - "Epoch 10: 100%|█████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.00615]\n", - "Epoch 11: 100%|█████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.00768]\n", - "Epoch 12: 100%|█████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.00711]\n", - "Epoch 13: 100%|█████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.00755]\n", - "Epoch 14: 100%|█████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.00628]\n", - "Epoch 15: 100%|█████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.00723]\n", - "Epoch 16: 100%|█████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.00786]\n", - "Epoch 17: 100%|█████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.00665]\n", - "Epoch 18: 100%|██████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.0063]\n", - "Epoch 19: 100%|██████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.0057]\n", - "Epoch 20: 100%|█████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.00712]\n", - "Epoch 21: 100%|█████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.00584]\n", - "Epoch 22: 100%|█████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.00537]\n", - "Epoch 23: 100%|█████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.00619]\n", - "Epoch 24: 100%|█████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.00543]\n", - "100%|██████████| 1000/1000 [00:44<00:00, 22.24it/s]\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Epoch 25: 100%|█████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.00601]\n", - "Epoch 26: 100%|█████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.00569]\n", - "Epoch 27: 100%|██████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.0049]\n", - "Epoch 28: 100%|█████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.00549]\n", - "Epoch 29: 100%|██████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.0058]\n", - "Epoch 30: 100%|█████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.00615]\n", - "Epoch 31: 100%|█████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.00406]\n", - "Epoch 32: 100%|█████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.00423]\n", - "Epoch 33: 100%|█████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.00506]\n", - "Epoch 34: 100%|█████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.00672]\n", - "Epoch 35: 100%|█████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.00716]\n", - "Epoch 36: 100%|█████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.00442]\n", - "Epoch 37: 100%|█████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.00569]\n", - "Epoch 38: 100%|█████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.00552]\n", - "Epoch 39: 100%|█████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.00434]\n", - "Epoch 40: 100%|█████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.00509]\n", - "Epoch 41: 100%|█████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.00639]\n", - "Epoch 42: 100%|█████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.00381]\n", - "Epoch 43: 100%|█████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.00434]\n", - "Epoch 44: 100%|█████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.00427]\n", - "Epoch 45: 100%|█████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.00605]\n", - "Epoch 46: 100%|█████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.00522]\n", - "Epoch 47: 100%|██████████| 49/49 [00:44<00:00, 1.11it/s, loss=0.0054]\n", - "Epoch 48: 100%|█████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.00555]\n", - "Epoch 49: 100%|█████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.00475]\n", - "100%|██████████| 1000/1000 [00:44<00:00, 22.29it/s]\n" - ] - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAKIAAACGCAYAAABez1E7AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy80BEi2AAAACXBIWXMAAA9hAAAPYQGoP6dpAAACv0lEQVR4nO3dy2rbQABAUbt5L0wg6/z/l2UdCF7kTbozVkOLaazoTjhnJZGSDuQyGqSRvf74+PhYwcJ+LT0AWK2ESIQQSRAiCUIkQYgkCJEEIZIgRBJOD/2H6/V6znHwgx3y8M6MSIIQSTj40kzb/tJpxH0sZkQShEiCS/MR/HlHYYlL44iX431mRBKESIIQSRh2jXhxcbE7fn5+XnAk46/PCsyIJAiRhPWhr5Pa9NB2e3u7O767u1twJJ/Z9MAwhEiCEEmwRmR21ogMQ4gkCJEEIZIgRBKESMKwu2/+V2E3NZ+ZEUkQIglCJOEoa8TLy8vJ+dPT0zF+7SxGWhOenk7/PG9vbwuNZH5mRBKESILdNxzFZrPZHW+328nP7L5hGEIkQYgkWCMyO2tEhiFEEoRIghBJECIJQiRBiCQIkQQhkiBEEoRIghBJECIJ6Rfsz8/Pd8cvLy8LjuRrSl/FUWVGJEGIJAiRBDu0v9nZ2dnk/PX1dXd8c3Mz+dn9/f1ff8/+W3Or1ec350rs0GYYQiTBpTns5ORkcv7+/r7QSL7GpZlhCJEEIZIw+yO+q6uryfnj4+Pc/+WPMeqa8H+YEUkQIglCJMF9xD2+g2Ue7iMyDCGSkN6h/d1cipdjRiRBiCQIkYRh14j7t1qs7aZfQ1f+Crq/MSOSIEQSZn+yYvcNnqwwDCGSIEQS7L5hdtaIDEOIJAiRhPQjvlEe4+1/oOhqNfaHii7FjEiCEElw++Yfll4aXF9fT84fHh6+fQzH4PYNwxAiCUIkwRqR2VkjMgwhkiBEEoRIghBJECIJQiRBiCQIkQQhkiBEEoRIghBJECIJQiRBiCQIkYT0C/Zz2Gw2k/PtdrvQSNhnRiRBiCR4eYrZeXmKYQiRBCGScPDtm/LnEzI+MyIJQiRBiCQIkQQhkiBEEoRIghBJECIJvwHFRbXOl8m4xwAAAABJRU5ErkJggg==", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Epoch 50: 100%|█████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.00464]\n", - "Epoch 51: 100%|█████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.00443]\n", - "Epoch 52: 100%|█████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.00533]\n", - "Epoch 53: 100%|█████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.00399]\n", - "Epoch 54: 100%|█████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.00417]\n", - "Epoch 55: 100%|█████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.00431]\n", - "Epoch 56: 100%|██████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.0042]\n", - "Epoch 57: 100%|█████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.00484]\n", - "Epoch 58: 100%|█████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.00494]\n", - "Epoch 59: 100%|█████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.00426]\n", - "Epoch 60: 100%|█████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.00454]\n", - "Epoch 61: 100%|█████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.00365]\n", - "Epoch 62: 100%|█████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.00371]\n", - "Epoch 63: 100%|█████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.00399]\n", - "Epoch 64: 100%|█████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.00411]\n", - "Epoch 65: 100%|█████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.00404]\n", - "Epoch 66: 100%|█████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.00442]\n", - "Epoch 67: 100%|███████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.004]\n", - "Epoch 68: 100%|█████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.00379]\n", - "Epoch 69: 100%|█████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.00514]\n", - "Epoch 70: 100%|█████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.00372]\n", - "Epoch 71: 100%|███████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.005]\n", - "Epoch 72: 100%|█████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.00379]\n", - "Epoch 73: 100%|█████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.00288]\n", - "Epoch 74: 100%|█████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.00488]\n", - "100%|██████████| 1000/1000 [00:44<00:00, 22.26it/s]\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Epoch 75: 100%|█████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.00464]\n", - "Epoch 76: 100%|█████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.00338]\n", - "Epoch 77: 100%|█████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.00396]\n", - "Epoch 78: 100%|█████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.00552]\n", - "Epoch 79: 100%|█████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.00439]\n", - "Epoch 80: 100%|█████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.00395]\n", - "Epoch 81: 100%|█████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.00278]\n", - "Epoch 82: 100%|█████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.00411]\n", - "Epoch 83: 100%|█████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.00347]\n", - "Epoch 84: 100%|█████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.00524]\n", - "Epoch 85: 100%|█████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.00444]\n", - "Epoch 86: 100%|█████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.00479]\n", - "Epoch 87: 100%|█████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.00412]\n", - "Epoch 88: 100%|█████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.00377]\n", - "Epoch 89: 100%|█████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.00419]\n", - "Epoch 90: 100%|█████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.00387]\n", - "Epoch 91: 100%|█████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.00501]\n", - "Epoch 92: 100%|██████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.0033]\n", - "Epoch 93: 100%|█████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.00391]\n", - "Epoch 94: 100%|█████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.00353]\n", - "Epoch 95: 100%|█████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.00363]\n", - "Epoch 96: 100%|█████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.00351]\n", - "Epoch 97: 100%|█████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.00373]\n", - "Epoch 98: 100%|█████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.00387]\n", - "Epoch 99: 100%|█████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.00413]\n", - "100%|██████████| 1000/1000 [00:44<00:00, 22.26it/s]\n" - ] - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAKIAAACGCAYAAABez1E7AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy80BEi2AAAACXBIWXMAAA9hAAAPYQGoP6dpAAAC5klEQVR4nO3d2U7jQBAF0A5Z/v93s0DmDZxII9lJO75ln/MUJAQWuqouevPufr/fGyzsa+kHgNYEkRCCSARBJIIgEkEQiSCIRBBEIggiEQ5jv3G32835HKzYmMU7FZEIgkiE0UMzfZxOp4evL5fLQk+SRUUkgiASYTd2P+KU/5q/vv7y/fPzM/2pWBX/NVOGIBJBEIkwy/RNr77weDz+fr5er11+5tY99/opR5ZURCIIIhFmmb5Zo+GUVGumpaYwfUMZgkgEQSSC3Tcj6QnnpSISQRCJIIhEKNsjWv57tN/vfz9/f38v+CSvURGJIIhEiF7i67HTeziEt2YYf8cwA1N27VjiowxBJIIgEiG6Rxz6xMH0w+FxNut2u3X/HVukR6QMQSTCokOzXc/T9JjOWuLwlKGZMgSRCIJIhDLTN0sztfM6PSJlCCIRBJEIUT1i6gVBvEePSBmCSITZD09NWcYzFG+XikgEQSSCIBJh9h7R1i7GUBGJIIhEmGVo9go0plIRiSCIRBBEIkS/Ao3/W9sJSBWRCIJIhC5Dc+VhouoVyJX+xmOoiEQQRCIIIhGiDk/NwYGs5Tk8RRmCSARBJEKZV6ANX/HV2vjXfG2xJ3y+MGoo9fIoFZEIgkiE1U/fsDzTN5QhiEQQRCKUmb7Zgi0vR6qIRBBEIhiag/Qaip93zA93oZ/P5y6/ozcVkQiCSARBJIIlPmZniY8yBJEIgkgE84gdVL7pIoWKSARBJIKh+UXD6SxD8ftURCIIIhEEkQhlesThVqbWPn+p5pZ3T3+CikgEQSTCKnffDJ81fQid8qxVXy1n9w1lCCIRBJEIq+wR01Tt7XrRI1KGIBJBEIlQZolvaa/e4d3aNvvCqVREIggiEQzNI00ZiplORSSCIBJBEImgRyxkuEv90zvU56YiEkEQiWD3DbOz+4YyBJEIgkiE0dM36afhqE1FJIIgEkEQiSCIRBBEIggiEQSRCIJIBEEkwj/jRfKzasQTOgAAAABJRU5ErkJggg==", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Epoch 100: 100%|████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.00376]\n", - "Epoch 101: 100%|████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.00317]\n", - "Epoch 102: 100%|████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.00316]\n", - "Epoch 103: 100%|████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.00405]\n", - "Epoch 104: 100%|████████| 49/49 [00:44<00:00, 1.11it/s, loss=0.00397]\n", - "Epoch 105: 100%|████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.00388]\n", - "Epoch 106: 100%|████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.00376]\n", - "Epoch 107: 100%|████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.00538]\n", - "Epoch 108: 100%|████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.00328]\n", - "Epoch 109: 100%|████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.00486]\n", - "Epoch 110: 100%|████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.00487]\n", - "Epoch 111: 100%|████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.00408]\n", - "Epoch 112: 100%|████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.00412]\n", - "Epoch 113: 100%|████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.00278]\n", - "Epoch 114: 100%|█████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.0035]\n", - "Epoch 115: 100%|████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.00297]\n", - "Epoch 116: 100%|████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.00263]\n", - "Epoch 117: 100%|████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.00309]\n", - "Epoch 118: 100%|████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.00306]\n", - "Epoch 119: 100%|████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.00477]\n", - "Epoch 120: 100%|████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.00361]\n", - "Epoch 121: 100%|████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.00317]\n", - "Epoch 122: 100%|████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.00433]\n", - "Epoch 123: 100%|█████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.0046]\n", - "Epoch 124: 100%|████████| 49/49 [00:43<00:00, 1.11it/s, loss=0.00484]\n", - "100%|██████████| 1000/1000 [00:44<00:00, 22.27it/s]\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Epoch 125: 100%|████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.00582]\n", - "Epoch 126: 100%|████████| 49/49 [00:43<00:00, 1.11it/s, loss=0.00438]\n", - "Epoch 127: 100%|████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.00304]\n", - "Epoch 128: 100%|████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.00339]\n", - "Epoch 129: 100%|████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.00362]\n", - "Epoch 130: 100%|████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.00317]\n", - "Epoch 131: 100%|████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.00388]\n", - "Epoch 132: 100%|█████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.0042]\n", - "Epoch 133: 100%|████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.00583]\n", - "Epoch 134: 100%|████████| 49/49 [00:43<00:00, 1.11it/s, loss=0.00653]\n", - "Epoch 135: 100%|█████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.0037]\n", - "Epoch 136: 100%|████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.00485]\n", - "Epoch 137: 100%|████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.00387]\n", - "Epoch 138: 100%|█████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.0046]\n", - "Epoch 139: 100%|█████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.0045]\n", - "Epoch 140: 100%|█████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.0029]\n", - "Epoch 141: 100%|████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.00353]\n", - "Epoch 142: 100%|████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.00477]\n", - "Epoch 143: 100%|████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.00438]\n", - "Epoch 144: 100%|████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.00396]\n", - "Epoch 145: 100%|████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.00323]\n", - "Epoch 146: 100%|████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.00455]\n", - "Epoch 147: 100%|█████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.0056]\n", - "Epoch 148: 100%|████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.00357]\n", - "Epoch 149: 100%|████████| 49/49 [00:43<00:00, 1.12it/s, loss=0.00413]\n", - "100%|██████████| 1000/1000 [00:44<00:00, 22.26it/s]\n" - ] - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAKIAAACGCAYAAABez1E7AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy80BEi2AAAACXBIWXMAAA9hAAAPYQGoP6dpAAABvUlEQVR4nO3dQQqDMBRAQVO8/4mFdNvuQsH6WmfWWQR8fIKCGXPOucHFHldvALZNiEQIkQQhkiBEEoRIghBJECIJQiRhX104xjhzH/yxlY93JiIJQiRBiCQIkQQhkiBEEoRIghBJECIJQiRBiCQIkQQhkiBEEoRIghBJECIJQiRBiCQIkQQhkiBEEoRIghBJECIJQiRBiCQIkQQhkiBEEoRIghBJECIJQiRh+dfFfN++vz+e4zgu2sn5TEQShEiCEEkYqxeHu96CT7negp8hRBK8vrmB12PV4kns60xEEoRIghBJcEa8geq58JWJSIIQSRAiCUIkQYgkCJEEIZIgRBKESIIQSRAiCUIkQYgkCJEEIZIgRBKESIIQSRAiCUIkQYgkCJEEIZIgRBKESIIQSRAiCUIkQYgkCJEEIZIgRBKESIIQSRAiCUIkQYgkCJEEIZIgRBKESIIQSRAiCUIkQYgkCJEEIZIgRBKESIIQSRAiCUIkQYgkCJEEIZIgRBKESIIQSRAiCUIkQYgkCJEEIZIgRBKESIIQSRAiCfvqwjnnmfvg5kxEEoRIghBJECIJQiRBiCQIkQQhkiBEEp6pAxsHCWAPJQAAAABJRU5ErkJggg==", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "train completed, total time: 6877.832907915115.\n" - ] - } - ], - "source": [ - "max_epochs = 150\n", - "val_interval = 25\n", - "epoch_loss_list = []\n", - "val_epoch_loss_list = []\n", - "\n", - "scaler = GradScaler()\n", - "total_start = time.time()\n", - "for epoch in range(max_epochs):\n", - " model.train()\n", - " epoch_loss = 0\n", - " progress_bar = tqdm(enumerate(train_loader), total=len(train_loader), ncols=70)\n", - " progress_bar.set_description(f\"Epoch {epoch}\")\n", - " for step, batch in progress_bar:\n", - " images = batch[\"image\"].to(device)\n", - " optimizer.zero_grad(set_to_none=True)\n", - "\n", - " with autocast(device_type=\"cuda\", enabled=True):\n", - " # Generate random noise\n", - " noise = torch.randn_like(images).to(device)\n", - "\n", - " # Create timesteps\n", - " timesteps = torch.randint(\n", - " 0, inferer.scheduler.num_train_timesteps, (images.shape[0],), device=images.device\n", - " ).long()\n", - "\n", - " # Get model prediction\n", - " noise_pred = inferer(inputs=images, diffusion_model=model, noise=noise, timesteps=timesteps)\n", - "\n", - " loss = F.mse_loss(noise_pred.float(), noise.float())\n", - "\n", - " scaler.scale(loss).backward()\n", - " scaler.step(optimizer)\n", - " scaler.update()\n", - "\n", - " epoch_loss += loss.item()\n", - "\n", - " progress_bar.set_postfix({\"loss\": epoch_loss / (step + 1)})\n", - " epoch_loss_list.append(epoch_loss / (step + 1))\n", - "\n", - " if (epoch + 1) % val_interval == 0:\n", - " model.eval()\n", - " val_epoch_loss = 0\n", - " for step, batch in enumerate(val_loader):\n", - " images = batch[\"image\"].to(device)\n", - " noise = torch.randn_like(images).to(device)\n", - " with torch.no_grad():\n", - " with autocast(device_type=\"cuda\", enabled=True):\n", - " timesteps = torch.randint(\n", - " 0, inferer.scheduler.num_train_timesteps, (images.shape[0],), device=images.device\n", - " ).long()\n", - "\n", - " # Get model prediction\n", - " noise_pred = inferer(inputs=images, diffusion_model=model, noise=noise, timesteps=timesteps)\n", - " val_loss = F.mse_loss(noise_pred.float(), noise.float())\n", - "\n", - " val_epoch_loss += val_loss.item()\n", - " progress_bar.set_postfix({\"val_loss\": val_epoch_loss / (step + 1)})\n", - " val_epoch_loss_list.append(val_epoch_loss / (step + 1))\n", - "\n", - " # Sampling image during training\n", - " image = torch.randn((1, 1, 32, 40, 32))\n", - " image = image.to(device)\n", - " scheduler.set_timesteps(num_inference_steps=1000)\n", - " with autocast(device_type=\"cuda\", enabled=True):\n", - " image = inferer.sample(input_noise=image, diffusion_model=model, scheduler=scheduler)\n", - "\n", - " plt.figure(figsize=(2, 2))\n", - " plt.imshow(image[0, 0, :, :, 15].cpu(), vmin=0, vmax=1, cmap=\"gray\")\n", - " plt.tight_layout()\n", - " plt.axis(\"off\")\n", - " plt.show()\n", - "\n", - "total_time = time.time() - total_start\n", - "print(f\"train completed, total time: {total_time}.\")\n", - "\n", - "# max_epochs = 40\n", - "# val_interval = max_epochs // 5\n", - "# epoch_loss_list = []\n", - "# val_epoch_loss_list = []\n", - "\n", - "# scaler = GradScaler()\n", - "# total_start = time.time()\n", - "# for epoch in range(max_epochs):\n", - "# model.train()\n", - "# epoch_loss = 0\n", - "# progress_bar = tqdm(enumerate(train_loader), total=len(train_loader), ncols=70)\n", - "# progress_bar.set_description(f\"Epoch {epoch}\")\n", - "# for step, batch in progress_bar:\n", - "# images = batch[\"image\"].to(device)\n", - "# optimizer.zero_grad(set_to_none=True)\n", - "\n", - "# with autocast(device_type=\"cuda\", enabled=True):\n", - "# # Generate random noise\n", - "# noise = torch.randn_like(images).to(device)\n", - "\n", - "# # Create timesteps\n", - "# timesteps = torch.randint(0, num_train_timesteps, (images.shape[0],), device=images.device).long()\n", - "\n", - "# # Get model prediction\n", - "# noise_pred = inferer(inputs=images, diffusion_model=model, noise=noise, timesteps=timesteps)\n", - "\n", - "# loss = F.mse_loss(noise_pred.float(), noise.float())\n", - "\n", - "# scaler.scale(loss).backward()\n", - "# scaler.step(optimizer)\n", - "# scaler.update()\n", - "\n", - "# epoch_loss += loss.item()\n", - "\n", - "# progress_bar.set_postfix({\"loss\": f\"{epoch_loss / (step + 1):.4f}\"})\n", - "# epoch_loss_list.append(epoch_loss / (step + 1))\n", - "\n", - "# if (epoch + 1) % val_interval == 0:\n", - "# model.eval()\n", - "# val_epoch_loss = 0\n", - "# for step, batch in enumerate(val_loader):\n", - "# images = batch[\"image\"].to(device)\n", - "# noise = torch.randn_like(images).to(device)\n", - "# with torch.no_grad(), autocast(device_type=\"cuda\", enabled=True):\n", - "# timesteps = torch.randint(0, num_train_timesteps, (images.shape[0],), device=images.device).long()\n", - "\n", - "# # Get model prediction\n", - "# noise_pred = inferer(inputs=images, diffusion_model=model, noise=noise, timesteps=timesteps)\n", - "# val_loss = F.mse_loss(noise_pred.float(), noise.float())\n", - "\n", - "# val_epoch_loss += val_loss.item()\n", - "# progress_bar.set_postfix({\"val_loss\": val_epoch_loss / (step + 1)})\n", - "# val_epoch_loss_list.append(val_epoch_loss / (step + 1))\n", - "\n", - "# # Sampling image during training\n", - "# image = torch.randn((1, 1, 32, 40, 32))\n", - "# image = image.to(device)\n", - "# scheduler.set_timesteps(num_inference_steps=1000)\n", - "# with autocast(device_type=\"cuda\", enabled=True):\n", - "# image = inferer.sample(input_noise=image, diffusion_model=model, scheduler=scheduler)\n", - "\n", - "# plt.figure(figsize=(2, 2))\n", - "# plt.imshow(image[0, 0, :, :, 15].cpu(), vmin=0, vmax=1, cmap=\"gray\")\n", - "# plt.tight_layout()\n", - "# plt.axis(\"off\")\n", - "# plt.show()\n", - "\n", - "# total_time = time.time() - total_start\n", - "# print(f\"train completed, total time: {total_time}.\")" - ] - }, - { - "cell_type": "markdown", - "id": "3e263b67", - "metadata": {}, - "source": [ - "### Learning curves" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "id": "c7520419", - "metadata": { - "lines_to_next_cell": 2 - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plt.style.use(\"seaborn-v0_8\")\n", - "plt.title(\"Learning Curves\", fontsize=20)\n", - "plt.plot(np.linspace(1, max_epochs, max_epochs), epoch_loss_list, color=\"C0\", linewidth=2.0, label=\"Train\")\n", - "plt.plot(\n", - " np.linspace(val_interval, max_epochs, int(max_epochs / val_interval)),\n", - " val_epoch_loss_list,\n", - " color=\"C1\",\n", - " linewidth=2.0,\n", - " label=\"Validation\",\n", - ")\n", - "plt.yticks(fontsize=12)\n", - "plt.xticks(fontsize=12)\n", - "plt.xlabel(\"Epochs\", fontsize=16)\n", - "plt.ylabel(\"Loss\", fontsize=16)\n", - "plt.legend(prop={\"size\": 14})\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "38724c9b", - "metadata": {}, - "source": [ - "## Sampling Brain Image\n", - "\n", - "In order to sample the brain images, we need to pass the model an image containing just noise and use it to remove the noise of the image iteratively. For that, we will use the `.sample()` function of the `inferer`." - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "id": "092eb6a0", - "metadata": { - "lines_to_next_cell": 2 - }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 1000/1000 [01:10<00:00, 14.29it/s]\n" - ] - } - ], - "source": [ - "model.eval()\n", - "noise = torch.randn((1, 1, 32, 40, 32))\n", - "noise = noise.to(device)\n", - "scheduler.set_timesteps(num_inference_steps=1000)\n", - "image = inferer.sample(input_noise=noise, diffusion_model=model, scheduler=scheduler)" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "id": "5dc3e69d", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plt.style.use(\"default\")\n", - "plotting_image_0 = np.concatenate([image[0, 0, :, :, 15].cpu(), np.flipud(image[0, 0, :, 20, :].cpu().T)], axis=1)\n", - "plotting_image_1 = np.concatenate([np.flipud(image[0, 0, 15, :, :].cpu().T), np.zeros((32, 32))], axis=1)\n", - "plt.imshow(np.concatenate([plotting_image_0, plotting_image_1], axis=0), vmin=0, vmax=1, cmap=\"gray\")\n", - "plt.tight_layout()\n", - "plt.axis(\"off\")\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "f0acc27a", - "metadata": {}, - "source": [ - "### Sampling with Denoising Diffusion Implicit Model Scheduler\n", - "\n", - "Recent papers have proposed different ways to improve the sampling speed by using fewer steps in the denoising process. In this example, we are using a `DDIMScheduler` (from [Song et al. \"Denoising Diffusion Implicit Models\"](https://arxiv.org/abs/2010.02502)) to reduce the original number of steps from 1000 to 250." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "e3e43b95", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 250/250 [00:17<00:00, 14.54it/s]\n" - ] - } - ], - "source": [ - "scheduler_ddim = DDIMScheduler(\n", - " num_train_timesteps=num_train_timesteps,\n", - " schedule=\"scaled_linear_beta\",\n", - " beta_start=0.0005,\n", - " beta_end=0.0195,\n", - " clip_sample=False,\n", - ")\n", - "\n", - "scheduler_ddim.set_timesteps(num_inference_steps=250)\n", - "\n", - "model.eval()\n", - "noise = torch.randn((1, 1, 32, 40, 32))\n", - "noise = noise.to(device)\n", - "\n", - "image = inferer.sample(input_noise=noise, diffusion_model=model, scheduler=scheduler_ddim)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "89f93ab8", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plt.style.use(\"default\")\n", - "plotting_image_0 = np.concatenate([image[0, 0, :, :, 15].cpu(), np.flipud(image[0, 0, :, 20, :].cpu().T)], axis=1)\n", - "plotting_image_1 = np.concatenate([np.flipud(image[0, 0, 15, :, :].cpu().T), np.zeros((32, 32))], axis=1)\n", - "plt.imshow(np.concatenate([plotting_image_0, plotting_image_1], axis=0), vmin=0, vmax=1, cmap=\"gray\")\n", - "plt.tight_layout()\n", - "plt.axis(\"off\")\n", - "plt.show()" - ] - } - ], - "metadata": { - "jupytext": { - "formats": "py:percent,ipynb" - }, - "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.11.9" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -}