From b92f9db99c8952394c0f85d990c0de70b9945ca6 Mon Sep 17 00:00:00 2001 From: Can Zhao <69829124+Can-Zhao@users.noreply.github.com> Date: Fri, 12 Jul 2024 16:29:50 -0700 Subject: [PATCH] Maisi VAE notebook (#1757) Fixes # . ### Description Add MAISI notebook and adjust it to a setting that can run on 16G V100. ### Checks - [x] Avoid including large-size files in the PR. - [x] Clean up long text outputs from code cells in the notebook. - [x] For security purposes, please check the contents and remove any sensitive info such as user names and private key. - [x] Ensure (1) hyperlinks and markdown anchors are working (2) use relative paths for tutorial repo files (3) put figure and graphs in the `./figure` folder - [x] Notebook runs automatically `./runner.sh -t ` --------- Signed-off-by: root Signed-off-by: Can-Zhao Co-authored-by: root Co-authored-by: pre-commit-ci[bot] <66853113+pre-commit-ci[bot]@users.noreply.github.com> Co-authored-by: Mingxin Zheng <18563433+mingxin-zheng@users.noreply.github.com> --- .../maisi/configs/config_maisi_vae_train.json | 6 +- .../configs/environment_maisi_vae_train.json | 4 + .../maisi/maisi_train_vae_tutorial.ipynb | 961 ++++++++++++++++++ generative/maisi/scripts/utils.py | 44 + 4 files changed, 1012 insertions(+), 3 deletions(-) create mode 100644 generative/maisi/configs/environment_maisi_vae_train.json create mode 100644 generative/maisi/maisi_train_vae_tutorial.ipynb diff --git a/generative/maisi/configs/config_maisi_vae_train.json b/generative/maisi/configs/config_maisi_vae_train.json index 2e3b18d461..9699398b35 100644 --- a/generative/maisi/configs/config_maisi_vae_train.json +++ b/generative/maisi/configs/config_maisi_vae_train.json @@ -7,10 +7,10 @@ }, "autoencoder_train": { "batch_size": 1, - "patch_size": [128,128,128], + "patch_size": [64, 64, 64], "val_batch_size": 1, "val_patch_size": null, - "val_sliding_window_patch_size": [192,192,128], + "val_sliding_window_patch_size": [96, 96, 64], "lr": 1e-4, "perceptual_weight": 0.3, "kl_weight": 1e-7, @@ -19,6 +19,6 @@ "val_interval": 10, "cache": 0.5, "amp": true, - "n_epochs": 12000 + "n_epochs": 2 } } diff --git a/generative/maisi/configs/environment_maisi_vae_train.json b/generative/maisi/configs/environment_maisi_vae_train.json new file mode 100644 index 0000000000..02f9235870 --- /dev/null +++ b/generative/maisi/configs/environment_maisi_vae_train.json @@ -0,0 +1,4 @@ +{ + "model_dir": "./models/", + "tfevent_path": "./outputs/tfevent" +} diff --git a/generative/maisi/maisi_train_vae_tutorial.ipynb b/generative/maisi/maisi_train_vae_tutorial.ipynb new file mode 100644 index 0000000000..b9cb1facd8 --- /dev/null +++ b/generative/maisi/maisi_train_vae_tutorial.ipynb @@ -0,0 +1,961 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "6286986e", + "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", + "# MAISI VAE Training Tutorial\n", + "\n", + "This tutorial illustrates how to train the VAE model in MAISI on CT and MRI datasets. The VAE model is used for latent feature compression, which significantly reduce the memory usage of the diffusion model. The released VAE model weights can work on both CT and MRI images.\n", + "\n", + "## Setup environment\n", + "\n", + "To run this tutorial, please install `xformers` by following the [official guide](https://github.com/facebookresearch/xformers#installing-xformers) " + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "f96b6f31", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.2.3\n" + ] + } + ], + "source": [ + "!python -c \"import monai\" || pip install -q \"monai-weekly[nibabel, tqdm]\"\n", + "# TODO: remove print statement after generative dir is renamed to generation\n", + "!python -c \"import xformers\" || pip install -q xformers --index-url https://download.pytorch.org/whl/cu121\n", + "!python -c \"import generative; print(generative.__version__)\" || pip install -q \"monai-generative\"\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": 2, + "id": "67e2019e-1556-41a6-95e8-5d1a65f8b3a1", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MONAI version: 1.3.1+25.g64ea76d8\n", + "Numpy version: 1.26.4\n", + "Pytorch version: 2.3.0+cu121\n", + "MONAI flags: HAS_EXT = False, USE_COMPILED = False, USE_META_DICT = False\n", + "MONAI rev id: 64ea76d83a92b7cf7f13c8f93498d50037c3324c\n", + "MONAI __file__: /mnt/drive3/wenao/anaconda3/lib/python3.11/site-packages/monai/__init__.py\n", + "\n", + "Optional dependencies:\n", + "Pytorch Ignite version: NOT INSTALLED or UNKNOWN VERSION.\n", + "ITK version: NOT INSTALLED or UNKNOWN VERSION.\n", + "Nibabel version: 5.2.1\n", + "scikit-image version: 0.22.0\n", + "scipy version: 1.11.4\n", + "Pillow version: 10.2.0\n", + "Tensorboard version: 2.17.0\n", + "gdown version: 5.2.0\n", + "TorchVision version: 0.18.1+cu121\n", + "tqdm version: 4.65.0\n", + "lmdb version: 1.4.1\n", + "psutil version: 5.9.0\n", + "pandas version: 2.1.4\n", + "einops version: NOT INSTALLED or UNKNOWN VERSION.\n", + "transformers version: 4.41.2\n", + "mlflow version: NOT INSTALLED or UNKNOWN VERSION.\n", + "pynrrd version: NOT INSTALLED or UNKNOWN VERSION.\n", + "clearml version: NOT INSTALLED or UNKNOWN VERSION.\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 argparse\n", + "import glob\n", + "import json\n", + "import os\n", + "import tempfile\n", + "from pathlib import Path\n", + "\n", + "import torch\n", + "from generative.networks.nets import PatchDiscriminator\n", + "from monai.apps import download_and_extract\n", + "from monai.config import print_config\n", + "from monai.data import CacheDataset, DataLoader\n", + "from monai.inferers.inferer import SimpleInferer, SlidingWindowInferer\n", + "from monai.losses.adversarial_loss import PatchAdversarialLoss\n", + "from monai.losses.perceptual import PerceptualLoss\n", + "from monai.utils import set_determinism\n", + "from torch.cuda.amp import GradScaler, autocast\n", + "from torch.nn import L1Loss, MSELoss\n", + "from torch.optim import lr_scheduler\n", + "from torch.utils.tensorboard import SummaryWriter\n", + "\n", + "from scripts.transforms import VAE_Transform\n", + "from scripts.utils import KL_loss, define_instance, dynamic_infer\n", + "from scripts.utils_plot import find_label_center_loc, get_xyz_plot, show_image\n", + "\n", + "import warnings\n", + "\n", + "warnings.filterwarnings(\"ignore\")\n", + "\n", + "print_config()" + ] + }, + { + "cell_type": "markdown", + "id": "50e37a43", + "metadata": {}, + "source": [ + "## Setup data directory\n", + "You can specify a directory with the `MONAI_DATA_DIRECTORY` environment variable.\n", + "This allows you to save results and reuse downloads.\n", + "If not specified a temporary directory will be used." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "e3c12dcc", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "/tmp/tmpun1b0r48\n" + ] + } + ], + "source": [ + "directory = os.environ.get(\"MONAI_DATA_DIRECTORY\")\n", + "if directory is not None:\n", + " os.makedirs(directory, exist_ok=True)\n", + "root_dir = tempfile.mkdtemp() if directory is None else directory\n", + "print(root_dir)" + ] + }, + { + "cell_type": "markdown", + "id": "42d9719f-159b-4ecf-9689-dce848e0cf11", + "metadata": {}, + "source": [ + "## Download dataset\n", + "\n", + "This tutorial shows how to train a VAE with both CT and MRI data. We use MSD 09 Spleen segmentation and MSD 01 Brats16&17 Brain Tumor segmentation as examples. The dataset comes from http://medicaldecathlon.com/.\n", + "\n", + "This is just an example on how to build a multi-modal training dataset with both CT and MRI involved. Users can choose their own training datasets.\n", + "\n", + "For the released trained autoencoder model weights, we used CT and MRI data from [TCIA Covid 19 Chest CT](https://wiki.cancerimagingarchive.net/display/Public/CT+Images+in+COVID-19#70227107b92475d33ae7421a9b9c426f5bb7d5b3), [TCIA Colon Abdomen CT](https://wiki.cancerimagingarchive.net/pages/viewpage.action?pageId=3539213), [MSD03 Liver Abdomen CT](http://medicaldecathlon.com/), [LIDC chest CT](https://www.cancerimagingarchive.net/collection/lidc-idri/), [TCIA Stony Brook Covid Chest CT](https://www.cancerimagingarchive.net/collection/covid-19-ny-sbu/), [NLST Chest CT](https://www.cancerimagingarchive.net/collection/nlst/), [TCIA Upenn GBM Brain MR](https://wiki.cancerimagingarchive.net/pages/viewpage.action?pageId=70225642), [Aomic Brain MR](https://openneuro.org/datasets/ds003097/versions/1.2.1), [QTIM Brain MR](https://openneuro.org/datasets/ds004169/versions/1.0.7), [TCIA Acrin Chest MR](https://www.cancerimagingarchive.net/collection/acrin-contralateral-breast-mr/), [TCIA Prostate MR Below-Abdomen MR](https://wiki.cancerimagingarchive.net/pages/viewpage.action?pageId=68550661#68550661a2c52df5969d435eae49b9669bea21a6). In total, we have\n", + "- number of CT training data: 37243\n", + "- number of MRI training data: 17887\n", + "- number of CT validation data:1963\n", + "- number of MRI validation data: 940" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "ec6f0c29-1989-45c6-bd64-35682533794b", + "metadata": {}, + "outputs": [], + "source": [ + "# MSD Spleen CT data\n", + "resource = \"https://msd-for-monai.s3-us-west-2.amazonaws.com/Task09_Spleen.tar\"\n", + "md5 = \"410d4a301da4e5b2f6f86ec3ddba524e\"\n", + "\n", + "compressed_file = os.path.join(root_dir, \"Task09_Spleen.tar\")\n", + "data_path_1 = os.path.join(root_dir, \"Task09_Spleen\")\n", + "if not os.path.exists(data_path_1):\n", + " download_and_extract(resource, compressed_file, root_dir, md5)\n", + "\n", + "train_images_1 = sorted(glob.glob(os.path.join(data_path_1, \"imagesTr\", \"*.nii.gz\")))\n", + "data_dicts_1 = [{\"image\": image_name} for image_name in train_images_1]\n", + "len_train = int(0.8 * len(data_dicts_1))\n", + "train_files_1, val_files_1 = data_dicts_1[:len_train], data_dicts_1[len_train:]\n", + "\n", + "# MSD Brats MRI data\n", + "resource = \"https://msd-for-monai.s3-us-west-2.amazonaws.com/Task01_BrainTumour.tar\"\n", + "md5 = \"240a19d752f0d9e9101544901065d872\"\n", + "\n", + "compressed_file = os.path.join(root_dir, \"Task01_BrainTumour.tar\")\n", + "data_path_2 = os.path.join(root_dir, \"Task01_BrainTumour\")\n", + "if not os.path.exists(data_path_2):\n", + " download_and_extract(resource, compressed_file, root_dir, md5)\n", + "\n", + "train_images_2 = sorted(glob.glob(os.path.join(data_path_2, \"imagesTr\", \"*.nii.gz\")))\n", + "data_dicts_2 = [{\"image\": image_name} for image_name in train_images_2]\n", + "len_train = int(0.8 * len(data_dicts_2))\n", + "train_files_2, val_files_2 = data_dicts_2[:len_train], data_dicts_2[len_train:]\n", + "\n", + "# Expandable to more datasets\n", + "datasets = {\n", + " 1: {\n", + " \"data_name\": \"Dataset 1 MSD09 Spleen Abdomen CT\",\n", + " \"train_files\": train_files_1,\n", + " \"val_files\": val_files_1,\n", + " \"modality\": \"ct\",\n", + " },\n", + " 2: {\n", + " \"data_name\": \"Dataset 2 MSD01 Brats Brain MRI\",\n", + " \"train_files\": train_files_2,\n", + " \"val_files\": val_files_2,\n", + " \"modality\": \"mri\",\n", + " },\n", + "}" + ] + }, + { + "cell_type": "markdown", + "id": "5f164998-6c7d-44cd-93ee-e9d36c26ef96", + "metadata": {}, + "source": [ + "## Read in environment setting, including data directory, model directory, and output directory\n", + "\n", + "The information for data directory, model directory, and output directory are saved in `\"./configs/environment_maisi_vae_train.json\"`" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "c38b4c33", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "model_dir: ./models/\n", + "tfevent_path: ./outputs/tfevent\n", + "Trained model will be saved as ./models/autoencoder.pt and ./models/discriminator.pt.\n", + "Tensorboard event will be saved as ./outputs/tfevent/autoencoder.\n" + ] + } + ], + "source": [ + "args = argparse.Namespace()\n", + "\n", + "environment_file = \"./configs/environment_maisi_vae_train.json\"\n", + "env_dict = json.load(open(environment_file, \"r\"))\n", + "for k, v in env_dict.items():\n", + " setattr(args, k, v)\n", + " print(f\"{k}: {v}\")\n", + "\n", + "# model path\n", + "Path(args.model_dir).mkdir(parents=True, exist_ok=True)\n", + "trained_g_path = os.path.join(args.model_dir, \"autoencoder.pt\")\n", + "trained_d_path = os.path.join(args.model_dir, \"discriminator.pt\")\n", + "print(f\"Trained model will be saved as {trained_g_path} and {trained_d_path}.\")\n", + "\n", + "# initialize tensorboard writer\n", + "Path(args.tfevent_path).mkdir(parents=True, exist_ok=True)\n", + "tensorboard_path = os.path.join(args.tfevent_path, \"autoencoder\")\n", + "Path(tensorboard_path).mkdir(parents=True, exist_ok=True)\n", + "tensorboard_writer = SummaryWriter(tensorboard_path)\n", + "print(f\"Tensorboard event will be saved as {tensorboard_path}.\")" + ] + }, + { + "cell_type": "markdown", + "id": "ae98233f-6492-40ed-9ba5-7ab4ae0f8ffd", + "metadata": {}, + "source": [ + "## Read in configuration setting, including network definition, body region and anatomy to generate, etc.\n", + "\n", + "The information used for both training and inference, like network definition, is stored in `\"./configs/config_maisi.json\"`. Training and inference should use the same \"./configs/config_maisi.json\".\n", + "\n", + "The information for the training hyperparameters and data processing pparameters, like learning rate and patch size, are stored in `\"./configs/config_maisi_vae_train\"`. The provided configuration works for 16G V100 GPU. Please feel free to tune the parameters for your datasets and device.\n", + "\n", + "Dataset preprocessing:\n", + "- `\"random_aug\"`: bool, whether to add random data augmentation for training data.\n", + "- `\"spacing_type\"`: choose from `\"original\"` (no resampling involved), `\"fixed\"` (all images resampled to same voxel size), and `\"rand_zoom\"` (images randomly zoomed, valid when `\"random_aug\"` is True).\n", + "- `\"spacing\"`: None or list of three floats. If `\"spacing_type\"` is `\"fixed\"`, all the images will be interpolated to the voxel size of `\"spacing\"`.\n", + "- `\"select_channel\"`: int, if multi-channel MRI, which channel it will select.\n", + "\n", + "Training configs:\n", + "- `\"batch_size\"`: training batch size. Please consider increasing it if GPU memory is larger than 16G.\n", + "- `\"patch_size\"`: training patch size. For the released model, we first trained the autoencoder with small patch size [64,64,64], then continued training with patch size of [128,128,128].\n", + "- `\"val_patch_size\"`: Size of validation patches. If None, will use the whole volume for validation. If given, will central crop a patch for validation.\n", + "- `\"val_sliding_window_patch_size\"`: if the validation patch is too large, will use sliding window inference. Please consider increasing it if GPU memory is larger than 16G.\n", + "- `\"val_batch_size\"`: validation batch size.\n", + "- `\"perceptual_weight\"`: perceptual loss weight.\n", + "- `\"kl_weight\"`: KL loss weight, important hyper-parameter. If too large, decoder cannot recon good results from latent space. If too small, latent space will not be regularized enough for the diffusion model.\n", + "- `\"adv_weight\"`: adversavarial loss weight.\n", + "- `\"recon_loss\"`: choose from 'l1' and l2'.\n", + "- `\"val_interval\"`:int, do validation every `\"val_interval\"` epoches.\n", + "- `\"cache\"`: float between 0 and 1, dataloader cache, choose small value if CPU memory is small.\n", + "- `\"n_epochs\"`: int, number of epochs to train. Please adjust it based on the size of your datasets. We used 280 epochs for the released model on 58k data." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "533414f3-bef5-49f7-b082-f803b5e494bf", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "random_aug: True\n", + "spacing_type: rand_zoom\n", + "spacing: None\n", + "select_channel: 0\n", + "batch_size: 1\n", + "patch_size: [64, 64, 64]\n", + "val_batch_size: 1\n", + "val_patch_size: None\n", + "val_sliding_window_patch_size: [96, 96, 64]\n", + "lr: 0.0001\n", + "perceptual_weight: 0.3\n", + "kl_weight: 1e-07\n", + "adv_weight: 0.1\n", + "recon_loss: l1\n", + "val_interval: 10\n", + "cache: 0.5\n", + "amp: True\n", + "n_epochs: 2\n", + "Network definition and training hyperparameters have been loaded.\n" + ] + } + ], + "source": [ + "config_file = \"./configs/config_maisi.json\"\n", + "config_dict = json.load(open(config_file, \"r\"))\n", + "for k, v in config_dict.items():\n", + " setattr(args, k, v)\n", + "\n", + "# check the format of inference inputs\n", + "config_train_file = \"./configs/config_maisi_vae_train.json\"\n", + "config_train_dict = json.load(open(config_train_file, \"r\"))\n", + "for k, v in config_train_dict[\"data_option\"].items():\n", + " setattr(args, k, v)\n", + " print(f\"{k}: {v}\")\n", + "for k, v in config_train_dict[\"autoencoder_train\"].items():\n", + " setattr(args, k, v)\n", + " print(f\"{k}: {v}\")\n", + "\n", + "print(\"Network definition and training hyperparameters have been loaded.\")" + ] + }, + { + "cell_type": "markdown", + "id": "d22296e5", + "metadata": {}, + "source": [ + "## Set deterministic training for reproducibility" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "87ba613d-a2f5-4afc-95df-65ad21fafedd", + "metadata": {}, + "outputs": [], + "source": [ + "set_determinism(seed=0)" + ] + }, + { + "cell_type": "markdown", + "id": "9125f7c8", + "metadata": {}, + "source": [ + "## Build training dataset" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "8685da6e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Dataset 1 MSD09 Spleen Abdomen CT: number of training data is 32.\n", + "Dataset 1 MSD09 Spleen Abdomen CT: number of val data is 9.\n", + "Dataset 2 MSD01 Brats Brain MRI: number of training data is 387.\n", + "Dataset 2 MSD01 Brats Brain MRI: number of val data is 97.\n", + "Total number of training data for ct is 32.\n", + "Total number of val data for ct is 9.\n", + "Total number of training data for mri is 387.\n", + "Total number of val data for mri is 97.\n" + ] + } + ], + "source": [ + "# Initialize file lists\n", + "train_files = {\"ct\": [], \"mri\": []}\n", + "val_files = {\"ct\": [], \"mri\": []}\n", + "\n", + "\n", + "# Function to add assigned class to datalist\n", + "def add_assigned_class_to_datalist(datalist, classname):\n", + " for item in datalist:\n", + " item[\"class\"] = classname\n", + " return datalist\n", + "\n", + "\n", + "# Process datasets\n", + "for _, dataset in datasets.items():\n", + " train_files_i = dataset[\"train_files\"]\n", + " val_files_i = dataset[\"val_files\"]\n", + " print(f\"{dataset['data_name']}: number of training data is {len(train_files_i)}.\")\n", + " print(f\"{dataset['data_name']}: number of val data is {len(val_files_i)}.\")\n", + "\n", + " # attach modality to each file\n", + " modality = dataset[\"modality\"]\n", + " train_files[modality] += add_assigned_class_to_datalist(train_files_i, modality)\n", + " val_files[modality] += add_assigned_class_to_datalist(val_files_i, modality)\n", + "\n", + "# Print total numbers for each modality\n", + "for modality in train_files.keys():\n", + " print(f\"Total number of training data for {modality} is {len(train_files[modality])}.\")\n", + " print(f\"Total number of val data for {modality} is {len(val_files[modality])}.\")\n", + "\n", + "# Combine the data\n", + "train_files_combined = train_files[\"ct\"] + train_files[\"mri\"]\n", + "val_files_combined = val_files[\"ct\"] + val_files[\"mri\"]" + ] + }, + { + "cell_type": "markdown", + "id": "06d1e997-c239-463b-8905-a05de5c0afff", + "metadata": {}, + "source": [ + "## Define data transforms" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "404c314e-6998-417b-97cc-8a86cc3a9782", + "metadata": {}, + "outputs": [], + "source": [ + "train_transform = VAE_Transform(\n", + " is_train=True,\n", + " random_aug=args.random_aug, # whether apply random data augmentation for training\n", + " k=4, # patches should be divisible by k\n", + " patch_size=args.patch_size,\n", + " val_patch_size=args.val_patch_size,\n", + " output_dtype=torch.float16, # final data type\n", + " spacing_type=args.spacing_type,\n", + " spacing=args.spacing,\n", + " image_keys=[\"image\"],\n", + " label_keys=[],\n", + " additional_keys=[],\n", + " select_channel=0,\n", + ")\n", + "val_transform = VAE_Transform(\n", + " is_train=False,\n", + " random_aug=False,\n", + " k=4, # patches should be divisible by k\n", + " val_patch_size=args.val_patch_size, # if None, will validate on whole image volume\n", + " output_dtype=torch.float16, # final data type\n", + " image_keys=[\"image\"],\n", + " label_keys=[],\n", + " additional_keys=[],\n", + " select_channel=0,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "c6b67b9d-fe54-4d6f-95c3-cb84122f1e3e", + "metadata": {}, + "source": [ + "## Build data loader" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "0126468a-273b-40fc-ae18-b8c1b5302e28", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Total number of training data is 419.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Loading dataset: 100%|████████████████████| 209/209 [00:00<00:00, 939560.06it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Total number of validation data is 106.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Loading dataset: 100%|██████████████████████| 53/53 [00:00<00:00, 694681.60it/s]\n" + ] + } + ], + "source": [ + "print(f\"Total number of training data is {len(train_files_combined)}.\")\n", + "dataset_train = CacheDataset(data=train_files_combined, transform=train_transform, cache_rate=args.cache, num_workers=8)\n", + "dataloader_train = DataLoader(dataset_train, batch_size=args.batch_size, num_workers=4, shuffle=True, drop_last=True)\n", + "\n", + "print(f\"Total number of validation data is {len(val_files_combined)}.\")\n", + "dataset_val = CacheDataset(data=val_files_combined, transform=val_transform, cache_rate=args.cache, num_workers=8)\n", + "dataloader_val = DataLoader(dataset_val, batch_size=args.val_batch_size, num_workers=4, shuffle=False)" + ] + }, + { + "cell_type": "markdown", + "id": "114bb8d7-17db-48b5-8d08-d8af61fc763a", + "metadata": {}, + "source": [ + "## Visualize the data" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "e0453d9f-1614-4c84-aef1-77b6339d8c12", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Train image shape torch.Size([1, 64, 64, 64])\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Val image shape torch.Size([1, 512, 512, 36])\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "example_vis_img = dataset_train[0][\"image\"]\n", + "print(f\"Train image shape {example_vis_img.shape}\")\n", + "center_loc_axis = find_label_center_loc(example_vis_img.squeeze(0))\n", + "vis_image = get_xyz_plot(example_vis_img, center_loc_axis, mask_bool=False)\n", + "show_image(vis_image, title=\"training image\")\n", + "\n", + "example_vis_img = dataset_val[0][\"image\"]\n", + "print(f\"Val image shape {example_vis_img.shape}\")\n", + "center_loc_axis = find_label_center_loc(example_vis_img.squeeze(0))\n", + "vis_image = get_xyz_plot(example_vis_img, center_loc_axis, mask_bool=False)\n", + "show_image(vis_image, title=\"validation image\")" + ] + }, + { + "cell_type": "markdown", + "id": "02476bc7-c980-4b0b-8d7a-c780a5ccc11f", + "metadata": {}, + "source": [ + "## Initialize networks" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "d499f7b1", + "metadata": { + "lines_to_next_cell": 2 + }, + "outputs": [], + "source": [ + "device = torch.device(\"cuda\")\n", + "\n", + "args.autoencoder_def[\"num_splits\"] = 1\n", + "autoencoder = define_instance(args, \"autoencoder_def\").to(device)\n", + "discriminator_norm = \"INSTANCE\"\n", + "discriminator = PatchDiscriminator(\n", + " spatial_dims=args.spatial_dims,\n", + " num_layers_d=3,\n", + " num_channels=32,\n", + " in_channels=1,\n", + " out_channels=1,\n", + " norm=discriminator_norm,\n", + ").to(device)" + ] + }, + { + "cell_type": "markdown", + "id": "fe658ac2-6a90-40eb-89fc-7ec35a41dc4b", + "metadata": {}, + "source": [ + "## Training config" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "271f91bf-1c55-46e2-ae56-8677cd8eb81f", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Use l1 loss\n" + ] + } + ], + "source": [ + "# config loss and loss weight\n", + "if args.recon_loss == \"l2\":\n", + " intensity_loss = MSELoss()\n", + " print(\"Use l2 loss\")\n", + "else:\n", + " intensity_loss = L1Loss(reduction=\"mean\")\n", + " print(\"Use l1 loss\")\n", + "adv_loss = PatchAdversarialLoss(criterion=\"least_squares\")\n", + "\n", + "loss_perceptual = (\n", + " PerceptualLoss(spatial_dims=3, network_type=\"squeeze\", is_fake_3d=True, fake_3d_ratio=0.2).eval().to(device)\n", + ")\n", + "\n", + "# config optimizer and lr scheduler\n", + "optimizer_g = torch.optim.Adam(params=autoencoder.parameters(), lr=args.lr, eps=1e-06 if args.amp else 1e-08)\n", + "optimizer_d = torch.optim.Adam(params=discriminator.parameters(), lr=args.lr, eps=1e-06 if args.amp else 1e-08)\n", + "\n", + "\n", + "# please adjust the learning rate warmup rule based on your dataset and n_epochs\n", + "def warmup_rule(epoch):\n", + " # learning rate warmup rule\n", + " if epoch < 10:\n", + " return 0.01\n", + " elif epoch < 20:\n", + " return 0.1\n", + " else:\n", + " return 1.0\n", + "\n", + "\n", + "scheduler_g = lr_scheduler.LambdaLR(optimizer_g, lr_lambda=warmup_rule)\n", + "scheduler_d = lr_scheduler.LambdaLR(optimizer_d, lr_lambda=warmup_rule)\n", + "\n", + "# set AMP scaler\n", + "if args.amp:\n", + " # test use mean reduction for everything\n", + " scaler_g = GradScaler(init_scale=2.0**8, growth_factor=1.5)\n", + " scaler_d = GradScaler(init_scale=2.0**8, growth_factor=1.5)" + ] + }, + { + "cell_type": "markdown", + "id": "d3c00aa4-a6ee-4adc-8933-51757cb79628", + "metadata": {}, + "source": [ + "## Training" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "4c251a32-390f-46dd-a613-75b12a7884c1", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "lr: [1.0000000000000002e-06]\n", + "Epoch 0 train_vae_loss 0.5239322738493688: {'recons_loss': 0.22154318983166485, 'kl_loss': 48163.89544255295, 'p_loss': 0.9919089815781623}.\n", + "Epoch 0 val_vae_loss 0.31033217618731235: {'recons_loss': 0.06709538206879823, 'kl_loss': 115662.2734375, 'p_loss': 0.7722352225825472}.\n", + "Save trained autoencoder to ./models/autoencoder.pt\n", + "Save trained discriminator to ./models/discriminator.pt\n", + "Got best val vae loss.\n", + "Save trained autoencoder to ./models/autoencoder_epoch0.pt\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "lr: [1.0000000000000002e-06]\n", + "Epoch 1 train_vae_loss 0.35136976669327646: {'recons_loss': 0.13655436403942706, 'kl_loss': 26992.977631125075, 'p_loss': 0.707053682969123}.\n" + ] + } + ], + "source": [ + "# Initialize variables\n", + "val_interval = args.val_interval\n", + "best_val_recon_epoch_loss = 10000000.0\n", + "total_step = 0\n", + "start_epoch = 0\n", + "max_epochs = args.n_epochs\n", + "\n", + "# Setup validation inferer\n", + "val_inferer = (\n", + " SlidingWindowInferer(\n", + " roi_size=args.val_sliding_window_patch_size,\n", + " sw_batch_size=1,\n", + " progress=False,\n", + " overlap=0.0,\n", + " device=torch.device(\"cpu\"),\n", + " sw_device=device,\n", + " )\n", + " if args.val_sliding_window_patch_size\n", + " else SimpleInferer()\n", + ")\n", + "\n", + "\n", + "def loss_weighted_sum(losses):\n", + " return losses[\"recons_loss\"] + args.kl_weight * losses[\"kl_loss\"] + args.perceptual_weight * losses[\"p_loss\"]\n", + "\n", + "\n", + "# Training and validation loops\n", + "for epoch in range(start_epoch, max_epochs):\n", + " print(\"lr:\", scheduler_g.get_lr())\n", + " autoencoder.train()\n", + " discriminator.train()\n", + " train_epoch_losses = {\"recons_loss\": 0, \"kl_loss\": 0, \"p_loss\": 0}\n", + "\n", + " for batch in dataloader_train:\n", + " images = batch[\"image\"].to(device).contiguous()\n", + " optimizer_g.zero_grad(set_to_none=True)\n", + " optimizer_d.zero_grad(set_to_none=True)\n", + " with autocast(enabled=args.amp):\n", + " # Train Generator\n", + " reconstruction, z_mu, z_sigma = autoencoder(images)\n", + " losses = {\n", + " \"recons_loss\": intensity_loss(reconstruction, images),\n", + " \"kl_loss\": KL_loss(z_mu, z_sigma),\n", + " \"p_loss\": loss_perceptual(reconstruction.float(), images.float()),\n", + " }\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 = loss_weighted_sum(losses) + args.adv_weight * generator_loss\n", + "\n", + " if args.amp:\n", + " scaler_g.scale(loss_g).backward()\n", + " scaler_g.unscale_(optimizer_g)\n", + " scaler_g.step(optimizer_g)\n", + " scaler_g.update()\n", + " else:\n", + " loss_g.backward()\n", + " optimizer_g.step()\n", + "\n", + " # Train Discriminator\n", + " logits_fake = discriminator(reconstruction.contiguous().detach())[-1]\n", + " loss_d_fake = 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", + " loss_d = (loss_d_fake + loss_d_real) * 0.5\n", + "\n", + " if args.amp:\n", + " scaler_d.scale(loss_d).backward()\n", + " scaler_d.step(optimizer_d)\n", + " scaler_d.update()\n", + " else:\n", + " loss_d.backward()\n", + " optimizer_d.step()\n", + "\n", + " # Log training loss\n", + " total_step += 1\n", + " for loss_name, loss_value in losses.items():\n", + " tensorboard_writer.add_scalar(f\"train_{loss_name}_iter\", loss_value.item(), total_step)\n", + " train_epoch_losses[loss_name] += loss_value.item()\n", + " tensorboard_writer.add_scalar(\"train_adv_loss_iter\", generator_loss, total_step)\n", + " tensorboard_writer.add_scalar(\"train_fake_loss_iter\", loss_d_fake, total_step)\n", + " tensorboard_writer.add_scalar(\"train_real_loss_iter\", loss_d_real, total_step)\n", + "\n", + " scheduler_g.step()\n", + " scheduler_d.step()\n", + " for key in train_epoch_losses:\n", + " train_epoch_losses[key] /= len(dataloader_train)\n", + " print(f\"Epoch {epoch} train_vae_loss {loss_weighted_sum(train_epoch_losses)}: {train_epoch_losses}.\")\n", + " for loss_name, loss_value in train_epoch_losses.items():\n", + " tensorboard_writer.add_scalar(f\"train_{loss_name}_epoch\", loss_value, epoch)\n", + "\n", + " # Validation\n", + " if epoch % val_interval == 0:\n", + " autoencoder.eval()\n", + " val_epoch_losses = {\"recons_loss\": 0, \"kl_loss\": 0, \"p_loss\": 0}\n", + " val_loader_iter = iter(dataloader_val)\n", + " for batch in dataloader_val:\n", + " with torch.no_grad():\n", + " with autocast(enabled=args.amp):\n", + " images = batch[\"image\"]\n", + " reconstruction, _, _ = dynamic_infer(val_inferer, autoencoder, images)\n", + " reconstruction = reconstruction.to(device)\n", + " val_epoch_losses[\"recons_loss\"] += intensity_loss(reconstruction, images.to(device)).item()\n", + " val_epoch_losses[\"kl_loss\"] += KL_loss(z_mu, z_sigma).item()\n", + " val_epoch_losses[\"p_loss\"] += loss_perceptual(reconstruction, images.to(device)).item()\n", + "\n", + " for key in val_epoch_losses:\n", + " val_epoch_losses[key] /= len(dataloader_val)\n", + "\n", + " torch.save(autoencoder.state_dict(), trained_g_path)\n", + " torch.save(discriminator.state_dict(), trained_d_path)\n", + " val_loss_g = loss_weighted_sum(val_epoch_losses)\n", + " print(f\"Epoch {epoch} val_vae_loss {val_loss_g}: {val_epoch_losses}.\")\n", + " print(\"Save trained autoencoder to\", trained_g_path)\n", + " print(\"Save trained discriminator to\", trained_d_path)\n", + "\n", + " if val_loss_g < best_val_recon_epoch_loss:\n", + " best_val_recon_epoch_loss = val_loss_g\n", + " trained_g_path_epoch = f\"{trained_g_path[:-3]}_epoch{epoch}.pt\"\n", + " torch.save(autoencoder.state_dict(), trained_g_path_epoch)\n", + " print(\"Got best val vae loss.\")\n", + " print(\"Save trained autoencoder to\", trained_g_path_epoch)\n", + "\n", + " for loss_name, loss_value in val_epoch_losses.items():\n", + " tensorboard_writer.add_scalar(loss_name, loss_value, epoch)\n", + "\n", + " # Monitor scale_factor\n", + " # We'd like to tune kl_weights in order to make scale_factor close to 1.\n", + " scale_factor_sample = 1.0 / z_mu.flatten().std()\n", + " tensorboard_writer.add_scalar(\"val_one_sample_scale_factor\", scale_factor_sample, epoch)\n", + "\n", + " # Monitor reconstruction result\n", + " center_loc_axis = find_label_center_loc(images[0, 0, ...])\n", + " vis_image = get_xyz_plot(images[0, ...], center_loc_axis, mask_bool=False)\n", + " vis_recon_image = get_xyz_plot(reconstruction[0, ...], center_loc_axis, mask_bool=False)\n", + "\n", + " tensorboard_writer.add_image(\n", + " \"val_orig_img\",\n", + " vis_image.transpose([2, 0, 1]),\n", + " epoch,\n", + " )\n", + " tensorboard_writer.add_image(\n", + " \"val_recon_img\",\n", + " vis_recon_image.transpose([2, 0, 1]),\n", + " epoch,\n", + " )\n", + "\n", + " show_image(vis_image, title=\"val image\")\n", + " show_image(vis_recon_image, title=\"val recon result\")" + ] + } + ], + "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.7" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/generative/maisi/scripts/utils.py b/generative/maisi/scripts/utils.py index e6ed794d5d..7600a3cdb1 100644 --- a/generative/maisi/scripts/utils.py +++ b/generative/maisi/scripts/utils.py @@ -11,6 +11,7 @@ import copy import json +import math import os from argparse import Namespace from datetime import timedelta @@ -701,3 +702,46 @@ def load_autoencoder_ckpt(load_autoencoder_path): new_state_dict[k] = v checkpoint_autoencoder = new_state_dict return checkpoint_autoencoder + + +def KL_loss(z_mu, z_sigma): + """ + Compute the Kullback-Leibler (KL) divergence loss for a variational autoencoder (VAE). + + The KL divergence measures how one probability distribution diverges from a second, expected probability distribution. + In the context of VAEs, this loss term ensures that the learned latent space distribution is close to a standard normal distribution. + + Args: + z_mu (torch.Tensor): Mean of the latent variable distribution, shape [N,C,H,W,D] or [N,C,H,W]. + z_sigma (torch.Tensor): Standard deviation of the latent variable distribution, same shape as 'z_mu'. + + Returns: + torch.Tensor: The computed KL divergence loss, averaged over the batch. + """ + eps = 1e-10 + kl_loss = 0.5 * torch.sum( + z_mu.pow(2) + z_sigma.pow(2) - torch.log(z_sigma.pow(2) + eps) - 1, + dim=list(range(1, len(z_sigma.shape))), + ) + return torch.sum(kl_loss) / kl_loss.shape[0] + + +def dynamic_infer(inferer, model, images): + """ + Perform dynamic inference using a model and an inferer, typically a monai SlidingWindowInferer. + + This function determines whether to use the model directly or to use the provided inferer + (such as a sliding window inferer) based on the size of the input images. + + Args: + inferer: An inference object, typically a monai SlidingWindowInferer, which handles patch-based inference. + model (torch.nn.Module): The model used for inference. + images (torch.Tensor): The input images for inference, shape [N,C,H,W,D] or [N,C,H,W]. + + Returns: + torch.Tensor: The output from the model or the inferer, depending on the input size. + """ + if torch.numel(images[0:1, 0:1, ...]) < math.prod(inferer.roi_size): + return model(images) + else: + return inferer(network=model, inputs=images)