From edea9a9608adec73f3502406ae75b2d90e9c89ad Mon Sep 17 00:00:00 2001 From: rayanirban Date: Wed, 22 Nov 2023 11:12:49 +0100 Subject: [PATCH] first merge with juglab HDN --- .gitignore | 18 ++ boilerplate/boilerplate.py | 180 +++++++++-- boilerplate/dataset.py | 176 +++++++++++ data.py | 42 +++ inference.ipynb | 508 ++++++++++++++++++++++++++++++ inference.py | 88 ++++++ lib/gaussianMixtureNoiseModel.py | 8 +- lib/likelihoods.py | 175 +++++++---- lib/nn.py | 76 +++-- lib/stochastic.py | 180 ++++++++++- lib/utils.py | 90 ++++-- model.py | 393 +++++++++++++++++++++++ models/lvae.py | 276 +++++++++++----- models/lvae_layers.py | 129 +++++--- psnrs.ipynb | 190 +++++++++++ ra_psnr.py | 81 +++++ training.py | 521 +++++++++++++++++++++---------- 17 files changed, 2665 insertions(+), 466 deletions(-) create mode 100644 .gitignore create mode 100644 boilerplate/dataset.py create mode 100644 data.py create mode 100644 inference.ipynb create mode 100644 inference.py create mode 100644 model.py create mode 100644 psnrs.ipynb create mode 100644 ra_psnr.py diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..8441c90 --- /dev/null +++ b/.gitignore @@ -0,0 +1,18 @@ +checkpoints*/ +data/ +wandb/ +__pycache__ +hpc* +*.pt +root*/ +results*_ +*.png +*.tif +*.tiff +*.sbatch +*.npy +Trained_model/ +*.out +Trained_Models/* +*.sbatch +sbatches_logs/* \ No newline at end of file diff --git a/boilerplate/boilerplate.py b/boilerplate/boilerplate.py index dd9482d..1fba095 100644 --- a/boilerplate/boilerplate.py +++ b/boilerplate/boilerplate.py @@ -9,6 +9,7 @@ from torchvision.utils import save_image from torch.nn import init from torch.optim.optimizer import Optimizer +from torch.cuda.amp import autocast import os import glob import random @@ -19,6 +20,7 @@ from models.lvae import LadderVAE import lib.utils as utils + def _make_datamanager(train_images, val_images, test_images, batch_size, test_batch_size): """Create data loaders for training, validation and test sets during training. @@ -51,6 +53,8 @@ def _make_datamanager(train_images, val_images, test_images, batch_size, test_ba train_images = torch.from_numpy(train_images) train_labels = torch.zeros(len(train_images),).fill_(float('nan')) train_set = TensorDataset(train_images, train_labels) + + # TODO add normal dataloader val_images = (val_images-data_mean)/data_std val_images = torch.from_numpy(val_images) @@ -69,6 +73,7 @@ def _make_datamanager(train_images, val_images, test_images, batch_size, test_ba return train_loader, val_loader, test_loader, data_mean, data_std + def _make_optimizer_and_scheduler(model, lr, weight_decay) -> Optimizer: """ Implements Adamax optimizer and learning rate scheduler. @@ -88,23 +93,29 @@ def _make_optimizer_and_scheduler(model, lr, weight_decay) -> Optimizer: verbose=True) return optimizer, scheduler -def forward_pass(x, y, device, model, gaussian_noise_std)-> dict: + +def forward_pass(x, y, device, model, gaussian_noise_std, amp=True, stochasticity=True)-> dict: x = x.to(device, non_blocking=True) - model_out = model(x) + y = y.to(device, non_blocking=True) + with autocast(enabled=amp): + model_out = model(x,y) + if model.mode_pred is False: - recons_sep = -model_out['ll'] + + recons_sep = -model_out['ll'] # negative log likelihood kl_sep = model_out['kl_sep'] kl = model_out['kl'] - kl_loss = model_out['kl_loss']/float(x.shape[2]*x.shape[3]) - - if gaussian_noise_std is None: - recons_loss = recons_sep.mean() + if stochasticity == True: + kl_loss = model_out['kl_loss']/float(x.shape[2]*x.shape[3]) else: - recons_loss = recons_sep.mean()/ ((gaussian_noise_std/model.data_std)**2) - - + kl_loss = None + recons_loss = recons_sep.mean() + output = { + 'top_bu': model_out['top_bu'], + 'z': model_out['z'], + 'out_img': model_out['out_sample'], 'recons_loss': recons_loss, 'kl_loss': kl_loss, 'out_mean': model_out['out_mean'], @@ -113,6 +124,9 @@ def forward_pass(x, y, device, model, gaussian_noise_std)-> dict: else: output = { + 'top_bu': model_out['top_bu'], + 'z': model_out['z'], + 'out_img': model_out['out_sample'], 'recons_loss': None, 'kl_loss': None, 'out_mean': model_out['out_mean'], @@ -124,6 +138,7 @@ def forward_pass(x, y, device, model, gaussian_noise_std)-> dict: return output + def img_grid_pad_value(imgs, thresh = .2) -> float: """Returns padding value (black or white) for a grid of images. Hack to visualize boundaries between images with torchvision's @@ -135,7 +150,6 @@ def img_grid_pad_value(imgs, thresh = .2) -> float: Returns: pad_value (float): The padding value """ - assert imgs.dim() == 4 imgs = imgs.clamp(min=0., max=1.) assert 0. < thresh < 1. @@ -153,6 +167,7 @@ def img_grid_pad_value(imgs, thresh = .2) -> float: return 1.0 return 0.0 + def save_image_grid(images,filename,nrows): """Saves images on disk. Args: @@ -163,7 +178,8 @@ def save_image_grid(images,filename,nrows): pad = img_grid_pad_value(images) save_image(images, filename, nrow=nrows, pad_value=pad, normalize=True) -def generate_and_save_samples(model, filename, nrows = 4) -> None: + +def generate_and_save_samples(model, filename, nrows=4, amp=True) -> None: """Save generated images at intermediate training steps. Args: model: instance of LadderVAE class @@ -171,20 +187,27 @@ def generate_and_save_samples(model, filename, nrows = 4) -> None: nrows (int): Number of rows in which to arrange denoised/generated images. """ - samples = model.sample_prior(nrows**2) + with autocast(enabled=amp): + samples = model.sample_prior(nrows**2) + if samples.dim() == 5: + samples = samples[0, ...].permute(1, 0, 2, 3) save_image_grid(samples, filename, nrows=nrows) return samples + def save_image_grid_reconstructions(inputs,recons,filename): assert inputs.shape == recons.shape n_img = inputs.shape[0] n = int(np.sqrt(2 * n_img)) imgs = torch.stack([inputs.cpu(), recons.cpu()]) - imgs = imgs.permute(1, 0, 2, 3, 4) - imgs = imgs.reshape(n**2, inputs.size(1), inputs.size(2), inputs.size(3)) + imgs = imgs.permute(1, 0, *list(range(2, imgs.dim()))) + imgs = imgs.reshape(n**2, *inputs.shape[1:]) + if imgs.dim() == 5: + imgs = imgs[0, ...].permute(1, 0, 2, 3) save_image_grid(imgs, filename, nrows=n) -def generate_and_save_reconstructions(x,filename,device,model,gaussian_noise_std,data_std,nrows) -> None: + +def generate_and_save_reconstructions(x,filename,device,model,gaussian_noise_std,data_std,nrows, amp=True) -> None: """Save denoised images at intermediate training steps. Args: x (Torch.tensor): Batch of images from test set @@ -197,13 +220,14 @@ def generate_and_save_reconstructions(x,filename,device,model,gaussian_noise_std """ n_img = nrows**2 // 2 - if x.shape[0] < n_img: + #print(x.shape) + if x.shape[2] < n_img: msg = ("{} data points required, but given batch has size {}. " "Please use a larger batch.".format(n_img, x.shape[0])) raise RuntimeError(msg) - x = x.to(device) - - outputs = forward_pass(x, x, device, model, gaussian_noise_std) + # x = x.to(device) + + outputs = forward_pass(x, x, device, model, gaussian_noise_std, amp=amp) # Try to get reconstruction from different sources in order recons = None @@ -221,13 +245,15 @@ def generate_and_save_reconstructions(x,filename,device,model,gaussian_noise_std raise RuntimeError(msg) # Pick required number of images + x = x[:n_img] recons = recons[:n_img] # Save inputs and reconstructions in a grid save_image_grid_reconstructions(x, recons, filename) -def save_images(img_folder, device, model, test_loader, gaussian_noise_std, data_std, nrows) -> None: + +def save_images(img_folder, device, model, test_loader, gaussian_noise_std, data_std, nrows, amp=True) -> None: """Save generated images and denoised images at intermediate training steps. Args: img_folder (str): Folder where to save images @@ -246,15 +272,18 @@ def save_images(img_folder, device, model, test_loader, gaussian_noise_std, dat generate_and_save_samples(model, fname, nrows) # Get first test batch - (x, _) = next(iter(test_loader)) + x = next(iter(test_loader)) x = x.unsqueeze(1) + x = x.to(device=device, dtype=torch.float) + # Save model original/reconstructions fname = os.path.join(img_folder, 'reconstruction_' + str(step) + '.png') - generate_and_save_reconstructions(x, fname, device, model, gaussian_noise_std, data_std, nrows) + generate_and_save_reconstructions(x, fname, device, model, gaussian_noise_std, data_std, nrows, amp) -def _test(epoch, img_folder, device, model, test_loader, gaussian_noise_std, data_std, nrows): + +def _test(epoch, img_folder, device, model, test_loader, gaussian_noise_std, data_std, nrows, amp=True): """Perform a test step at intermediate training steps. Args: epoch (int): Current training epoch @@ -270,7 +299,7 @@ def _test(epoch, img_folder, device, model, test_loader, gaussian_noise_std, da # Evaluation mode model.eval() # Save images - save_images(img_folder, device, model, test_loader, gaussian_noise_std, data_std, nrows) + save_images(img_folder, device, model, test_loader, gaussian_noise_std, data_std, nrows, amp) def get_normalized_tensor(img,model,device): @@ -290,6 +319,75 @@ def get_normalized_tensor(img,model,device): return test_images +def predcit_tiled(img, model, device, patch_size, overlap=0, num_samples=10, tta=False, gaussian_noise_std=None) -> np.ndarray: + """ + Predicts image using tiled prediction. + Parameters + ---------- + img: array of shape (H,W) or (Z,H,W) + Image to predict. + model: Hierarchical DivNoising model + device: GPU device. + img_width: int + Width of image tiles. + overlap: int + Overlap between tiles. + num_samples: int + Number of samples to use for prediction. + tta: bool + Whether to use test time augmentation. + gaussian_noise_std: float + std of Gaussian noise used to corrupt the data. For intrinsically noisy data, set to None. + """ + + #TODO: refactor/rewrite ? + + assert patch_size > overlap, f'Patch size {patch_size} must be larger than overlap {overlap}.' + + zmin = 0 + xmin = 0 + ymin = 0 + zmax = patch_size[0] + xmax = patch_size[1] + ymax = patch_size[2] + ovLeft = 0 + pred = np.zeros(img.shape) + coords = [] + + while xmin < img.shape[1]: + ovTop = 0 + while ymin < img.shape[0]: + ymin_ = min(img.shape[0], ymax) - patch_size + xmin_ = min(img.shape[1], xmax) - patch_size + lastPatchShiftY = ymin - ymin_ + lastPatchShiftX = xmin - xmin_ + if ((ymin_, ymax), (xmin_, xmax)) not in coords: + coords.append(((ymin_, ymax), (xmin_, xmax))) + img_mmse, samples = boilerplate.predict(img[ymin_:ymax,xmin_:xmax], + num_samples, + model, + gaussian_noise_std, + device, + tta) + + # preticted_tile = img_mmse[lastPatchShiftY:,lastPatchShiftX:][ovTop:,ovLeft:] + pred[ymin:ymax,xmin:xmax][ovTop:,ovLeft:] = img_mmse[lastPatchShiftY:,lastPatchShiftX:][ovTop:,ovLeft:] + + ymin = ymin-overlap + patch_size + ymax = min(img.shape[0], ymin + patch_size) + ovTop = overlap//2 + + ymin = 0 + ymax = patch_size + xmin = xmin-overlap + patch_size + xmax = min(img.shape[1], xmin + patch_size) + ovLeft = overlap//2 + + + + return pred + + def predict_sample(img, model, gaussian_noise_std, device): """ Predicts a sample. @@ -299,7 +397,7 @@ def predict_sample(img, model, gaussian_noise_std, device): Image for which denoised MMSE estimate needs to be computed. model: Ladder VAE object Hierarchical DivNoising model. - gaussian_noise_std: float + gaussian_noise_std: float std of Gaussian noise used to corrupty data. For intrinsically noisy data, set to None. device: GPU device """ @@ -326,13 +424,12 @@ def predict_mmse(img_n, num_samples, model, gaussian_noise_std, device, return_s std of Gaussian noise used to corrupty data. For intrinsically noisy data, set to None. device: GPU device """ - img_height,img_width=img_n.shape[0],img_n.shape[1] img_t = get_normalized_tensor(img_n,model,device) - image_sample = img_t.view(1,1,img_height,img_width) + image_sample = img_t.view(1, 1, *img_n.shape) image_sample = image_sample.to(device=device, dtype=torch.float) samples = [] - for j in tqdm(range(num_samples)): + for j in range(num_samples): sample = predict_sample(image_sample, model, gaussian_noise_std, device=device) samples.append(np.squeeze(sample)) @@ -424,7 +521,7 @@ def generate_arbitrary_sized_samples(sample_shape, num_samples, model, save_path torch.set_grad_enabled(False) n = num_samples model.eval() - orig_model_img_shape = model.img_shape + orig_model_img_shape = (128,128) #model.img_shape fname = os.path.join(save_path, "samples_"+str(sample_shape[0])+"x"+str(sample_shape[1])+".png") if sample_shape[0] None: + """ + Parameters + ---------- + data_path : List[str] + List of filenames to read image data from. + patch_size : Tuple[int] + The size of the patch to extract from the image. Must be a tuple of len either 2 or 3 depending on number of spatial dimension in the data. + patch_iter : Union[np.ndarray, Callable] + converts an input image (item from dataset) into a iterable of image patches. + `patch_iter(dataset[idx])` must yield a tuple: (patches, coordinates). + image_level_transform : Optional[Callable], optional + _description_, by default None + patch_level_transform : Optional[Callable], optional + _description_, by default None + """ + # super().__init__(data=data, transform=None) + self.data = data_path + self.patch_size = patch_size + self.patch_iter = patch_iter + self.image_transform = image_level_transform + self.patch_transform = patch_level_transform + + #Assert input data + assert isinstance(data_path, list), f'Incorrect patch_size. Must be a tuple, given{type(data_path)}' + assert len(data_path) > 0, 'Data source is empty' + + #Assert patch_size + assert isinstance(patch_size, tuple), f'Incorrect patch_size. Must be a tuple, given{type(patch_size)}' + assert len(patch_size) in (2, 3), f'Incorrect patch_size. Must be a 2 or 3, given{len(patch_size)}' + + @staticmethod + def read_data_source(self, data_source: str): + """ + Read data source and correct dimensions + + Parameters + ---------- + data_source : str + Path to data source + + Returns + ------- + image volume : np.ndarray + """ + + if not os.path.exists(data_source): + raise ValueError(f"Data source {data_source} does not exist") + + arr = tifffile.imread(data_source) + # Assert data dimensions are correct + assert len(arr.shape) in (2, 3, 4), f'Incorrect data dimensions. Must be 2, 3 or 4, given {arr.shape} for file {data_source}' + + # Adding channel dimension if necessary. If present, check correctness + if len(arr.shape) == 2 or (len(arr.shape) == 3 and len(self.patch_size) == 3): + arr = np.expand_dims(arr, axis=0) + elif len(arr.shape) == 3 and len(self.patch_size) == 2 and arr.shape[0] > 4: + raise ValueError(f'Incorrect number of channels {arr.shape[0]}') + elif len(arr.shape) > 3 and len(self.patch_size) == 2: + raise ValueError(f'Incorrect data dimensions {arr.shape} for given dimensionality {len(self.patch_size)}D in file {data_source}') + #TODO add other asserts + return arr + + + def __iter_source__(self): + """ + Iterate over data source and yield whole image. Optional transform is applied to the images. + + Yields + ------ + np.ndarray + """ + info = torch.utils.data.get_worker_info() + num_workers = info.num_workers if info is not None else 1 + id = info.id if info is not None else 0 + self.source = iter(self.data) + #TODO check for mem leaks, explicitly gc the arr after iterator is exhausted + for i, filename in enumerate(self.source): + try: + arr = self.read_data_source(self, filename) + except (ValueError, FileNotFoundError, OSError) as e: + logging.exception(f'Exception in file {filename}, skipping') + raise e + if i % num_workers == id: + yield self.image_transform(arr) if self.image_transform is not None else arr + + def __iter__(self): + """ + Iterate over data source and yield single patch. Optional transform is applied to the patches. + + Yields + ------ + np.ndarray + """ + for image in self.__iter_source__(): + for patch in self.patch_iter(image, self.patch_size): + #TODO add patch manip n2v + yield self.patch_transform(patch) if self.patch_transform is not None else patch + + diff --git a/data.py b/data.py new file mode 100644 index 0000000..3c582a9 --- /dev/null +++ b/data.py @@ -0,0 +1,42 @@ +import math +import copy +import torch +from torch import nn, einsum +import torch.nn.functional as F +from inspect import isfunction +from functools import partial + +from torch.utils import data +from pathlib import Path +from torch.optim import Adam +from torchvision import transforms, utils + +import numpy as np +from tqdm import tqdm +import glob +import os +from PIL import Image +from tifffile import imsave, imread +import matplotlib.pyplot as plt + +class Dataset(data.Dataset): + def __init__(self, folder, image_size, exts = ['jpg', 'jpeg', 'png', 'tif', 'tiff', 'bmp']): + super().__init__() + self.folder = folder + self.image_size = image_size + self.paths = [p for ext in exts for p in Path(f'{folder}').glob(f'**/*.{ext}')] + self.transform = transforms.Compose( + [transforms.RandomCrop(image_size)]) + + def __len__(self): + return len(self.paths) # returns the number of images in the dataset + + def __getitem__(self, index): + + path = self.paths[index] + img = imread(path) + img = torch.from_numpy(img.copy()) + random = np.random.randint(1, 7) + img = img[(0, random),...] #only take the first (target) and 7th channel (input) + return img + diff --git a/inference.ipynb b/inference.ipynb new file mode 100644 index 0000000..497029f --- /dev/null +++ b/inference.ipynb @@ -0,0 +1,508 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Make the LVAE model" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import glob\n", + "import random\n", + "import math\n", + "import time\n", + "import datetime\n", + "import torch.nn as nn\n", + "import torch.nn.functional as F\n", + "import torch.optim as optim\n", + "from torch.utils.data import TensorDataset\n", + "from torch.utils.data import Dataset, DataLoader\n", + "from torchvision.utils import save_image\n", + "from torch.nn import init\n", + "from torch.optim.optimizer import Optimizer\n", + "from torch.cuda.amp import GradScaler\n", + "from tqdm import tqdm\n", + "from boilerplate import boilerplate\n", + "from models.lvae import LadderVAE\n", + "import lib.utils as utils\n", + "import sys" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "LVAE Trained Model loaded\n" + ] + } + ], + "source": [ + "\n", + "import numpy as np\n", + "import torch\n", + "from tifffile import imread\n", + "from matplotlib import pyplot as plt\n", + "import warnings\n", + "warnings.filterwarnings('ignore')\n", + "# We import all our dependencies.\n", + "import numpy as np\n", + "from tifffile import imread\n", + "from matplotlib import pyplot as plt\n", + "\n", + "use_cuda = torch.cuda.is_available()\n", + "device = torch.device(\"cuda\" if use_cuda else \"cpu\")\n", + "\n", + "model_LVAE = torch.load(\"./Trained_Models/NL[5]zD[32]bpl[3]len_nF[6]lh[GaussianLikelihood_HDN]Stoc[True]lvClip[None]_lvtp[None]_DO_[True]_BN_[True]/model/TalleyLines_best_vae.net\")\n", + "model_LVAE.mode_pred=True\n", + "model_LVAE.stochastic=False\n", + "model_LVAE.dropout=0.0\n", + "model_LVAE.batchnorm=False\n", + "model_LVAE.eval()\n", + "print(\"LVAE Trained Model loaded\")" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Make the Diffusion Model" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### From the Test Image set get the latents using LVAE" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'Image T=7 Input')" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from tifffile import imread\n", + "path = \"/group/jug/Anirban/Datasets/TalleySim_1024/test/confocal_au_3000.tif\"\n", + "signal = imread(path)[7:8,...].astype(\"float32\")\n", + "image_0 = imread(path)[0:1,...].astype(\"float32\")\n", + "#plot gt and signal in the same figure\n", + "plt.figure(figsize=(15,15))\n", + "plt.subplot(1,2,1)\n", + "plt.imshow(image_0[0,...],cmap=\"magma\")\n", + "plt.title(\"Image T=0 GT\")\n", + "plt.subplot(1,2,2)\n", + "plt.imshow(signal[0,...],cmap=\"magma\")\n", + "plt.title(\"Image T=7 Input\")" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'Image T=7 Input')" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA0cAAAHDCAYAAADvBGFkAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAABGAElEQVR4nO3de1iUdf7/8RcHGfAwg5gwkmiU5SkPiYZTaWokGlYmbVmmVprZopu65aH84qFWW81DKuWWFdXiau6VVlIqaWolnig21HI1LWx10E1h1BQQ7t8f/bjXyRPD+fB8XNd9Xcz9ed/3fD6o8/E198nLMAxDAAAAAFDLeVd2BwAAAACgKiAcAQAAAIAIRwAAAAAgiXAEAAAAAJIIRwAAAAAgiXAEAAAAAJIIRwAAAAAgiXAEAAAAAJIIRwAAAAAgiXAEAAAAAJIIR6hmEhMT5eXlpZ07d1Z2V8pFjx495OXldcVl6tSppX6vjz76SJ06dZK/v7+aNWumKVOm6Ny5c8Xe/ujRo5o4caLatWun+vXry9/fXy1atNBjjz2mL7/8UpL06KOPFms8jz76aKnHAwBljTmn9HPOxo0bL7vvv/zlL8Xa/p///GeJ+1DWZsyYoVWrVlV2N1BOfCu7AwD+5/nnn9fw4cPN1zt27NCCBQv03HPPqXXr1ub69u3bl+p9Pv30U/Xv3189evTQwoULlZGRoRdffFFHjx7Va6+9dsXtt2/frpiYGJ08eVIDBw7UyJEjZbFYdPDgQa1atUqJiYnatGmTnnzySUVFRZnbHTx4UPHx8RoxYoS6detmrr/uuutKNR4AgOcqYs5p3bq13nvvvQvWv/fee1q3bp169+5d4n1XlhkzZuj+++9X//79K7srKAeEI6AKufPOO91e+/v7a8GCBbrzzjvVo0ePMnufZ555Ru3bt9e6devk6/vbx4DVatWMGTP09NNPq1WrVpfc9sSJE+rfv798fX2Vnp5+Qe2LL76oZcuWKSAgQF26dJHD4TDbdu7cqfj4eDkcDj3yyCNlNh4AgOcqYs4JCQm56Of9tGnTdP3116tLly5l8j5AWeG0OlR7jz76qOrXr6/MzEz169dP9evX19VXX62EhARJUkZGhnr16qV69eqpefPmWrp0qdv2x48f1zPPPGOeHma1WtW3b1/961//uuC9fvrpJ91zzz2qV6+egoODNXbsWK1du1ZeXl7auHGjW+22bdvUp08f2Ww21a1bV7fffru++uqrcvs9FNeePXu0Z88ejRgxwgxGkvTHP/5RhmFc8dSFxYsX68iRI5o/f/5FQ5SXl5ceeughJjwANRJzTult375d+/fv16BBg0q0/dSpU+Xl5aX9+/fr0UcfVWBgoGw2mx577DH9+uuvbrVeXl4aNWqUkpKS1LJlS/n7+ysiIkKbN292q3v00Ud1zTXXXPK9zt/f6dOn9c4773BqeA3FkSPUCAUFBerbt6+6d++uWbNmKSkpSaNGjVK9evX0/PPPa9CgQRowYIAWL16sIUOGyOFwKDw8XJJ04MABrVq1Sn/4wx8UHh6urKws/e1vf9Ptt9+uPXv2KDQ0VJJ0+vRp9erVS0eOHNHTTz8tu92upUuX6vPPP7+gPxs2bFDfvn0VERGhKVOmyNvbW2+//bZ69eqlL774QjfffHOZjDsnJ0f5+flXrPP391f9+vUlSd98840kqXPnzm41oaGhatq0qdl+KR9//LECAgI0YMCAEvYaAKo35pzLO3/OuZikpCRJKnE4KvLAAw8oPDxcM2fO1Ndff60lS5YoODhYf/3rX93qNm3apOXLl+tPf/qTLBaLXn31VfXp00fbt2/XjTfe6NF7vvfeexo+fLhuvvlmjRgxQhKnhtc4BlCNvP3224YkY8eOHea6oUOHGpKMGTNmmOtOnDhhBAQEGF5eXsayZcvM9d9//70hyZgyZYq57uzZs0ZBQYHb+xw8eNCwWCzG9OnTzXVz5swxJBmrVq0y1505c8Zo1aqVIcn4/PPPDcMwjMLCQuP66683oqOjjcLCQrP2119/NcLDw40777yz2ONdsWKF275/7/bbbzckXXEZOnSouc3s2bMNSUZmZuYF++vSpYvRtWvXy/apYcOGRseOHS9Y73K5jGPHjpnLqVOnLqjZsWOHIcl4++23L/seAFAVMOe4K8mc83vnzp0zQkJCjJtvvrlYffr8888NScaKFSvMdVOmTDEkGY8//rhb7X333Wc0atTIbV1Rn3bu3Gmu++mnnwx/f3/jvvvuM9cNHTrUaN68+QXvX/Re56tXr95lx4jqjSNHqDHOv6g0MDBQLVu21P79+/XAAw+Y61u2bKnAwEAdOHDAXGexWMyfCwoKlJ2drfr166tly5b6+uuvzbY1a9bo6quv1j333GOu8/f31xNPPKE///nP5rr09HTt27dPkydP1i+//OLWxzvuuEPvvfeeCgsL5e1d+rNa58yZoxMnTlyxruibSEk6c+aMJPdxF/H395fL5brsvlwu10W/ERw8eLA+/PBD83VcXJwWLVp0xb4BQHXEnHNp5885v7d+/XplZWXpueeeK3V/Ro4c6fa6W7duWrlypVwul6xWq7ne4XAoIiLCfN2sWTPde++9+vjjj1VQUCAfH59S9wU1B+EINYK/v78aN27sts5ms6lp06Zu5woXrT//w72wsFCvvPKKXn31VR08eFAFBQVmW6NGjcyff/rpJ1133XUX7K9FixZur/ft2ydJGjp06CX7m5OTo4YNGxZzdJd2/od9cQUEBEiScnNzL2g7e/as2X4pDRo00KlTpy5YP336dI0aNUrShRf5AkBNwpxTcklJSfLx8dGDDz5Y6n01a9bM7XXRGE+cOOEWjq6//voLtr3hhhv066+/6tixY7Lb7aXuC2oOwhFqhEt963Op9YZhmD/PmDFD//d//6fHH39cL7zwgoKCguTt7a0xY8aosLDQ474UbTN79mx17NjxojWXOxfbE8ePH1deXt4V6wICAmSz2SRJTZo0kSQdOXJEYWFhbnVHjhy54rnprVq10r/+9S/l5+erTp065vrS3l4cAKoL5pzLO3/OOd+ZM2e0cuVKRUVFKSQkpNT9Kc7vu7h+H0KLnB9eUTsQjlDr/fOf/1TPnj315ptvuq3Pzs7WVVddZb5u3ry59uzZI8Mw3D5E9+/f77Zd0YWZVqvV7Rk/5WHAgAHatGnTFeuGDh2qxMRESTInz507d7oFocOHD+vnn382LzC9lH79+mnr1q1auXKl2+kjAIArq21zzvk++ugjnTx5stQ3YvBU0dG18/373/9W3bp1zSOADRs2VHZ29gV1P/300wXrLhWkUDMQjlDr+fj4XPAt04oVK/Sf//zH7fSF6OhopaSk6KOPPtK9994r6bfT0N544w23bSMiInTdddfp5Zdf1sMPP3zBN3bHjh274HSMkirJ+d9t27ZVq1at9Prrr+vJJ580v3l77bXX5OXlpfvvv/+y+3rqqae0cOFCjR07Vh07dtQNN9zg1l6Sb+wAoLaobXPO+ZYuXaq6devqvvvuK5P+FFdqaqq+/vprderUSZJ06NAhffjhh+rTp485B1533XXKycnRt99+a54JceTIEa1cufKC/dWrV++iQQo1A+EItV6/fv00ffp0PfbYY7rllluUkZGhpKQkXXvttW51Tz75pBYtWqSHHnpITz/9tJo0aaKkpCT5+/tL+t83Sd7e3lqyZIn69u2rtm3b6rHHHtPVV1+t//znP/r8889ltVr18ccfl0nfS3r+9+zZs3XPPfeod+/eGjhwoHbt2qVFixZp+PDhbk9Fv5igoCCtXLlSd999tzp06KCBAweqS5cuqlOnjg4dOqQVK1ZIuvBccABA7ZxzpN9Oyfv0008VGxtbZqf5FdeNN96o6Ohot1t5S789iLbIwIEDNWHCBN13333605/+pF9//VWvvfaabrjhBrcbZUi//R4+++wzzZ07V6GhoQoPD1dkZGSFjgnlh3CEWu+5557T6dOntXTpUi1fvlydOnVScnKyJk6c6FZXv359bdiwQaNHj9Yrr7yi+vXra8iQIbrlllsUGxtrTliS1KNHD6WmpuqFF17QokWLdOrUKdntdkVGRurJJ5+s6CFeoF+/fvrggw80bdo0jR49Wo0bN9Zzzz2n+Pj4Ym3vcDi0a9cuzZ07V8nJyVq+fLkKCwt19dVX67bbbtPrr7+ubt26lfMoAKD6qY1zjvTb0bH8/Hw9/PDDFf7et99+uxwOh6ZNm6bMzEy1adNGiYmJbtfKNmrUSCtXrtS4ceM0fvx48/lJ+/btuyAczZ07VyNGjNDkyZN15swZDR06lHBUg3gZnAMDlMr8+fM1duxY/fzzz7r66qsruzsAgBqMOcczXl5ePFoCHin9Te+BWqToGUFFzp49q7/97W+6/vrrmaQAAGWKOQeoeJxWB3hgwIABatasmTp27KicnBz9/e9/1/fff6+kpKTK7hoAoIZhzgEqHuEI8EB0dLSWLFmipKQkFRQUqE2bNlq2bFmZPMwOAIDzMecAFY9rjgAAAABAXHMEAAAAAJIIRwAAAAAgqQZfc1RYWKjDhw+rQYMG5oPSAADlzzAMnTx5UqGhofL25ju48zE3AUDlKO7cVGPD0eHDhxUWFlbZ3QCAWuvQoUNq2rRpZXejSmFuAoDKdaW5qcaGowYNGkj67RdgtVoruTcAUHu4XC6FhYWZn8P4H+YmAKgcxZ2bamw4KjpdwWq1MgEBQCXgtLELMTcBQOW60tzEyeAAAAAAIMIRAAAAAEgiHAEAAACAJMIRAAAAAEgiHAEAAACAJMIRAAAAAEgiHAEAAACAJMIRAAAAAEgiHAEAAACAJMIRAAAAAEgiHAEAAACAJMIRAAAAAEgiHAEAAACAJMIRAAAAAEgiHAEAAACAJMIRAAAAAEgqQTj6z3/+o0ceeUSNGjVSQECA2rVrp507d5rthmEoPj5eTZo0UUBAgKKiorRv3z63fRw/flyDBg2S1WpVYGCghg0bplOnTrnVfPvtt+rWrZv8/f0VFhamWbNmlXCIJXfNxGRzAQCgKmBuAoDy41E4OnHihG699VbVqVNHn376qfbs2aM5c+aoYcOGZs2sWbO0YMECLV68WNu2bVO9evUUHR2ts2fPmjWDBg3S7t27lZKSotWrV2vz5s0aMWKE2e5yudS7d281b95caWlpmj17tqZOnarXX3+9DIYMAAAAABfy9aT4r3/9q8LCwvT222+b68LDw82fDcPQ/PnzNXnyZN17772SpHfffVchISFatWqVBg4cqO+++05r1qzRjh071LlzZ0nSwoULddddd+nll19WaGiokpKSlJeXp7feekt+fn5q27at0tPTNXfuXLcQBQAAAABlxaMjRx999JE6d+6sP/zhDwoODtZNN92kN954w2w/ePCgnE6noqKizHU2m02RkZFKTU2VJKWmpiowMNAMRpIUFRUlb29vbdu2zazp3r27/Pz8zJro6Gjt3btXJ06cuGjfcnNz5XK53BYAAAAAKC6PwtGBAwf02muv6frrr9fatWv11FNP6U9/+pPeeecdSZLT6ZQkhYSEuG0XEhJitjmdTgUHB7u1+/r6KigoyK3mYvs4/z1+b+bMmbLZbOYSFhbmydAAAAAA1HIehaPCwkJ16tRJM2bM0E033aQRI0boiSee0OLFi8urf8U2adIk5eTkmMuhQ4cqu0sAAAAAqhGPwlGTJk3Upk0bt3WtW7dWZmamJMlut0uSsrKy3GqysrLMNrvdrqNHj7q1nzt3TsePH3erudg+zn+P37NYLLJarW4LAAAAABSXR+Ho1ltv1d69e93W/fvf/1bz5s0l/XZzBrvdrvXr15vtLpdL27Ztk8PhkCQ5HA5lZ2crLS3NrNmwYYMKCwsVGRlp1mzevFn5+flmTUpKilq2bOl2ZzwAAAAAKCsehaOxY8dq69atmjFjhvbv36+lS5fq9ddfV1xcnCTJy8tLY8aM0YsvvqiPPvpIGRkZGjJkiEJDQ9W/f39Jvx1p6tOnj5544glt375dX331lUaNGqWBAwcqNDRUkvTwww/Lz89Pw4YN0+7du7V8+XK98sorGjduXNmOHgAAAAD+P49u5d2lSxetXLlSkyZN0vTp0xUeHq758+dr0KBBZs348eN1+vRpjRgxQtnZ2brtttu0Zs0a+fv7mzVJSUkaNWqU7rjjDnl7eys2NlYLFiww2202m9atW6e4uDhFREToqquuUnx8PLfxBgAAAFBuvAzDMCq7E+XB5XLJZrMpJyenxNcfnf/08R9fiimrrgFAjVYWn781FXMTAFSO4n7+enRaHQAAAADUVIQjAAAAABDhCAAAAAAkEY4AAAAAQBLhCAAAAAAkEY4AAAAAQBLhCAAAAAAkEY4AAAAAQBLhCAAAAAAkEY4AAAAAQBLhCAAAAAAkEY4AAAAAQBLhCAAAAAAkEY4AAAAAQBLhCAAAAAAkEY4AAAAAQBLhCAAAAAAkEY4AAAAAQBLhCAAAAAAkEY4AAAAAQBLhCAAAAAAkEY4AAAAAQBLhCAAAAAAkEY4AAAAAQBLhCAAAAAAkEY4AAAAAQBLhCAAAAAAkEY4AAAAAQBLhCAAAAAAkEY4AAAAAQBLhCAAAAAAkEY4AAAAAQBLhCABQzc2cOVNdunRRgwYNFBwcrP79+2vv3r1uNWfPnlVcXJwaNWqk+vXrKzY2VllZWW41mZmZiomJUd26dRUcHKxnn31W586dc6vZuHGjOnXqJIvFohYtWigxMbG8hwcAqECEIwBAtbZp0ybFxcVp69atSklJUX5+vnr37q3Tp0+bNWPHjtXHH3+sFStWaNOmTTp8+LAGDBhgthcUFCgmJkZ5eXnasmWL3nnnHSUmJio+Pt6sOXjwoGJiYtSzZ0+lp6drzJgxGj58uNauXVuh4wUAlB8vwzCMyu5EeXC5XLLZbMrJyZHVai3RPq6ZmGz+/ONLMWXVNQCo0cri87c0jh07puDgYG3atEndu3dXTk6OGjdurKVLl+r++++XJH3//fdq3bq1UlNT1bVrV3366afq16+fDh8+rJCQEEnS4sWLNWHCBB07dkx+fn6aMGGCkpOTtWvXLvO9Bg4cqOzsbK1Zs6ZYfWNuAoDKUdzPX44cAQBqlJycHElSUFCQJCktLU35+fmKiooya1q1aqVmzZopNTVVkpSamqp27dqZwUiSoqOj5XK5tHv3brPm/H0U1RTtAwBQ/flWdgcAACgrhYWFGjNmjG699VbdeOONkiSn0yk/Pz8FBga61YaEhMjpdJo15wejovaitsvVuFwunTlzRgEBARf0Jzc3V7m5ueZrl8tVugECAMoVR44AADVGXFycdu3apWXLllV2VyT9drMIm81mLmFhYZXdJQDAZRCOAAA1wqhRo7R69Wp9/vnnatq0qbnebrcrLy9P2dnZbvVZWVmy2+1mze/vXlf0+ko1Vqv1okeNJGnSpEnKyckxl0OHDpVqjACA8kU4AgBUa4ZhaNSoUVq5cqU2bNig8PBwt/aIiAjVqVNH69evN9ft3btXmZmZcjgckiSHw6GMjAwdPXrUrElJSZHValWbNm3MmvP3UVRTtI+LsVgsslqtbgsAoOrimiMAQLUWFxenpUuX6sMPP1SDBg3Ma4RsNpsCAgJks9k0bNgwjRs3TkFBQbJarRo9erQcDoe6du0qSerdu7fatGmjwYMHa9asWXI6nZo8ebLi4uJksVgkSSNHjtSiRYs0fvx4Pf7449qwYYPef/99JScnX7JvAIDqhSNHAIBq7bXXXlNOTo569OihJk2amMvy5cvNmnnz5qlfv36KjY1V9+7dZbfb9cEHH5jtPj4+Wr16tXx8fORwOPTII49oyJAhmj59ulkTHh6u5ORkpaSkqEOHDpozZ46WLFmi6OjoCh0vAKD8cOQIAFCtFedxff7+/kpISFBCQsIla5o3b65PPvnksvvp0aOHvvnmG4/7CACoHjhyBAAAAAAiHAEAAACAJMIRAAAAAEgiHAEAAACAJMIRAAAAAEgiHAEAAACAJA/D0dSpU+Xl5eW2tGrVymw/e/as4uLi1KhRI9WvX1+xsbHKyspy20dmZqZiYmJUt25dBQcH69lnn9W5c+fcajZu3KhOnTrJYrGoRYsWSkxMLPkIAQAAAKAYPD5y1LZtWx05csRcvvzyS7Nt7Nix+vjjj7VixQpt2rRJhw8f1oABA8z2goICxcTEKC8vT1u2bNE777yjxMRExcfHmzUHDx5UTEyMevbsqfT0dI0ZM0bDhw/X2rVrSzlUAAAAALg0jx8C6+vrK7vdfsH6nJwcvfnmm1q6dKl69eolSXr77bfVunVrbd26VV27dtW6deu0Z88effbZZwoJCVHHjh31wgsvaMKECZo6dar8/Py0ePFihYeHa86cOZKk1q1b68svv9S8efN4CjkAAACAcuPxkaN9+/YpNDRU1157rQYNGqTMzExJUlpamvLz8xUVFWXWtmrVSs2aNVNqaqokKTU1Ve3atVNISIhZEx0dLZfLpd27d5s15++jqKZoHwAAAABQHjw6chQZGanExES1bNlSR44c0bRp09StWzft2rVLTqdTfn5+CgwMdNsmJCRETqdTkuR0Ot2CUVF7Udvlalwul86cOaOAgICL9i03N1e5ubnma5fL5cnQAAAAANRyHoWjvn37mj+3b99ekZGRat68ud5///1LhpaKMnPmTE2bNq1S+wAAAACg+irVrbwDAwN1ww03aP/+/bLb7crLy1N2drZbTVZWlnmNkt1uv+DudUWvr1RjtVovG8AmTZqknJwcczl06FBphgYAAACglilVODp16pR++OEHNWnSRBEREapTp47Wr19vtu/du1eZmZlyOBySJIfDoYyMDB09etSsSUlJkdVqVZs2bcya8/dRVFO0j0uxWCyyWq1uCwAAAAAUl0fh6JlnntGmTZv0448/asuWLbrvvvvk4+Ojhx56SDabTcOGDdO4ceP0+eefKy0tTY899pgcDoe6du0qSerdu7fatGmjwYMH61//+pfWrl2ryZMnKy4uThaLRZI0cuRIHThwQOPHj9f333+vV199Ve+//77Gjh1b9qMHAAAAgP/Po2uOfv75Zz300EP65Zdf1LhxY912223aunWrGjduLEmaN2+evL29FRsbq9zcXEVHR+vVV181t/fx8dHq1av11FNPyeFwqF69eho6dKimT59u1oSHhys5OVljx47VK6+8oqZNm2rJkiXcxhsAAABAufIoHC1btuyy7f7+/kpISFBCQsIla5o3b65PPvnksvvp0aOHvvnmG0+6BgAAAAClUqprjgAAAACgpiAcAQAAAIAIRwAAAAAgiXAEAAAAAJIIRwAAAAAgiXAEAAAAAJIIRwAAAAAgiXAEAAAAAJIIRwAAAAAgiXAEAAAAAJIIRwAAAAAgiXAEAAAAAJIIRwAAAAAgiXAEAAAAAJIIRwAAAAAgiXAEAAAAAJIIRwAAAAAgiXAEAAAAAJIIRwAAAAAgiXAEAAAAAJIIRwAAAAAgiXAEAAAAAJIIRwAAAAAgiXAEAAAAAJIIRwAAAAAgiXAEAAAAAJIIRwAAAAAgiXAEAAAAAJIIRwAAAAAgiXAEAAAAAJIIRwAAAAAgiXAEAAAAAJIIRwAAAAAgiXAEAAAAAJIIRwAAAAAgiXAEAAAAAJIIRwAAAAAgiXAEAAAAAJIIRwAAAAAgiXAEAAAAAJIIRwAAAAAgiXAEAAAAAJIIRwAAAAAgiXAEAAAAAJIIRwAAAAAgiXAEAAAAAJIIRwAAAAAgiXAEAAAAAJIIRwAAAAAgiXAEAAAAAJJKGY5eeukleXl5acyYMea6s2fPKi4uTo0aNVL9+vUVGxurrKwst+0yMzMVExOjunXrKjg4WM8++6zOnTvnVrNx40Z16tRJFotFLVq0UGJiYmm6CgAAAACXVeJwtGPHDv3tb39T+/bt3daPHTtWH3/8sVasWKFNmzbp8OHDGjBggNleUFCgmJgY5eXlacuWLXrnnXeUmJio+Ph4s+bgwYOKiYlRz549lZ6erjFjxmj48OFau3ZtSbsLAAAAAJdVonB06tQpDRo0SG+88YYaNmxors/JydGbb76puXPnqlevXoqIiNDbb7+tLVu2aOvWrZKkdevWac+ePfr73/+ujh07qm/fvnrhhReUkJCgvLw8SdLixYsVHh6uOXPmqHXr1ho1apTuv/9+zZs3rwyGDACoSTZv3qy7775boaGh8vLy0qpVq9zaH330UXl5ebktffr0cas5fvy4Bg0aJKvVqsDAQA0bNkynTp1yq/n222/VrVs3+fv7KywsTLNmzSrvoQEAKliJwlFcXJxiYmIUFRXltj4tLU35+flu61u1aqVmzZopNTVVkpSamqp27dopJCTErImOjpbL5dLu3bvNmt/vOzo62tzHxeTm5srlcrktAICa7/Tp0+rQoYMSEhIuWdOnTx8dOXLEXP7xj3+4tQ8aNEi7d+9WSkqKVq9erc2bN2vEiBFmu8vlUu/evdW8eXOlpaVp9uzZmjp1ql5//fVyGxcAoOL5errBsmXL9PXXX2vHjh0XtDmdTvn5+SkwMNBtfUhIiJxOp1lzfjAqai9qu1yNy+XSmTNnFBAQcMF7z5w5U9OmTfN0OACAaq5v377q27fvZWssFovsdvtF27777jutWbNGO3bsUOfOnSVJCxcu1F133aWXX35ZoaGhSkpKUl5ent566y35+fmpbdu2Sk9P19y5c91CFACgevPoyNGhQ4f09NNPKykpSf7+/uXVpxKZNGmScnJyzOXQoUOV3SUAQBWxceNGBQcHq2XLlnrqqaf0yy+/mG2pqakKDAw0g5EkRUVFydvbW9u2bTNrunfvLj8/P7MmOjpae/fu1YkTJy75vpzVAADVi0fhKC0tTUePHlWnTp3k6+srX19fbdq0SQsWLJCvr69CQkKUl5en7Oxst+2ysrLMb+zsdvsFd68ren2lGqvVetGjRtJv3wparVa3BQCAPn366N1339X69ev117/+VZs2bVLfvn1VUFAg6bezFYKDg9228fX1VVBQkEdnPVzMzJkzZbPZzCUsLKwshwYAKGMehaM77rhDGRkZSk9PN5fOnTtr0KBB5s916tTR+vXrzW327t2rzMxMORwOSZLD4VBGRoaOHj1q1qSkpMhqtapNmzZmzfn7KKop2gcAAMU1cOBA3XPPPWrXrp369++v1atXa8eOHdq4cWO5vzdnNQBA9eLRNUcNGjTQjTfe6LauXr16atSokbl+2LBhGjdunIKCgmS1WjV69Gg5HA517dpVktS7d2+1adNGgwcP1qxZs+R0OjV58mTFxcXJYrFIkkaOHKlFixZp/Pjxevzxx7Vhwwa9//77Sk5OLosxAwBqsWuvvVZXXXWV9u/frzvuuEN2u93tCztJOnfunI4fP+7RWQ8XY7FYzLkNAFD1leohsBczb9489evXT7Gxserevbvsdrs++OADs93Hx0erV6+Wj4+PHA6HHnnkEQ0ZMkTTp083a8LDw5WcnKyUlBR16NBBc+bM0ZIlSxQdHV3W3QUA1DI///yzfvnlFzVp0kTSb2crZGdnKy0tzazZsGGDCgsLFRkZadZs3rxZ+fn5Zk1KSopatmzp9kgLAED15mUYhlHZnSgPLpdLNptNOTk5Jb7+6JqJ/ztS9eNLMWXVNQCo0cri89cTp06d0v79+yVJN910k+bOnauePXsqKChIQUFBmjZtmmJjY2W32/XDDz9o/PjxOnnypDIyMsyjOn379lVWVpYWL16s/Px8PfbYY+rcubOWLl0q6bfn+LVs2VK9e/fWhAkTtGvXLj3++OOaN2+eR3erY24CgMpR3M/fMj9yBABARdq5c6duuukm3XTTTZKkcePG6aabblJ8fLx8fHz07bff6p577tENN9ygYcOGKSIiQl988YXb6W5JSUlq1aqV7rjjDt1111267bbb3J5hZLPZtG7dOh08eFARERH685//rPj4eG7jDQA1jMfPOQIAoCrp0aOHLncSxNq1a6+4j6CgIPMo0aW0b99eX3zxhcf9AwBUHxw5AgAAAAARjgAAAABAEuEIAAAAACQRjgAAAABAEuEIAAAAACQRjgAAAABAEuEIAAAAACQRjgAAAABAEuEIAAAAACQRjgAAAABAEuEIAAAAACQRjgAAAABAEuEIAAAAACQRjgAAAABAEuEIAAAAACQRjgAAAABAEuEIAAAAACQRjgAAAABAEuEIAAAAACQRjgAAAABAEuEIAAAAACQRjgAAAABAEuEIAAAAACQRjgAAAABAEuEIAAAAACQRjgAAAABAEuEIAAAAACQRjgAAAABAEuEIAAAAACQRjgAAAABAEuEIAAAAACQRjgAAAABAEuEIAAAAACQRjgAAAABAEuEIAAAAACQRjgAAAABAEuEIAAAAACQRjgAAAABAEuEIAAAAACQRjgAAAABAEuEIAAAAACQRjgAAAABAEuEIAAAAACQRjgAAAABAEuEIAAAAACQRjgAAAABAEuEIAAAAACR5GI5ee+01tW/fXlarVVarVQ6HQ59++qnZfvbsWcXFxalRo0aqX7++YmNjlZWV5baPzMxMxcTEqG7dugoODtazzz6rc+fOudVs3LhRnTp1ksViUYsWLZSYmFjyEQIAAABAMXgUjpo2baqXXnpJaWlp2rlzp3r16qV7771Xu3fvliSNHTtWH3/8sVasWKFNmzbp8OHDGjBggLl9QUGBYmJilJeXpy1btuidd95RYmKi4uPjzZqDBw8qJiZGPXv2VHp6usaMGaPhw4dr7dq1ZTRkAAAAALiQl2EYRml2EBQUpNmzZ+v+++9X48aNtXTpUt1///2SpO+//16tW7dWamqqunbtqk8//VT9+vXT4cOHFRISIklavHixJkyYoGPHjsnPz08TJkxQcnKydu3aZb7HwIEDlZ2drTVr1hS7Xy6XSzabTTk5ObJarSUa2zUTk82ff3wppkT7AIDapiw+f2sq5iYAqBzF/fwt8TVHBQUFWrZsmU6fPi2Hw6G0tDTl5+crKirKrGnVqpWaNWum1NRUSVJqaqratWtnBiNJio6OlsvlMo8+paamuu2jqKZoH5eSm5srl8vltgAAAABAcXkcjjIyMlS/fn1ZLBaNHDlSK1euVJs2beR0OuXn56fAwEC3+pCQEDmdTkmS0+l0C0ZF7UVtl6txuVw6c+bMJfs1c+ZM2Ww2cwkLC/N0aAAAAABqMY/DUcuWLZWenq5t27bpqaee0tChQ7Vnz57y6JtHJk2apJycHHM5dOhQZXcJAAAAQDXi6+kGfn5+atGihSQpIiJCO3bs0CuvvKIHH3xQeXl5ys7Odjt6lJWVJbvdLkmy2+3avn272/6K7mZ3fs3v73CXlZUlq9WqgICAS/bLYrHIYrF4OhwAAAAAkFQGzzkqLCxUbm6uIiIiVKdOHa1fv95s27t3rzIzM+VwOCRJDodDGRkZOnr0qFmTkpIiq9WqNm3amDXn76OopmgfAAAAAFAePDpyNGnSJPXt21fNmjXTyZMntXTpUm3cuFFr166VzWbTsGHDNG7cOAUFBclqtWr06NFyOBzq2rWrJKl3795q06aNBg8erFmzZsnpdGry5MmKi4szj/qMHDlSixYt0vjx4/X4449rw4YNev/995WcnHy5rgEAAABAqXgUjo4ePaohQ4boyJEjstlsat++vdauXas777xTkjRv3jx5e3srNjZWubm5io6O1quvvmpu7+Pjo9WrV+upp56Sw+FQvXr1NHToUE2fPt2sCQ8PV3JyssaOHatXXnlFTZs21ZIlSxQdHV1GQwYAAACAC5X6OUdVFc+SAIDKwXOOLo25CQAqR7k/5wgAAAAAahLCEQAAAACIcAQAAAAAkghHAAAAACCpBA+BBQAAVQM3ZwCAssWRIwAAAAAQ4QgAAAAAJBGOAAAAAEAS4QgAAAAAJBGOAAAAAEAS4QgAUM1t3rxZd999t0JDQ+Xl5aVVq1a5tRuGofj4eDVp0kQBAQGKiorSvn373GqOHz+uQYMGyWq1KjAwUMOGDdOpU6fcar799lt169ZN/v7+CgsL06xZs8p7aACACkY4AgBUa6dPn1aHDh2UkJBw0fZZs2ZpwYIFWrx4sbZt26Z69eopOjpaZ8+eNWsGDRqk3bt3KyUlRatXr9bmzZs1YsQIs93lcql3795q3ry50tLSNHv2bE2dOlWvv/56uY8PAFBxeM4RAKBa69u3r/r27XvRNsMwNH/+fE2ePFn33nuvJOndd99VSEiIVq1apYEDB+q7777TmjVrtGPHDnXu3FmStHDhQt111116+eWXFRoaqqSkJOXl5emtt96Sn5+f2rZtq/T0dM2dO9ctRAEAqjeOHAEAaqyDBw/K6XQqKirKXGez2RQZGanU1FRJUmpqqgIDA81gJElRUVHy9vbWtm3bzJru3bvLz8/PrImOjtbevXt14sSJChoNAKC8ceQIAFBjOZ1OSVJISIjb+pCQELPN6XQqODjYrd3X11dBQUFuNeHh4Rfso6itYcOGF33/3Nxc5ebmmq9dLlcpRgMAKG8cOQIAoJzMnDlTNpvNXMLCwiq7SwCAyyAcAQBqLLvdLknKyspyW5+VlWW22e12HT161K393LlzOn78uFvNxfZx/ntczKRJk5STk2Muhw4dKt2AAADlinAEAKixwsPDZbfbtX79enOdy+XStm3b5HA4JEkOh0PZ2dlKS0szazZs2KDCwkJFRkaaNZs3b1Z+fr5Zk5KSopYtW17ylDpJslgsslqtbgsAoOoiHAEAqrVTp04pPT1d6enpkn67CUN6eroyMzPl5eWlMWPG6MUXX9RHH32kjIwMDRkyRKGhoerfv78kqXXr1urTp4+eeOIJbd++XV999ZVGjRqlgQMHKjQ0VJL08MMPy8/PT8OGDdPu3bu1fPlyvfLKKxo3blwljRoAUB64IQMAoFrbuXOnevbsab4uCixDhw5VYmKixo8fr9OnT2vEiBHKzs7WbbfdpjVr1sjf39/cJikpSaNGjdIdd9whb29vxcbGasGCBWa7zWbTunXrFBcXp4iICF111VWKj4/nNt4AUMMQjgAA1VqPHj1kGMYl2728vDR9+nRNnz79kjVBQUFaunTpZd+nffv2+uKLL0rcTwBA1cdpdQAAAAAgwhEAAAAASCIcAQAAAIAkwhEAAAAASCIcAQAAAIAkwhEAAAAASCIcAQAAAIAkwhEAAAAASCIcAQAAAIAkwhEAAAAASCIcAQAAAIAkwhEAAAAASCIcAQAAAIAkwhEAAAAASCIcAQAAAIAkwhEAAAAASJJ8K7sDAACg9K6ZmGz+/ONLMZXYEwCovjhyBAAAAAAiHAEAAACAJMIRAAAAAEgiHAEAAACAJMIRAAAAAEgiHAEAAACAJMIRAAAAAEgiHAEAAACAJMIRAAAAAEgiHAEAAACAJMIRAAAAAEjyMBzNnDlTXbp0UYMGDRQcHKz+/ftr7969bjVnz55VXFycGjVqpPr16ys2NlZZWVluNZmZmYqJiVHdunUVHBysZ599VufOnXOr2bhxozp16iSLxaIWLVooMTGxZCMEAAAAgGLwKBxt2rRJcXFx2rp1q1JSUpSfn6/evXvr9OnTZs3YsWP18ccfa8WKFdq0aZMOHz6sAQMGmO0FBQWKiYlRXl6etmzZonfeeUeJiYmKj483aw4ePKiYmBj17NlT6enpGjNmjIYPH661a9eWwZABAAAA4EJehmEYJd342LFjCg4O1qZNm9S9e3fl5OSocePGWrp0qe6//35J0vfff6/WrVsrNTVVXbt21aeffqp+/frp8OHDCgkJkSQtXrxYEyZM0LFjx+Tn56cJEyYoOTlZu3btMt9r4MCBys7O1po1a4rVN5fLJZvNppycHFmt1hKN75qJyebPP74UU6J9AEBtUxafvzVVWc9Nl8KcBQDuivv5W6prjnJyciRJQUFBkqS0tDTl5+crKirKrGnVqpWaNWum1NRUSVJqaqratWtnBiNJio6Olsvl0u7du82a8/dRVFO0DwAAAAAoa74l3bCwsFBjxozRrbfeqhtvvFGS5HQ65efnp8DAQLfakJAQOZ1Os+b8YFTUXtR2uRqXy6UzZ84oICDggv7k5uYqNzfXfO1yuUo6NAAAAAC1UImPHMXFxWnXrl1atmxZWfanxGbOnCmbzWYuYWFhld0lAAAAANVIicLRqFGjtHr1an3++edq2rSpud5utysvL0/Z2dlu9VlZWbLb7WbN7+9eV/T6SjVWq/WiR40kadKkScrJyTGXQ4cOlWRoAAAAAGopj8KRYRgaNWqUVq5cqQ0bNig8PNytPSIiQnXq1NH69evNdXv37lVmZqYcDockyeFwKCMjQ0ePHjVrUlJSZLVa1aZNG7Pm/H0U1RTt42IsFousVqvbAgAAAADF5dE1R3FxcVq6dKk+/PBDNWjQwLxGyGazKSAgQDabTcOGDdO4ceMUFBQkq9Wq0aNHy+FwqGvXrpKk3r17q02bNho8eLBmzZolp9OpyZMnKy4uThaLRZI0cuRILVq0SOPHj9fjjz+uDRs26P3331dy8pXv0AMAAAAAJeHRkaPXXntNOTk56tGjh5o0aWIuy5cvN2vmzZunfv36KTY2Vt27d5fdbtcHH3xgtvv4+Gj16tXy8fGRw+HQI488oiFDhmj69OlmTXh4uJKTk5WSkqIOHTpozpw5WrJkiaKjo8tgyAAAAABwIY+OHBXnkUj+/v5KSEhQQkLCJWuaN2+uTz755LL76dGjh7755htPugcAAAAAJVaq5xwBAAAAQE1BOAIAAAAAEY4AAAAAQBLhCAAAAAAkEY4AAAAAQBLhCAAAAAAkEY4AAAAAQBLhCAAAAAAkEY4AAAAAQBLhCAAAAAAkEY4AAAAAQBLhCAAAAAAkEY4AAAAAQBLhCAAAAAAkEY4AAAAAQBLhCAAAAAAkEY4AAAAAQBLhCAAAAAAkEY4AAAAAQBLhCAAAAAAkEY4AAAAAQBLhCAAAAAAkEY4AAAAAQJLkW9kdAAAAZeuaicnmzz++FFOJPQGA6oUjRwAAAAAgwhEAAAAASCIcAQAAAIAkwhEAAAAASCIcAQAAAIAkwhEAAAAASCIcAQBqgalTp8rLy8ttadWqldl+9uxZxcXFqVGjRqpfv75iY2OVlZXlto/MzEzFxMSobt26Cg4O1rPPPqtz585V9FAAAOWI5xwBAGqFtm3b6rPPPjNf+/r+bwocO3askpOTtWLFCtlsNo0aNUoDBgzQV199JUkqKChQTEyM7Ha7tmzZoiNHjmjIkCGqU6eOZsyYUeFjAQCUD8IRAKBW8PX1ld1uv2B9Tk6O3nzzTS1dulS9evWSJL399ttq3bq1tm7dqq5du2rdunXas2ePPvvsM4WEhKhjx4564YUXNGHCBE2dOlV+fn4VPRwAQDngtDoAQK2wb98+hYaG6tprr9WgQYOUmZkpSUpLS1N+fr6ioqLM2latWqlZs2ZKTU2VJKWmpqpdu3YKCQkxa6Kjo+VyubR79+6KHQgAoNxw5AgAUONFRkYqMTFRLVu21JEjRzRt2jR169ZNu3btktPplJ+fnwIDA922CQkJkdPplCQ5nU63YFTUXtR2Kbm5ucrNzTVfu1yuMhoRAKA8EI4AADVe3759zZ/bt2+vyMhINW/eXO+//74CAgLK7X1nzpypadOmldv+AQBli9PqAAC1TmBgoG644Qbt379fdrtdeXl5ys7OdqvJysoyr1Gy2+0X3L2u6PXFrmMqMmnSJOXk5JjLoUOHynYgAIAyRTgCANQ6p06d0g8//KAmTZooIiJCderU0fr16832vXv3KjMzUw6HQ5LkcDiUkZGho0ePmjUpKSmyWq1q06bNJd/HYrHIarW6LQCAqovT6gAANd4zzzyju+++W82bN9fhw4c1ZcoU+fj46KGHHpLNZtOwYcM0btw4BQUFyWq1avTo0XI4HOrataskqXfv3mrTpo0GDx6sWbNmyel0avLkyYqLi5PFYqnk0QEAygrhCABQ4/3888966KGH9Msvv6hx48a67bbbtHXrVjVu3FiSNG/ePHl7eys2Nla5ubmKjo7Wq6++am7v4+Oj1atX66mnnpLD4VC9evU0dOhQTZ8+vbKGBAAoB4QjAECNt2zZssu2+/v7KyEhQQkJCZesad68uT755JOy7hoAoArhmiMAAAAAEOEIAAAAACQRjgAAAABAEuEIAAAAACQRjgAAAABAEuEIAAAAACQRjgAAAABAEuEIAAAAACQRjgAAAABAUgnC0ebNm3X33XcrNDRUXl5eWrVqlVu7YRiKj49XkyZNFBAQoKioKO3bt8+t5vjx4xo0aJCsVqsCAwM1bNgwnTp1yq3m22+/Vbdu3eTv76+wsDDNmjXL89EBAAAAQDF5HI5Onz6tDh06KCEh4aLts2bN0oIFC7R48WJt27ZN9erVU3R0tM6ePWvWDBo0SLt371ZKSopWr16tzZs3a8SIEWa7y+VS79691bx5c6WlpWn27NmaOnWqXn/99RIMEQAAAACuzNfTDfr27au+fftetM0wDM2fP1+TJ0/WvffeK0l69913FRISolWrVmngwIH67rvvtGbNGu3YsUOdO3eWJC1cuFB33XWXXn75ZYWGhiopKUl5eXl666235Ofnp7Zt2yo9PV1z5851C1EAAAAAUFbK9JqjgwcPyul0Kioqylxns9kUGRmp1NRUSVJqaqoCAwPNYCRJUVFR8vb21rZt28ya7t27y8/Pz6yJjo7W3r17deLEiYu+d25urlwul9sCAEBtd83EZLcFAHBpZRqOnE6nJCkkJMRtfUhIiNnmdDoVHBzs1u7r66ugoCC3movt4/z3+L2ZM2fKZrOZS1hYWOkHBAAAAKDWqDF3q5s0aZJycnLM5dChQ5XdJQAAAADVSJmGI7vdLknKyspyW5+VlWW22e12HT161K393LlzOn78uFvNxfZx/nv8nsVikdVqdVsAAAAAoLjKNByFh4fLbrdr/fr15jqXy6Vt27bJ4XBIkhwOh7Kzs5WWlmbWbNiwQYWFhYqMjDRrNm/erPz8fLMmJSVFLVu2VMOGDcuyywAAAAAgqQTh6NSpU0pPT1d6erqk327CkJ6erszMTHl5eWnMmDF68cUX9dFHHykjI0NDhgxRaGio+vfvL0lq3bq1+vTpoyeeeELbt2/XV199pVGjRmngwIEKDQ2VJD388MPy8/PTsGHDtHv3bi1fvlyvvPKKxo0bV2YDBwAAAIDzeXwr7507d6pnz57m66LAMnToUCUmJmr8+PE6ffq0RowYoezsbN12221as2aN/P39zW2SkpI0atQo3XHHHfL29lZsbKwWLFhgtttsNq1bt05xcXGKiIjQVVddpfj4eG7jDQAAAKDceByOevToIcMwLtnu5eWl6dOna/r06ZesCQoK0tKlSy/7Pu3bt9cXX3zhafcAAAAAoERqzN3qAAAAAKA0CEcAAAAAIMIRAAAAAEgiHAEAAACAJMIRAAAAAEgiHAEAAACAJMIRAAAAAEgiHAEAAACApBI8BBYAAFRf10xMNn/+8aWYSuwJyhJ/rkDZIBwBAABUIQQdoPIQjgAAACrZ+YGouHUEJ6DsEY4AAACqoeIGKgDFRzgCAAAopeIe0fE00BCAgIpFOAIAACgn1THc/L7PnL6H2oRwBAAAUExc8wPUbDznCAAAAADEkSMAAIBLKslpcZV9Kt3ljm5dqq2y+wxUFYQjAACAGorQA3iGcAQAAFALEZyACxGOAAAAzkNocMdNKFCbEI4AAKil+E9v6dT2EMXfH9REhCMAAFDr1fagU1z8nlDTEY4AAABHAQBAPOcIAAAAACRx5AgAANRgvz8NjKNi5eNyp9vxO0d1QjgCAAC1BqcPArgcwhEAAADKDYEU1QnhqJj4hw0AAADUbIQjAABQK3Fb6orHl82o6ghHAACgWrpUuOE/3QBKinAEAADc8O0+KgJ/z1AVEY4AAMAlVfatsCv7/QHULoQjVHt88wQAtUdxrhPiWiIAJUU4Qo1CUAKA6onPbwBVAeGoBPgArxjl9XvmFA0AAKqWyx3tY55GRSIcoVrgFAkAqBqKc4c4/qMLoLoiHKFKKcsQRKACgKqHsy8AVGWEI1S6yg4xTNQAAACQCEcoR5cKHZUdhgAAZa8kn+2X2oZ5Aufz9FROvuhEaRCOUCGY6AAAAFDVEY5KiTufuavuIYhvngAAAGovwhE8Vt0DEAAAAHAxhKMKwhEJAAAAoGojHJWx6hCCSvL8CY4WAQCA6uBylzxUh/+noXIRjspRcQJFcYNKce/8Vtq7whGC/ocPUAAAgNqFcFQJihtASnKLU8JN+SAoAQBQtfB/HpQHwhEAAABqLE/P5OFL0NqNcAR4qCTXbAEAgKqltJcfMOfXTIQjoAwV5yneAACg6iI01W5VOhwlJCRo9uzZcjqd6tChgxYuXKibb765srsFeKy0dwjkgxaoOpibAKDmqrLhaPny5Ro3bpwWL16syMhIzZ8/X9HR0dq7d6+Cg4Mru3tAmeGCUqD6YG4CUKQkN87iy86qz8swDKOyO3ExkZGR6tKlixYtWiRJKiwsVFhYmEaPHq2JEydecXuXyyWbzaacnBxZrdYS9YH/tKIm4oMZ5a0sPn+rKuYmAKVR2se0oOSK+/lbJY8c5eXlKS0tTZMmTTLXeXt7KyoqSqmpqRfdJjc3V7m5uebrnJwcSb/9IkqqMPfXEm8LVFXNxq6o7C642TUturK7gDJW9LlbRb97KzHmJgCldak5+HJzc3nN2+fPvzdOWXvR9TVJceemKhmO/vvf/6qgoEAhISFu60NCQvT9999fdJuZM2dq2rRpF6wPCwsrlz4CKBu2+ZXdA5SXkydPymazVXY3ygxzE4Ca5FLzb02fl680N1XJcFQSkyZN0rhx48zXhYWFOn78uBo1aiQvLy+P9+dyuRQWFqZDhw7VuNNCioPxM37Gz/hLOn7DMHTy5EmFhoaWQ++qF+amssX4GT/jr73jl0r3Oyju3FQlw9FVV10lHx8fZWVlua3PysqS3W6/6DYWi0UWi8VtXWBgYKn7YrVaa+1fQInxM37Gz/hLNv6adMSoCHNT1cH4GT/jr73jl0r+OyjO3ORdkg6VNz8/P0VERGj9+vXmusLCQq1fv14Oh6MSewYAqK2YmwCg5quSR44kady4cRo6dKg6d+6sm2++WfPnz9fp06f12GOPVXbXAAC1FHMTANRsVTYcPfjggzp27Jji4+PldDrVsWNHrVmz5oILYcuLxWLRlClTLjgdorZg/Iyf8TP+2jr+y2FuqlyMn/Ez/to7fqlifgdV9jlHAAAAAFCRquQ1RwAAAABQ0QhHAAAAACDCEQAAAABIIhwBAAAAgKRaHo4SEhJ0zTXXyN/fX5GRkdq+fftl61esWKFWrVrJ399f7dq10yeffFJBPS0fnoz/jTfeULdu3dSwYUM1bNhQUVFRV/x9VXWe/vkXWbZsmby8vNS/f//y7WA583T82dnZiouLU5MmTWSxWHTDDTdU638Dno5//vz5atmypQICAhQWFqaxY8fq7NmzFdTbsrV582bdfffdCg0NlZeXl1atWnXFbTZu3KhOnTrJYrGoRYsWSkxMLPd+1lbMTcxNzE3MTcxNlTg3GbXUsmXLDD8/P+Ott94ydu/ebTzxxBNGYGCgkZWVddH6r776yvDx8TFmzZpl7Nmzx5g8ebJRp04dIyMjo4J7XjY8Hf/DDz9sJCQkGN98843x3XffGY8++qhhs9mMn3/+uYJ7XjY8HX+RgwcPGldffbXRrVs34957762YzpYDT8efm5trdO7c2bjrrruML7/80jh48KCxceNGIz09vYJ7XjY8HX9SUpJhsViMpKQk4+DBg8batWuNJk2aGGPHjq3gnpeNTz75xHj++eeNDz74wJBkrFy58rL1Bw4cMOrWrWuMGzfO2LNnj7Fw4ULDx8fHWLNmTcV0uBZhbmJuYm5ibmJuqty5qdaGo5tvvtmIi4szXxcUFBihoaHGzJkzL1r/wAMPGDExMW7rIiMjjSeffLJc+1lePB3/7507d85o0KCB8c4775RXF8tVScZ/7tw545ZbbjGWLFliDB06tFpPQJ6O/7XXXjOuvfZaIy8vr6K6WK48HX9cXJzRq1cvt3Xjxo0zbr311nLtZ0UozgQ0fvx4o23btm7rHnzwQSM6Oroce1Y7MTcxNzE3MTcVYW5aedma8pqbauVpdXl5eUpLS1NUVJS5ztvbW1FRUUpNTb3oNqmpqW71khQdHX3J+qqsJOP/vV9//VX5+fkKCgoqr26Wm5KOf/r06QoODtawYcMqopvlpiTj/+ijj+RwOBQXF6eQkBDdeOONmjFjhgoKCiqq22WmJOO/5ZZblJaWZp7ecODAAX3yySe66667KqTPla0mff5VZcxNzE3MTcxNzE3FV16ff76l2rqa+u9//6uCgoILnmgeEhKi77///qLbOJ3Oi9Y7nc5y62d5Kcn4f2/ChAkKDQ294C9ldVCS8X/55Zd68803lZ6eXgE9LF8lGf+BAwe0YcMGDRo0SJ988on279+vP/7xj8rPz9eUKVMqottlpiTjf/jhh/Xf//5Xt912mwzD0Llz5zRy5Eg999xzFdHlSnepzz+Xy6UzZ84oICCgknpWszA3MTcxNzE3MTcVX3nNTbXyyBFK56WXXtKyZcu0cuVK+fv7V3Z3yt3Jkyc1ePBgvfHGG7rqqqsquzuVorCwUMHBwXr99dcVERGhBx98UM8//7wWL15c2V2rEBs3btSMGTP06quv6uuvv9YHH3yg5ORkvfDCC5XdNQD/H3NT7cPcxNxUHmrlkaOrrrpKPj4+ysrKcluflZUlu91+0W3sdrtH9VVZScZf5OWXX9ZLL72kzz77TO3bty/PbpYbT8f/ww8/6Mcff9Tdd99trissLJQk+fr6au/evbruuuvKt9NlqCR//k2aNFGdOnXk4+NjrmvdurWcTqfy8vLk5+dXrn0uSyUZ///93/9p8ODBGj58uCSpXbt2On36tEaMGKHnn39e3t41+3umS33+Wa1WjhqVIeYm5ibmJuYm5qbiK6+5qWb/1i7Bz89PERERWr9+vbmusLBQ69evl8PhuOg2DofDrV6SUlJSLllflZVk/JI0a9YsvfDCC1qzZo06d+5cEV0tF56Ov1WrVsrIyFB6erq53HPPPerZs6fS09MVFhZWkd0vtZL8+d96663av3+/OfFK0r///W81adKkWk0+UsnG/+uvv14wyRRNxr9dN1qz1aTPv6qMuYm5ibmJuYm5qfjK7fOvVLdzqMaWLVtmWCwWIzEx0dizZ48xYsQIIzAw0HA6nYZhGMbgwYONiRMnmvVfffWV4evra7z88svGd999Z0yZMqXa3y7Vk/G/9NJLhp+fn/HPf/7TOHLkiLmcPHmysoZQKp6O//eq+x2BPB1/Zmam0aBBA2PUqFHG3r17jdWrVxvBwcHGiy++WFlDKBVPxz9lyhSjQYMGxj/+8Q/jwIEDxrp164zrrrvOeOCBByprCKVy8uRJ45tvvjG++eYbQ5Ixd+5c45tvvjF++uknwzAMY+LEicbgwYPN+qLbpT777LPGd999ZyQkJHAr73LC3MTcxNzE3MTcVLlzU60NR4ZhGAsXLjSaNWtm+Pn5GTfffLOxdetWs+322283hg4d6lb//vvvGzfccIPh5+dntG3b1khOTq7gHpctT8bfvHlzQ9IFy5QpUyq+42XE0z//81X3CcgwPB//li1bjMjISMNisRjXXnut8Ze//MU4d+5cBfe67Hgy/vz8fGPq1KnGddddZ/j7+xthYWHGH//4R+PEiRMV3/Ey8Pnnn1/033PRmIcOHWrcfvvtF2zTsWNHw8/Pz7j22muNt99+u8L7XVswNzE3MTcxNzE3Vd7c5GUYteC4GwAAAABcQa285ggAAAAAfo9wBAAAAAAiHAEAAACAJMIRAAAAAEgiHAEAAACAJMIRAAAAAEgiHAEAAACAJMIRAAAAAEgiHAEAAACAJMIRAAAAAEgiHAEAAACAJMIRAAAAAEiS/h/NDAVfsNoIcQAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#plot the histogram of the signal and the image\n", + "plt.figure(figsize=(10,5))\n", + "plt.subplot(1,2,1)\n", + "plt.hist(image_0[0,...].flatten(),bins=100)\n", + "plt.title(\"Image T=0 GT\")\n", + "plt.subplot(1,2,2)\n", + "plt.hist(signal[0,...].flatten(),bins=100)\n", + "plt.title(\"Image T=7 Input\") " + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Get Z values from LVAE, convert them into clean using R()" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "True\n" + ] + } + ], + "source": [ + "print(model_LVAE.mode_pred)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-0.031162493 1.0937392\n" + ] + }, + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'Image T=0 GT')" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "input = torch.from_numpy(np.expand_dims(signal,0)).cuda()\n", + "y = torch.from_numpy(np.expand_dims(signal,0)).cuda()\n", + "out = model_LVAE(input,y)\n", + "img = out['out_img'].detach().cpu().numpy()[0,0,...]\n", + "plt.figure(figsize=(5, 5))\n", + "plt.imshow(img,cmap='magma')\n", + "print(img.min(),img.max())\n", + "\n", + "#plot a histogram of the output\n", + "plt.figure(figsize=(10,5))\n", + "plt.subplot(1,2,1)\n", + "plt.hist(img.flatten(),bins=10)\n", + "plt.title(\"Image T=0 GT\")" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Compute PSNRs" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "signal shape: torch.Size([1, 128, 128])\n", + "image_0 shape: torch.Size([1, 128, 128])\n", + "img shape: torch.Size([1, 128, 128])\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "BRISQUE Score: 10.857231440144773\n" + ] + } + ], + "source": [ + "from ra_psnr import RangeInvariantPsnr as PSNR\n", + "from brisque import BRISQUE\n", + "\n", + "#convert all the images to torch tensors\n", + "signal = torch.Tensor(signal)\n", + "image_0 = torch.Tensor(image_0)\n", + "img = torch.Tensor(img)\n", + "img = img.unsqueeze(0)\n", + "\n", + "print('signal shape: ', signal.shape)\n", + "print('image_0 shape: ', image_0.shape)\n", + "print('img shape: ', img.shape)\n", + "\n", + "#compute the PSNR\n", + "psnr_unet = PSNR(image_0, img)\n", + "\n", + "#plot the images in a grid\n", + "fig, ax = plt.subplots(1, 3, figsize=(25, 25))\n", + "ax[0].imshow(signal[0], cmap='magma')\n", + "ax[0].set_title('T=7 Input')\n", + "\n", + "ax[1].imshow(img[0], cmap='magma')\n", + "ax[1].set_title('UNet T=7 -> T=0')\n", + "ax[1].set_xlabel('PSNR: ' + str(psnr_unet.item()))\n", + "\n", + "\n", + "ax[2].imshow(image_0[0], cmap='magma')\n", + "ax[2].set_title('T=0 GT')\n", + "plt.show()\n", + "out_new_3 = np.repeat(img,3,axis=0)\n", + "out_new_3 = np.transpose(out_new_3,(1,2,0))\n", + "obj = BRISQUE(url=False)\n", + "bri_out = obj.score(out_new_3)\n", + "print(\"BRISQUE Score: \",bri_out)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### MMSE of 100 samples" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "PSNR: 30.043071746826172\n", + "PSNR: 31.68590545654297\n", + "PSNR: 30.37914276123047\n", + "PSNR: 31.38597869873047\n", + "PSNR: 30.985689163208008\n", + "PSNR: 31.825450897216797\n", + "PSNR: 30.172922134399414\n", + "PSNR: 30.649505615234375\n", + "PSNR: 31.264293670654297\n", + "PSNR: 30.82338523864746\n", + "PSNR: 30.29872703552246\n", + "PSNR: 29.846384048461914\n", + "PSNR: 30.516563415527344\n", + "PSNR: 30.586772918701172\n", + "PSNR: 30.563718795776367\n", + "PSNR: 31.448768615722656\n", + "PSNR: 31.37790298461914\n", + "PSNR: 29.8060245513916\n", + "PSNR: 31.902544021606445\n", + "PSNR: 30.76786994934082\n", + "PSNR: 30.654935836791992\n", + "PSNR: 32.546051025390625\n", + "PSNR: 29.57863998413086\n", + "PSNR: 30.479969024658203\n", + "PSNR: 29.82609748840332\n", + "PSNR: 29.912872314453125\n", + "PSNR: 32.00138854980469\n", + "PSNR: 31.919267654418945\n", + "PSNR: 29.075275421142578\n", + "PSNR: 30.060688018798828\n", + "PSNR: 30.755369186401367\n", + "PSNR: 32.96156311035156\n", + "PSNR: 31.195833206176758\n", + "PSNR: 31.479310989379883\n", + "PSNR: 32.26576614379883\n", + "PSNR: 30.78696060180664\n", + "PSNR: 29.56454086303711\n", + "PSNR: 30.118694305419922\n", + "PSNR: 30.332805633544922\n", + "PSNR: 30.788936614990234\n", + "PSNR: 30.208904266357422\n", + "PSNR: 29.803552627563477\n", + "PSNR: 29.712820053100586\n", + "PSNR: 31.9449462890625\n", + "PSNR: 31.676685333251953\n", + "PSNR: 31.49134635925293\n", + "PSNR: 29.74199676513672\n", + "PSNR: 30.954612731933594\n", + "PSNR: 31.39765739440918\n", + "PSNR: 30.606870651245117\n", + "PSNR: 31.329212188720703\n", + "PSNR: 30.444255828857422\n", + "PSNR: 30.53004264831543\n", + "PSNR: 31.16271209716797\n", + "PSNR: 29.17374038696289\n", + "PSNR: 31.06374740600586\n", + "PSNR: 32.657867431640625\n", + "PSNR: 30.350460052490234\n", + "PSNR: 29.973735809326172\n", + "PSNR: 31.683473587036133\n", + "PSNR: 31.3597412109375\n", + "PSNR: 29.65129852294922\n", + "PSNR: 31.33001136779785\n", + "PSNR: 29.382484436035156\n", + "PSNR: 30.789411544799805\n", + "PSNR: 30.603126525878906\n", + "PSNR: 30.61549949645996\n", + "PSNR: 29.559932708740234\n", + "PSNR: 30.773935317993164\n", + "PSNR: 30.240272521972656\n", + "PSNR: 30.202877044677734\n", + "PSNR: 30.39792823791504\n", + "PSNR: 31.670757293701172\n", + "PSNR: 30.028186798095703\n", + "PSNR: 30.431045532226562\n", + "PSNR: 30.199661254882812\n", + "PSNR: 30.127944946289062\n", + "PSNR: 29.94239044189453\n", + "PSNR: 30.933135986328125\n", + "PSNR: 30.241981506347656\n", + "PSNR: 31.449005126953125\n", + "PSNR: 30.998676300048828\n", + "PSNR: 29.741275787353516\n", + "PSNR: 30.523710250854492\n", + "PSNR: 32.75361251831055\n", + "PSNR: 33.05546188354492\n", + "PSNR: 29.934738159179688\n", + "PSNR: 29.331344604492188\n", + "PSNR: 29.503908157348633\n", + "PSNR: 30.690540313720703\n", + "PSNR: 31.60590362548828\n", + "PSNR: 30.556072235107422\n", + "PSNR: 29.784103393554688\n", + "PSNR: 29.779033660888672\n", + "PSNR: 29.893266677856445\n", + "PSNR: 32.59778594970703\n", + "PSNR: 29.414588928222656\n", + "PSNR: 30.92306137084961\n", + "PSNR: 32.07377624511719\n", + "PSNR: 30.337501525878906\n", + "Mean PSNR: 30.71973217010498\n" + ] + } + ], + "source": [ + "#read all the images in the folder\n", + "path = \"/group/jug/Anirban/Datasets/TalleySim_1024/test/\"\n", + "files = glob.glob(path+\"/*.tif\")\n", + "files.sort()\n", + "psnrs = 0\n", + "for file in files:\n", + " input = imread(file)[7:8,...].astype(\"float32\")\n", + " target = imread(file)[0:1,...].astype(\"float32\")\n", + " input = torch.from_numpy(np.expand_dims(input,0)).cuda()\n", + " y = input\n", + " #do it 10 times\n", + " outs = []\n", + " for i in range(10):\n", + " out = model_LVAE(input,y)\n", + " img = out['out_img'].detach().cpu().numpy()[0,0,...]\n", + " outs.append(img)\n", + " #make outs a torch tensor\n", + " outs = torch.Tensor(outs)\n", + " mean_out = torch.mean(outs,dim=0)\n", + " #compute the PSNR\n", + " psnr_unet = PSNR(torch.Tensor(target), mean_out)\n", + " psnrs += psnr_unet.item()\n", + " print(\"PSNR: \",psnr_unet.item())\n", + "print(\"Mean PSNR: \",psnrs/len(files))" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.9.7 ('pytorch')", + "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.9.7" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "777931fff02ad60022c6585a049b0eda05d772d5cefd408029ca33f474e52fed" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/inference.py b/inference.py new file mode 100644 index 0000000..3c4dd86 --- /dev/null +++ b/inference.py @@ -0,0 +1,88 @@ +import os +import glob +import random +import numpy as np +import math +import time +import datetime +import torch +import torch.nn as nn +import torch.nn.functional as F +import torch.optim as optim +from torch.utils.data import TensorDataset +from torch.utils.data import Dataset, DataLoader +from torchvision.utils import save_image +from torch.nn import init +from torch.optim.optimizer import Optimizer +from torch.cuda.amp import GradScaler + +from tifffile import imread +from matplotlib import pyplot as plt +from tqdm import tqdm + +from boilerplate import boilerplate +from models.lvae import LadderVAE +import lib.utils as utils + +import warnings +warnings.filterwarnings('ignore') +# We import all our dependencies. +import numpy as np +import torch +import sys +from models.lvae import LadderVAE +from lib.gaussianMixtureNoiseModel import GaussianMixtureNoiseModel +from boilerplate import boilerplate +import lib.utils as utils +from tifffile import imread +from matplotlib import pyplot as plt +from tqdm import tqdm +import wandb +use_cuda = torch.cuda.is_available() +device = torch.device("cuda" if use_cuda else "cpu") + +# Data-specific +gaussian_noise_std = None #changed from 0 to None +#noise_model_params= np.load("data/GMMNoiseModel_convallaria_3_2_calibration.npz") +noiseModel = None #GaussianMixtureNoiseModel(params = noise_model_params, device = device) +image_size = 128 +image_shape = (image_size, image_size) + +# Training-specific +batch_size = 5 +virtual_batch = 20 +lr=1e-4 +max_epochs = 500 +steps_per_epoch = 300 +test_batch_size=1 + +# Model-specific +num_latents = 5 +z_dims = [64]*int(num_latents) #TODO what is this? +#z_dims = [32,16,8,8] +blocks_per_layer = 5 +batchnorm = True +free_bits = 1.0 +use_uncond_mode_at=[] + + +from data import Dataset +from pathlib import Path + +data_mean = 0.0 +data_std = 1.0 + + +model = LadderVAE(z_dims=z_dims,blocks_per_layer=blocks_per_layer,data_mean=data_mean,data_std=data_std,noiseModel=noiseModel, + device=device,batchnorm=batchnorm,free_bits=free_bits,img_shape=image_shape, + use_uncond_mode_at=use_uncond_mode_at).cuda() +model = torch.load("./Trained_model/model/TalleyLines_best_vae.net") +model.mode_pred=True +model.eval() + +path = "/group/jug/Anirban/Datasets/TalleySim_1024/test/confocal_au_3000.tif" +# The test data is just one quater of the full image ([:,:512,:512]) following the works which have used this data earlier +observation = imread(path)[0:1,...].astype("float32") +signal=observation#np.mean(observation[:,...],axis=0)[np.newaxis,...] +img_width, img_height = signal.shape[1], signal.shape[2] +out = model(torch.from_numpy(np.expand_dims(signal,0)).cuda()) diff --git a/lib/gaussianMixtureNoiseModel.py b/lib/gaussianMixtureNoiseModel.py index 33fb5d1..2f29f39 100644 --- a/lib/gaussianMixtureNoiseModel.py +++ b/lib/gaussianMixtureNoiseModel.py @@ -7,12 +7,14 @@ from scipy.stats import norm from tifffile import imread + def fastShuffle(series, num): length = series.shape[0] for i in range(num): series = series[np.random.permutation(length),:] return series + class GaussianMixtureNoiseModel: """The GaussianMixtureNoiseModel class describes a noise model which is parameterized as a mixture of gaussians. If you would like to initialize a new object from scratch, then set `params`= None and specify the other parameters as keyword arguments. If you are instead loading a model, use only `params`. @@ -51,7 +53,7 @@ class GaussianMixtureNoiseModel: """ def __init__(self, **kwargs): - if(kwargs.get('params') is None): + if (kwargs.get('params') is None): weight=kwargs.get('weight') n_gaussian=kwargs.get('n_gaussian') n_coeff=kwargs.get('n_coeff') @@ -80,7 +82,7 @@ def __init__(self, **kwargs): self.max_signal=torch.Tensor(params['max_signal']).to(self.device) self.weight=torch.Tensor(params['trained_weight']).to(self.device) - self.min_sigma=np.asscalar(params['min_sigma']) + self.min_sigma=np.ndarray.item(params['min_sigma']) self.n_gaussian=self.weight.shape[0]//3 self.n_coeff=self.weight.shape[1] self.tol=torch.Tensor([1e-10]).to(self.device) @@ -107,7 +109,7 @@ def polynomialRegressor(self, weightParams, signals): """ value=0 for i in range(weightParams.shape[0]): - value += weightParams[i] * (((signals - self.min_signal) / (self.max_signal - self.min_signal)) ** i); + value += weightParams[i] * (((signals - self.min_signal) / (self.max_signal - self.min_signal)) ** i) return value diff --git a/lib/likelihoods.py b/lib/likelihoods.py index 38b71c8..44544e2 100644 --- a/lib/likelihoods.py +++ b/lib/likelihoods.py @@ -5,7 +5,8 @@ from torch import nn from torch.distributions import Normal from torch.nn import functional as F - +from typing import Type, Union + class LikelihoodModule(nn.Module): def distr_params(self, x): @@ -26,15 +27,15 @@ def sample(params): def log_likelihood(self, x, params): pass - def forward(self, input_, x): - distr_params = self.distr_params(input_) + def forward(self, out, y): + distr_params = self.distr_params(out) mean = self.mean(distr_params) mode = self.mode(distr_params) sample = self.sample(distr_params) - if x is None: + if y is None: ll = None else: - ll = self.log_likelihood(x, distr_params) + ll = self.log_likelihood(y, distr_params) dct = { 'mean': mean, 'mode': mode, @@ -43,25 +44,33 @@ def forward(self, input_, x): } return ll, dct + +class GaussianLikelihood(LikelihoodModule): -class NoiseModelLikelihood(LikelihoodModule): - - def __init__(self, ch_in, color_channels, - data_mean, data_std, noiseModel): + def __init__(self, ch_in, color_channels, logvar_clip, conv_mult=2, lvclip=False, lv_type='pixelwise'): super().__init__() - self.parameter_net = nn.Conv2d(ch_in, - color_channels, + + conv_type: Type[Union[nn.Conv2d, nn.Conv3d]] = getattr(nn, f'Conv{conv_mult}d') + self.parameter_net = conv_type(ch_in, + 2 * color_channels, kernel_size=3, padding=1) - self.data_mean = data_mean - self.data_std = data_std - self.noiseModel = noiseModel - + self.logvar_clip = logvar_clip + self.lvclip = lvclip + self.lv_type = lv_type + #out goes here def distr_params(self, x): x = self.parameter_net(x) - # mean, lv = x.chunk(2, dim=1) - mean = x - lv = None + + if self.lv_type == 'pixelwise': + mean, lv = x.chunk(2, dim=1) #pixelwise mean and logvar + elif self.lv_type == 'global': + mean, lv = get_mean_lv(x) + + #clipping situation + if self.lvclip == True: + lv = torch.clip(lv, min=-self.logvar_clip, max=self.logvar_clip) + params = { 'mean': mean, 'logvar': lv, @@ -78,37 +87,98 @@ def mode(params): @staticmethod def sample(params): - # p = Normal(params['mean'], (params['logvar'] / 2).exp()) - # return p.rsample() - return params['mean'] + p = Normal(params['mean'], (params['logvar'] / 2).exp()) + return p.rsample() - def log_likelihood(self, x, params): - predicted_s_denormalized = params['mean'] * self.data_std + self.data_mean - x_denormalized = x * self.data_std + self.data_mean - predicted_s_cloned = predicted_s_denormalized - predicted_s_reduced = predicted_s_cloned.permute(1,0,2,3) + def log_likelihood(self, y, params): + logprob = log_normal(y, params['mean'], params['logvar'], reduce='none') + return logprob - x_cloned = x_denormalized - x_cloned = x_cloned.permute(1,0,2,3) - x_reduced = x_cloned[0,...] - likelihoods=self.noiseModel.likelihood(x_reduced,predicted_s_reduced) - logprob=torch.log(likelihoods) - return logprob - - -class GaussianLikelihood(LikelihoodModule): +def log_normal(x, mean, logvar, reduce='none', eps=1e-6): + """ + Log of the probability density of the values x under the Normal + distribution with parameters mean and logvar. The sum is taken over all + dimensions except for the first one (assumed to be batch). Reduction + is applied at the end. + :param x: tensor of points, with shape (batch, channels, dim1, dim2) + :param mean: tensor with mean of distribution, shape + (batch, channels, dim1, dim2) + :param logvar: tensor with log-variance of distribution, shape has to be + either scalar or broadcastable + :param reduce: reduction over batch: 'mean' | 'sum' | 'none' + :return: + """ + logvar = _input_check(x, mean, logvar, reduce) + var = torch.exp(logvar) + log_prob = -0.5 * (((x - mean)**2) / var + logvar + torch.tensor(2 * math.pi).log()) + #log_prob = log_prob.sum((1, 2, 3)) + return _reduce(log_prob, reduce) + +def _input_check(x, mean, scale_param, reduce): + assert x.dim() == 4 + assert x.size() == mean.size() + if scale_param.numel() == 1: + scale_param = scale_param.view(1, 1, 1, 1) + if reduce not in ['mean', 'sum', 'none']: + msg = "unrecognized reduction method '{}'".format(reduce) + raise RuntimeError(msg) + return scale_param + +def _reduce(x, reduce): + if reduce == 'mean': + x = x.mean() + elif reduce == 'sum': + x = x.sum() + return x + +#from Ashesh +def get_mean_lv(x, predict_logvar='global', logvar_lowerbound=None): + if predict_logvar is not None: + # pixelwise mean and logvar + mean, lv = x.chunk(2, dim=1) + if predict_logvar in ['channelwise', 'global']: + if predict_logvar == 'channelwise': + # logvar should be of the following shape (batch,num_channels). Other dims would be singletons. + N = np.prod(lv.shape[:2]) + new_shape = (*mean.shape[:2], *([1] * len(mean.shape[2:]))) + elif predict_logvar == 'global': + # logvar should be of the following shape (batch). Other dims would be singletons. + N = lv.shape[0] + new_shape = (*mean.shape[:1], *([1] * len(mean.shape[1:]))) + else: + raise ValueError(f"Invalid value for self.predict_logvar:{predict_logvar}") + + lv = torch.mean(lv.reshape(N, -1), dim=1) + lv = lv.reshape(new_shape) + + if logvar_lowerbound is not None: + lv = torch.clip(lv, min=logvar_lowerbound) + else: + mean = x + lv = None + return mean, lv + + +class GaussianLikelihood_HDN(LikelihoodModule): + + ''' + Description: Gaussian likelihood - def __init__(self, ch_in, color_channels): + ''' + #TODO might need to change this to the original + # https://github.com/addtt/ladder-vae-pytorch/blob/master/lib/likelihoods.py + + def __init__(self, ch_in, color_channels, conv_mult=2): super().__init__() - self.parameter_net = nn.Conv2d(ch_in, + + conv_type: Type[Union[nn.Conv2d, nn.Conv3d]] = getattr(nn, f'Conv{conv_mult}d') + self.parameter_net = conv_type(ch_in, color_channels, kernel_size=3, padding=1) - def distr_params(self, x): x = self.parameter_net(x) - # mean, lv = x.chunk(2, dim=1) mean = x lv = None params = { @@ -133,28 +203,5 @@ def sample(params): def log_likelihood(self, x, params): logprob = -0.5 *(params['mean']-x)**2 -# logprob = log_normal(x, params['mean'], params['logvar'], reduce='none') - return logprob - - -def log_normal(x, mean, logvar, reduce='mean'): - """ - Log of the probability density of the values x untder the Normal - distribution with parameters mean and logvar. The sum is taken over all - dimensions except for the first one (assumed to be batch). Reduction - is applied at the end. - :param x: tensor of points, with shape (batch, channels, dim1, dim2) - :param mean: tensor with mean of distribution, shape - (batch, channels, dim1, dim2) - :param logvar: tensor with log-variance of distribution, shape has to be - either scalar or broadcastable - :param reduce: reduction over batch: 'mean' | 'sum' | 'none' - :return: - """ - - logvar = _input_check(x, mean, logvar, reduce) - var = torch.exp(logvar) - log_prob = -0.5 * (( - (x - mean)**2) / var + logvar + torch.tensor(2 * math.pi).log()) - log_prob = log_prob.sum((1, 2, 3)) - return _reduce(log_prob, reduce) \ No newline at end of file + #logprob = log_normal(x, params['mean'], params['logvar'], reduce='none') + return logprob \ No newline at end of file diff --git a/lib/nn.py b/lib/nn.py index 973e904..61618e8 100644 --- a/lib/nn.py +++ b/lib/nn.py @@ -1,5 +1,11 @@ import torch from torch import nn +from torch.utils.checkpoint import checkpoint, checkpoint_sequential +from typing import Type, Union + + +def no_cp(func, inp): + return func(inp) class ResidualBlock(nn.Module): @@ -25,78 +31,86 @@ class ResidualBlock(nn.Module): def __init__(self, channels, + conv_mult, nonlin, kernel=None, groups=1, batchnorm=True, block_type=None, dropout=None, - gated=None): + gated=None, + grad_checkpoint=False): super().__init__() if kernel is None: kernel = self.default_kernel_size elif isinstance(kernel, int): kernel = (kernel, kernel) elif len(kernel) != 2: - raise ValueError( - "kernel has to be None, int, or an iterable of length 2") + raise ValueError("kernel has to be None, int, or an iterable of length 2") assert all([k % 2 == 1 for k in kernel]), "kernel sizes have to be odd" kernel = list(kernel) pad = [k // 2 for k in kernel] - self.gated = gated + dropout = dropout if not grad_checkpoint else None + self.cp = checkpoint if grad_checkpoint else no_cp + #TODO Might need to update batchnorm stats calculation for grad checkpointing + conv_layer: Type[Union[nn.Conv2d, nn.Conv3d]] = getattr(nn, f'Conv{conv_mult}d') + batchnorm_layer_type: Type[Union[nn.BatchNorm2d, nn.BatchNorm3d]] = getattr(nn, f'BatchNorm{conv_mult}d') + dropout_layer_type: Type[Union[nn.Dropout2d, nn.Dropout3d]] = getattr(nn, f'Dropout{conv_mult}d') modules = [] if block_type == 'cabdcabd': for i in range(2): - conv = nn.Conv2d(channels, - channels, - kernel[i], - padding=pad[i], - groups=groups) + conv = conv_layer(channels, + channels, + kernel[i], + padding=pad[i], + groups=groups) modules.append(conv) modules.append(nonlin()) if batchnorm: - modules.append(nn.BatchNorm2d(channels)) + modules.append(batchnorm_layer_type(channels)) if dropout is not None: - modules.append(nn.Dropout2d(dropout)) + modules.append(dropout_layer_type(dropout)) elif block_type == 'bacdbac': for i in range(2): if batchnorm: - modules.append(nn.BatchNorm2d(channels)) + modules.append(batchnorm_layer_type(channels)) modules.append(nonlin()) - conv = nn.Conv2d(channels, - channels, - kernel[i], - padding=pad[i], - groups=groups) + conv = conv_layer(channels, + channels, + kernel[i], + padding=pad[i], + groups=groups) modules.append(conv) if dropout is not None and i == 0: - modules.append(nn.Dropout2d(dropout)) + modules.append(dropout_layer_type(dropout)) elif block_type == 'bacdbacd': for i in range(2): if batchnorm: - modules.append(nn.BatchNorm2d(channels)) + modules.append(batchnorm_layer_type(channels)) modules.append(nonlin()) - conv = nn.Conv2d(channels, - channels, - kernel[i], - padding=pad[i], - groups=groups) + conv = conv_layer(channels, + channels, + kernel[i], + padding=pad[i], + groups=groups) modules.append(conv) - modules.append(nn.Dropout2d(dropout)) + if dropout is not None: + modules.append(dropout_layer_type(dropout)) else: raise ValueError("unrecognized block type '{}'".format(block_type)) if gated: - modules.append(GateLayer2d(channels, 1, nonlin)) + modules.append(GateLayer(channels, 1, conv_layer, nonlin)) self.block = nn.Sequential(*modules) - def forward(self, x): - return self.block(x) + x + def forward(self, inp): + return self.cp(self.block, inp) + inp + class ResidualGatedBlock(ResidualBlock): @@ -105,17 +119,17 @@ def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs, gated=True) -class GateLayer2d(nn.Module): +class GateLayer(nn.Module): """ Double the number of channels through a convolutional layer, then use half the channels as gate for the other half. """ - def __init__(self, channels, kernel_size, nonlin=nn.LeakyReLU): + def __init__(self, channels, kernel_size, conv_type, nonlin=nn.LeakyReLU): super().__init__() assert kernel_size % 2 == 1 pad = kernel_size // 2 - self.conv = nn.Conv2d(channels, 2 * channels, kernel_size, padding=pad) + self.conv = conv_type(channels, 2 * channels, kernel_size, padding=pad) self.nonlin = nonlin() def forward(self, x): diff --git a/lib/stochastic.py b/lib/stochastic.py index e87af34..3000385 100644 --- a/lib/stochastic.py +++ b/lib/stochastic.py @@ -2,9 +2,10 @@ from torch import nn from torch.distributions import kl_divergence from torch.distributions.normal import Normal +from typing import Type, Union -class NormalStochasticBlock2d(nn.Module): +class NormalStochasticConvBlock(nn.Module): """ Transform input parameters to q(z) with a convolution, optionally do the same for p(z), then sample z ~ q(z) and return conv(z). @@ -12,7 +13,7 @@ class NormalStochasticBlock2d(nn.Module): If q's parameters are not given, do the same but sample from p(z). """ - def __init__(self, c_in, c_vars, c_out, kernel=3, transform_p_params=True): + def __init__(self, c_in, c_vars, c_out, conv_mult, kernel=3, transform_p_params=True): super().__init__() assert kernel % 2 == 1 pad = kernel // 2 @@ -21,10 +22,12 @@ def __init__(self, c_in, c_vars, c_out, kernel=3, transform_p_params=True): self.c_out = c_out self.c_vars = c_vars + conv_type: Type[Union[nn.Conv2d, nn.Conv3d]] = getattr(nn, f'Conv{conv_mult}d') + if transform_p_params: - self.conv_in_p = nn.Conv2d(c_in, 2 * c_vars, kernel, padding=pad) - self.conv_in_q = nn.Conv2d(c_in, 2 * c_vars, kernel, padding=pad) - self.conv_out = nn.Conv2d(c_vars, c_out, kernel, padding=pad) + self.conv_in_p = conv_type(c_in, 2 * c_vars, kernel, padding=pad) + self.conv_in_q = conv_type(c_in, 2 * c_vars, kernel, padding=pad) + self.conv_out = conv_type(c_vars, c_out, kernel, padding=pad) def forward(self, p_params, @@ -41,7 +44,8 @@ def forward(self, if self.transform_p_params: p_params = self.conv_in_p(p_params) else: - assert p_params.size(1) == 2 * self.c_vars + #TODO better assertion logic + assert max(p_params.shape) == 2 * self.c_vars # Define p(z) p_mu, p_lv = p_params.chunk(2, dim=1) @@ -52,7 +56,6 @@ def forward(self, q_params = self.conv_in_q(q_params) q_mu, q_lv = q_params.chunk(2, dim=1) q = Normal(q_mu, (q_lv / 2).exp()) - # Sample from q(z) sampling_distrib = q else: @@ -70,7 +73,7 @@ def forward(self, # z = sampling_distrib.rsample() else: z = sampling_distrib.rsample() - else: + else: z = sampling_distrib.rsample() else: z = forced_latent @@ -86,15 +89,16 @@ def forward(self, # Compute log p(z) if mode_pred is False: - logprob_p = p.log_prob(z).sum((1, 2, 3)) - else: + #Summing over all dims but batch + logprob_p = p.log_prob(z).sum(list(range(1, z.dim()))) + else: logprob_p = None if q_params is not None: # Compute log q(z) - logprob_q = q.log_prob(z).sum((1, 2, 3)) - + logprob_q = q.log_prob(z).sum(list(range(1, z.dim()))) + if mode_pred is False: # if not predicting # Compute KL (analytical or MC estimate) kl_analytical = kl_divergence(q, p) @@ -102,7 +106,7 @@ def forward(self, kl_elementwise = kl_analytical else: kl_elementwise = kl_normal_mc(z, p_params, q_params) - kl_samplewise = kl_elementwise.sum((1, 2, 3)) + kl_samplewise = kl_elementwise.sum(list(range(1, z.dim()))) # Compute spatial KL analytically (but conditioned on samples from # previous layers) @@ -148,3 +152,153 @@ def kl_normal_mc(z, p_mulv, q_mulv): p_distrib = Normal(p_mu, p_std) q_distrib = Normal(q_mu, q_std) return q_distrib.log_prob(z) - p_distrib.log_prob(z) + +""" +Adapted from https://github.com/juglab/HDN/blob/e30edf7ec2cd55c902e469b890d8fe44d15cbb7e/lib/stochastic.py +""" +class NonStochasticBlock2d(nn.Module): + """ + Non-stochastic version of the NormalStochasticBlock2d + """ + + def __init__(self, + c_in: int, + c_vars: int, + c_out, + kernel: int = 3, + groups=1, + conv2d_bias: bool = True, + transform_p_params: bool = True): + """ + Args: + c_in: This is the channel count of the tensor input to this module. + c_vars: This is the size of the latent space + c_out: Output of the stochastic layer. Note that this is different from z. + kernel: kernel used in convolutional layers. + transform_p_params: p_params are transformed if this is set to True. + """ + super().__init__() + assert kernel % 2 == 1 + pad = kernel // 2 + self.transform_p_params = transform_p_params + self.c_in = c_in + self.c_out = c_out + self.c_vars = c_vars + + if transform_p_params: + self.conv_in_p = nn.Conv2d(c_in, 2 * c_vars, kernel, padding=pad, bias=conv2d_bias, groups=groups) + self.conv_in_q = nn.Conv2d(c_in, 2 * c_vars, kernel, padding=pad, bias=conv2d_bias, groups=groups) + self.conv_out = nn.Conv2d(c_vars, c_out, kernel, padding=pad, bias=conv2d_bias, groups=groups) + + def compute_kl_metrics(self, p, p_params, q, q_params, mode_pred, analytical_kl, z): + """ + Compute KL (analytical or MC estimate) and then process it in multiple ways. + """ + + kl_dict = { + 'kl_elementwise': None, # (batch, ch, h, w) + 'kl_samplewise': None, # (batch, ) + 'kl_spatial': None, # (batch, h, w) + 'kl_channelwise': None # (batch, ch) + } + return kl_dict + + def process_p_params(self, p_params, var_clip_max): + if self.transform_p_params: + p_params = self.conv_in_p(p_params) + else: + + assert p_params.size(1) == 2 * self.c_vars, f'{p_params.shape} {self.c_vars}' + + # Define p(z) + p_mu, p_lv = p_params.chunk(2, dim=1) + return p_mu, None + + def process_q_params(self, q_params, var_clip_max, allow_oddsizes=False): + # Define q(z) + q_params = self.conv_in_q(q_params) + q_mu, q_lv = q_params.chunk(2, dim=1) + + if q_mu.shape[-1] % 2 == 1 and allow_oddsizes is False: + q_mu = F.center_crop(q_mu, q_mu.shape[-1] - 1) + + return q_mu, None + + def forward(self, + p_params: torch.Tensor, + q_params: torch.Tensor = None, + forced_latent: Union[None, torch.Tensor] = None, + use_mode: bool = False, + force_constant_output: bool = False, + analytical_kl: bool = False, + mode_pred: bool = False, + use_uncond_mode: bool = False, + var_clip_max: Union[None, float] = None): + """ + Args: + p_params: this is passed from top layers. + q_params: this is the merge of bottom up layer at this level and top down layers above this level. + forced_latent: If this is a tensor, then in stochastic layer, we don't sample by using p() & q(). We simply + use this as the latent space sampling. + use_mode: If it is true, we still don't sample from the q(). We simply + use the mean of the distribution as the latent space. + force_constant_output: This ensures that only the first sample of the batch is used. Typically used + when infernce_mode is False + analytical_kl: If True, typical KL divergence is calculated. Otherwise, a one-sample approximate of it is + calculated. + mode_pred: If True, then only prediction happens. Otherwise, KL divergence loss also gets computed. + use_uncond_mode: Used only when mode_pred=True + var_clip_max: This is the maximum value the log of the variance of the latent vector for any layer can reach. + + """ + + debug_qvar_max = 0 + assert (forced_latent is None) or (not use_mode) + + p_mu, _ = self.process_p_params(p_params, var_clip_max) + + p_params = (p_mu, None) + + if q_params is not None: + # At inference time, just don't centercrop the q_params even if they are odd in size. + q_mu, _ = self.process_q_params(q_params, var_clip_max, allow_oddsizes=mode_pred is True) + q_params = (q_mu, None) + debug_qvar_max = torch.Tensor([1]).to(q_mu.device) + # Sample from q(z) + sampling_distrib = q_mu + q_size = q_mu.shape[-1] + if p_mu.shape[-1] != q_size and mode_pred is False: + p_mu.centercrop_to_size(q_size) + else: + # Sample from p(z) + sampling_distrib = p_mu + + # Generate latent variable (typically by sampling) + z = sampling_distrib + + # Copy one sample (and distrib parameters) over the whole batch. + # This is used when doing experiment from the prior - q is not used. + if force_constant_output: + z = z[0:1].expand_as(z).clone() + p_params = (p_params[0][0:1].expand_as(p_params[0]).clone(), + p_params[1][0:1].expand_as(p_params[1]).clone()) + + # Output of stochastic layer + out = self.conv_out(z) + + kl_dict = {} + logprob_q = None + logprob_p = None + + data = kl_dict + data['z'] = z # sampled variable at this layer (batch, ch, h, w) + data['p_params'] = p_params # (b, ch, h, w) where b is 1 or batch size + data['q_params'] = q_params # (batch, ch, h, w) + data['logprob_q'] = logprob_q # (batch, ) + data['logprob_p'] = logprob_p # (batch, ) + data['qvar_max'] = debug_qvar_max + data['kl_elementwise'] = None + data['kl_samplewise'] = None + data['kl_spatial'] = None + + return out, data \ No newline at end of file diff --git a/lib/utils.py b/lib/utils.py index c7b3416..2a3bde1 100644 --- a/lib/utils.py +++ b/lib/utils.py @@ -5,8 +5,10 @@ from tqdm import tqdm from glob import glob from sklearn.feature_extraction import image +from skimage.util import view_as_windows from matplotlib import pyplot as plt + class Interpolate(nn.Module): """Wrapper for torch.nn.functional.interpolate.""" @@ -30,6 +32,7 @@ def forward(self, x): align_corners=self.align_corners) return out + class CropImage(nn.Module): """Crops image to given size. Args: @@ -58,6 +61,7 @@ def normalize(img, mean, std): """ return (img - mean)/std + def denormalize(img, mean, std): """Denormalize an array of images with mean and standard deviation. Parameters @@ -71,6 +75,7 @@ def denormalize(img, mean, std): """ return (img * std) + mean + def convertToFloat32(train_images,val_images): """Converts the data to float 32 bit type. Parameters @@ -84,6 +89,7 @@ def convertToFloat32(train_images,val_images): x_val = val_images.astype('float32') return x_train, x_val + def getMeanStdData(train_images,val_images): """Compute mean and standrad deviation of data. Parameters @@ -99,6 +105,7 @@ def getMeanStdData(train_images,val_images): mean, std = np.mean(data), np.std(data) return mean, std + def convertNumpyToTensor(numpy_array): """Convert numpy array to PyTorch tensor. Parameters @@ -108,24 +115,24 @@ def convertNumpyToTensor(numpy_array): """ return torch.from_numpy(numpy_array) -def augment_data(X_train): - """Augment data by 8-fold with 90 degree rotations and flips. - Parameters - ---------- - X_train: numpy array - Array of training images. - """ - X_ = X_train.copy() - X_train_aug = np.concatenate((X_train, np.rot90(X_, 1, (1, 2)))) - X_train_aug = np.concatenate((X_train_aug, np.rot90(X_, 2, (1, 2)))) - X_train_aug = np.concatenate((X_train_aug, np.rot90(X_, 3, (1, 2)))) - X_train_aug = np.concatenate((X_train_aug, np.flip(X_train_aug, axis=1))) +def augment_data(patches): + if len(patches.shape[1:]) == 2: + augmented = np.concatenate((patches, + np.rot90(patches, k=1, axes=(1, 2)), + np.rot90(patches, k=2, axes=(1, 2)), + np.rot90(patches, k=3, axes=(1, 2)))) + elif len(patches.shape[1:]) == 3: + augmented = np.concatenate((patches, + np.rot90(patches, k=1, axes=(2, 3)), + np.rot90(patches, k=2, axes=(2, 3)), + np.rot90(patches, k=3, axes=(2, 3)))) + + augmented = np.concatenate((augmented, np.flip(augmented, axis=-2))) + return augmented - print('Raw image size after augmentation', X_train_aug.shape) - return X_train_aug -def extract_patches(x,patch_size,num_patches): +def extract_patches(x, patch_size, num_patches): """Deterministically extract patches from array of images. Parameters ---------- @@ -136,17 +143,22 @@ def extract_patches(x,patch_size,num_patches): num_patches: int Number of patches to be extracted from each image. """ - patches = np.zeros(shape=(x.shape[0]*num_patches,patch_size,patch_size)) + patches = np.zeros(shape=(x.shape[0]*num_patches, patch_size, patch_size)) for i in tqdm(range(x.shape[0])): - patches[i*num_patches:(i+1)*num_patches] = image.extract_patches_2d(x[i],(patch_size,patch_size), num_patches, - random_state=i) + patches[i*num_patches:(i+1)*num_patches] = image.extract_patches_2d(image=x[i], + patch_size=(patch_size, patch_size), + max_patches=num_patches, + random_state=i) + return patches + + def crop_img_tensor(x, size) -> torch.Tensor: """Crops a tensor. - Crops a tensor of shape (batch, channels, h, w) to new height and width + Crops a tensor of shape (batch, channels, h, w) or (batch, channels, d, h, w) to new height and width given by a tuple. Args: x (torch.Tensor): Input image @@ -159,35 +171,45 @@ def crop_img_tensor(x, size) -> torch.Tensor: def _pad_crop_img(x, size, mode) -> torch.Tensor: """ Pads or crops a tensor. - Pads or crops a tensor of shape (batch, channels, h, w) to new height + Pads or crops a tensor of shape (batch, channels, h, w) or (batch, channels, d, h, w) to new height and width given by a tuple. Args: x (torch.Tensor): Input image - size (list or tuple): Desired size (height, width) + size (list or tuple): Desired size (depth: opt, height, width) mode (str): Mode, either 'pad' or 'crop' Returns: The padded or cropped tensor """ - - assert x.dim() == 4 and len(size) == 2 + assert x.dim() in [4, 5], 'Invalid input array dimension' + assert len(size) in [2, 3], 'Invalid input depth dimension' + # assert size = tuple(size) - x_size = x.size()[2:4] + x_size = x.size()[2:] + if mode == 'pad': - cond = x_size[0] > size[0] or x_size[1] > size[1] + cond = any(x_size) > any(size) elif mode == 'crop': - cond = x_size[0] < size[0] or x_size[1] < size[1] + cond = any(x_size) < any(size) else: - raise ValueError("invalid mode '{}'".format(mode)) + raise ValueError(f'invalid mode {mode}') + if cond: - raise ValueError('trying to {} from size {} to size {}'.format( - mode, x_size, size)) - dr, dc = (abs(x_size[0] - size[0]), abs(x_size[1] - size[1])) - dr1, dr2 = dr // 2, dr - (dr // 2) - dc1, dc2 = dc // 2, dc - (dc // 2) + raise ValueError(f'trying to {mode} from size {x_size} to size {size}') + + padding = [] + for d in reversed(range(len(x_size))): + pad_val = abs(x_size[d] - size[d]) + padding.append(pad_val // 2) + padding.append(pad_val - (pad_val // 2)) + if mode == 'pad': - return nn.functional.pad(x, [dc1, dc2, dr1, dr2, 0, 0, 0, 0]) + return nn.functional.pad(x, padding) elif mode == 'crop': - return x[:, :, dr1:x_size[0] - dr2, dc1:x_size[1] - dc2] + if len(x_size) == 2: + return x[:, :, padding[2]:x_size[0] - padding[3], padding[0]:x_size[1] - padding[1]] + elif len(x_size) == 3: + return x[:, :, padding[4]:x_size[0] - padding[5], padding[2]:x_size[1] - padding[3], + padding[0]:x_size[2] - padding[1]] def free_bits_kl(kl, diff --git a/model.py b/model.py new file mode 100644 index 0000000..2251e2e --- /dev/null +++ b/model.py @@ -0,0 +1,393 @@ +import math +import torch +import torch.nn as nn + + +class EMA(): + def __init__(self, beta): + super().__init__() + self.beta = beta + + def update_model_average(self, ma_model, current_model): + for current_params, ma_params in zip(current_model.parameters(), ma_model.parameters()): + old_weight, up_weight = ma_params.data, current_params.data + ma_params.data = self.update_average(old_weight, up_weight) + + def update_average(self, old, new): + if old is None: + return new + return old * self.beta + (1 - self.beta) * new + +def get_timestep_embedding(timesteps, embedding_dim): + """ + This matches the implementation in Denoising Diffusion Probabilistic Models: + From Fairseq. + Build sinusoidal embeddings. + This matches the implementation in tensor2tensor, but differs slightly + from the description in Section 3.5 of "Attention Is All You Need". + """ + assert len(timesteps.shape) == 1 + + half_dim = embedding_dim // 2 + emb = math.log(10000) / (half_dim - 1) + emb = torch.exp(torch.arange(half_dim, dtype=torch.float32) * -emb) + emb = emb.to(device=timesteps.device) + emb = timesteps.float()[:, None] * emb[None, :] + emb = torch.cat([torch.sin(emb), torch.cos(emb)], dim=1) + if embedding_dim % 2 == 1: # zero pad + emb = torch.nn.functional.pad(emb, (0,1,0,0)) + return emb + + +def nonlinearity(x): + # swish + return x*torch.sigmoid(x) + + +def Normalize(in_channels): + return torch.nn.GroupNorm(num_groups=32, num_channels=in_channels, eps=1e-6, affine=True) + + +class Upsample(nn.Module): + def __init__(self, in_channels, with_conv): + super().__init__() + self.with_conv = with_conv + if self.with_conv: + self.conv = torch.nn.Conv2d(in_channels, + in_channels, + kernel_size=3, + stride=1, + padding=1) + + def forward(self, x): + x = torch.nn.functional.interpolate(x, scale_factor=2.0, mode="nearest") + if self.with_conv: + x = self.conv(x) + return x + + +class Downsample(nn.Module): + def __init__(self, in_channels, with_conv): + super().__init__() + self.with_conv = with_conv + if self.with_conv: + # no asymmetric padding in torch conv, must do it ourselves + self.conv = torch.nn.Conv2d(in_channels, + in_channels, + kernel_size=3, + stride=2, + padding=0) + + def forward(self, x): + if self.with_conv: + pad = (0,1,0,1) + x = torch.nn.functional.pad(x, pad, mode="constant", value=0) + x = self.conv(x) + else: + x = torch.nn.functional.avg_pool2d(x, kernel_size=2, stride=2) + return x + + +class ResnetBlock(nn.Module): + def __init__(self, *, in_channels, out_channels=None, conv_shortcut=False, + dropout, temb_channels=512): + super().__init__() + self.in_channels = in_channels + out_channels = in_channels if out_channels is None else out_channels + self.out_channels = out_channels + self.use_conv_shortcut = conv_shortcut + + self.norm1 = Normalize(in_channels) + self.conv1 = torch.nn.Conv2d(in_channels, + out_channels, + kernel_size=3, + stride=1, + padding=1) + self.temb_proj = torch.nn.Linear(temb_channels, + out_channels) + self.norm2 = Normalize(out_channels) + self.dropout = torch.nn.Dropout(dropout) + self.conv2 = torch.nn.Conv2d(out_channels, + out_channels, + kernel_size=3, + stride=1, + padding=1) + if self.in_channels != self.out_channels: + if self.use_conv_shortcut: + self.conv_shortcut = torch.nn.Conv2d(in_channels, + out_channels, + kernel_size=3, + stride=1, + padding=1) + else: + self.nin_shortcut = torch.nn.Conv2d(in_channels, + out_channels, + kernel_size=1, + stride=1, + padding=0) + + def forward(self, x, temb): + h = x + h = self.norm1(h) + h = nonlinearity(h) + h = self.conv1(h) + + h = h + self.temb_proj(nonlinearity(temb))[:,:,None,None] + + h = self.norm2(h) + h = nonlinearity(h) + h = self.dropout(h) + h = self.conv2(h) + + if self.in_channels != self.out_channels: + if self.use_conv_shortcut: + x = self.conv_shortcut(x) + else: + x = self.nin_shortcut(x) + + return x+h + + +class AttnBlock(nn.Module): + def __init__(self, in_channels): + super().__init__() + self.in_channels = in_channels + + self.norm = Normalize(in_channels) + self.q = torch.nn.Conv2d(in_channels, + in_channels, + kernel_size=1, + stride=1, + padding=0) + self.k = torch.nn.Conv2d(in_channels, + in_channels, + kernel_size=1, + stride=1, + padding=0) + self.v = torch.nn.Conv2d(in_channels, + in_channels, + kernel_size=1, + stride=1, + padding=0) + self.proj_out = torch.nn.Conv2d(in_channels, + in_channels, + kernel_size=1, + stride=1, + padding=0) + + + def forward(self, x): + h_ = x + h_ = self.norm(h_) + q = self.q(h_) + k = self.k(h_) + v = self.v(h_) + + # compute attention + b,c,h,w = q.shape + q = q.reshape(b,c,h*w) + q = q.permute(0,2,1) # b,hw,c + k = k.reshape(b,c,h*w) # b,c,hw + w_ = torch.bmm(q,k) # b,hw,hw w[b,i,j]=sum_c q[b,i,c]k[b,c,j] + w_ = w_ * (int(c)**(-0.5)) + w_ = torch.nn.functional.softmax(w_, dim=2) + + # attend to values + v = v.reshape(b,c,h*w) + w_ = w_.permute(0,2,1) # b,hw,hw (first hw of k, second of q) + h_ = torch.bmm(v,w_) # b, c,hw (hw of q) h_[b,c,j] = sum_i v[b,c,i] w_[b,i,j] + h_ = h_.reshape(b,c,h,w) + + h_ = self.proj_out(h_) + + return x+h_ + + +class Model(nn.Module): + def __init__(self, *, ch, out_ch, ch_mult=(1,2,4,8), num_res_blocks, + attn_resolutions, dropout=0.0, resamp_with_conv=True, in_channels, + resolution): + super().__init__() + self.ch = ch + self.temb_ch = self.ch*4 + self.num_resolutions = len(ch_mult) + self.num_res_blocks = num_res_blocks + self.resolution = resolution + self.in_channels = in_channels + + # timestep embedding + self.temb = nn.Module() + self.temb.dense = nn.ModuleList([ + torch.nn.Linear(self.ch, + self.temb_ch), + torch.nn.Linear(self.temb_ch, + self.temb_ch), + ]) + + # downsampling + self.conv_in = torch.nn.Conv2d(in_channels, + self.ch, + kernel_size=3, + stride=1, + padding=1) + + curr_res = resolution + in_ch_mult = (1,)+ch_mult + self.down = nn.ModuleList() + for i_level in range(self.num_resolutions): + block = nn.ModuleList() + attn = nn.ModuleList() + block_in = ch*in_ch_mult[i_level] + block_out = ch*ch_mult[i_level] + for i_block in range(self.num_res_blocks): + if i_level > 0 and i_block == 0: + block_in += 32 + block.append(ResnetBlock(in_channels=block_in, + out_channels=block_out, + temb_channels=self.temb_ch, + dropout=dropout)) + block_in = block_out + if curr_res in attn_resolutions: + attn.append(AttnBlock(block_in)) + down = nn.Module() + down.block = block + down.attn = attn + if i_level != self.num_resolutions-1: + down.downsample = Downsample(block_in, resamp_with_conv) + curr_res = curr_res // 2 + self.down.append(down) + + # middle + self.mid = nn.Module() + self.mid.block_1 = ResnetBlock(in_channels=block_in, + out_channels=block_in, + temb_channels=self.temb_ch, + dropout=dropout) + self.mid.attn_1 = AttnBlock(block_in) + self.mid.block_2 = ResnetBlock(in_channels=block_in, + out_channels=block_in, + temb_channels=self.temb_ch, + dropout=dropout) + + # upsampling + self.up = nn.ModuleList() + for i_level in reversed(range(self.num_resolutions)): + block = nn.ModuleList() + attn = nn.ModuleList() + block_out = ch*ch_mult[i_level] + skip_in = ch*ch_mult[i_level] + for i_block in range(self.num_res_blocks+1): + if i_block == self.num_res_blocks: + skip_in = ch*in_ch_mult[i_level] + + if i_level > 0 and i_block == 2: + skip_in += 32 + + #print(i_level, i_block, block_in, skip_in, block_out) + + block.append(ResnetBlock(in_channels=block_in+skip_in, + out_channels=block_out, + temb_channels=self.temb_ch, + dropout=dropout)) + block_in = block_out + if curr_res in attn_resolutions: + attn.append(AttnBlock(block_in)) + up = nn.Module() + up.block = block + up.attn = attn + if i_level != 0: + up.upsample = Upsample(block_in, resamp_with_conv) + curr_res = curr_res * 2 + self.up.insert(0, up) # prepend to get consistent order + + # end + self.norm_out = Normalize(block_in) + self.conv_out = torch.nn.Conv2d(block_in, + out_ch, + kernel_size=3, + stride=1, + padding=1) + + self.conv_out_levels = nn.ModuleList() + for i_level in reversed(range(1, self.num_resolutions)): + self.conv_out_levels.append(torch.nn.Conv2d(ch*ch_mult[i_level], + out_channels=32, + kernel_size=1, + stride=1, + )) + + #print(self.conv_out_levels) + + + def forward(self, X, t): + + assert X[0].shape[2] == X[0].shape[3] == self.resolution + + x = X[0] + + # timestep embedding + temb = get_timestep_embedding(t, self.ch) + temb = self.temb.dense[0](temb) + temb = nonlinearity(temb) + temb = self.temb.dense[1](temb) + + # downsampling + hs = [self.conv_in(x)] + for i_level in range(self.num_resolutions): + for i_block in range(self.num_res_blocks): + # we are also concatenating the input z from various levels + if i_level > 0 and i_block == 0: + #print(hs[-1].shape, X[i_level].shape) + hs[-1] = torch.cat([hs[-1], X[i_level]], dim=1) + h = self.down[i_level].block[i_block](hs[-1], temb) + if len(self.down[i_level].attn) > 0: + h = self.down[i_level].attn[i_block](h) + hs.append(h) + if i_level != self.num_resolutions-1: + hs.append(self.down[i_level].downsample(hs[-1])) + + #for i in hs: + # print(i.shape) + #print("mid") + + # middle + h = hs[-1] + h = self.mid.block_1(h, temb) + h = self.mid.attn_1(h) + h = self.mid.block_2(h, temb) + + + #in the upsampling part, store the tensor befre each upsampling in a list + #print("upsampling") + up_hs = [] + + + # upsampling + for i_level in reversed(range(self.num_resolutions)): + for i_block in range(self.num_res_blocks+1): + h = self.up[i_level].block[i_block]( + torch.cat([h, hs.pop()], dim=1), temb) + if len(self.up[i_level].attn) > 0: + h = self.up[i_level].attn[i_block](h) + + if i_level > 0 and i_block == self.num_res_blocks: + up_hs.append(h) + if i_level != 0: + h = self.up[i_level].upsample(h) + + up_hs_out = [] + for i in range(len(up_hs)): + up_hs_out.append(self.conv_out_levels[i](up_hs[i])) + + # end + h = self.norm_out(h) + h = nonlinearity(h) + h = self.conv_out(h) + + up_hs_out.reverse() + up_hs_out.insert(0,h) + + #for i in range(len(up_hs_out)): + # print(up_hs_out[i].shape) + + return up_hs_out #h \ No newline at end of file diff --git a/models/lvae.py b/models/lvae.py index 15b05b3..1633695 100644 --- a/models/lvae.py +++ b/models/lvae.py @@ -1,15 +1,31 @@ import numpy as np import torch from torch import nn - -from lib.likelihoods import (GaussianLikelihood, - NoiseModelLikelihood) +from typing import Type, Union +import math +import matplotlib.pyplot as plt +from lib.likelihoods import * from lib.utils import (crop_img_tensor, pad_img_tensor, Interpolate, free_bits_kl) from .lvae_layers import (TopDownLayer, BottomUpLayer, TopDownDeterministicResBlock, BottomUpDeterministicResBlock) +#add positional encoding to each conv layer +class SinusoidalPositionEmbeddings(nn.Module): + def __init__(self, dim): + super().__init__() + self.dim = dim + + def forward(self, time): + device = time.device + half_dim = self.dim // 2 + embeddings = math.log(10000) / (half_dim - 1) + embeddings = torch.exp(torch.arange(half_dim, device=device) * -embeddings) + embeddings = time[:, None] * embeddings[None, :] + embeddings = torch.cat((embeddings.sin(), embeddings.cos()), dim=-1) + return embeddings + class LadderVAE(nn.Module): def __init__(self, @@ -17,35 +33,49 @@ def __init__(self, device, data_mean, data_std, + blocks_per_layer, + n_filters, color_ch=1, noiseModel=None, - blocks_per_layer=5, - nonlin='elu', + conv_mult=2, + nonlin=nn.ELU, merge_type='residual', batchnorm=True, stochastic_skip=True, - n_filters=64, dropout=0.2, free_bits=0.0, learn_top_prior=True, img_shape=None, res_block_type='bacdbacd', gated=True, + grad_checkpoint=False, no_initial_downscaling=True, analytical_kl=True, mode_pred=False, - use_uncond_mode_at=[]): + use_uncond_mode_at=[], + likelihood_form='GaussianLikelihood', + logvar_clip = -1, + lvclip=False, + lvtype='pixelwise', + stochasticity=True): + super().__init__() self.color_ch = color_ch self.z_dims = z_dims self.blocks_per_layer = blocks_per_layer + # Get class of convolutional layer + self.conv_mult = conv_mult + self.conv_type: Type[Union[nn.Conv2d, nn.Conv3d]] = getattr(nn, f'Conv{self.conv_mult}d') + self.up_conv_type: Type[Union[nn.ConvTranspose2d, nn.ConvTranspose3d]] = getattr(nn, f'ConvTranspose{self.conv_mult}d') + # Get class of nonlinear activation from string description + self.nonlin: Type[Union[nn.ReLU, nn.LeakyReLU, nn.ELU, nn.SELU]] = nonlin self.n_layers = len(self.z_dims) self.stochastic_skip = stochastic_skip self.n_filters = n_filters self.dropout = dropout self.free_bits = free_bits self.learn_top_prior = learn_top_prior - self.img_shape = tuple(img_shape) + self.input_array_shape = tuple(img_shape) self.res_block_type = res_block_type self.gated = gated self.device = device @@ -56,15 +86,20 @@ def __init__(self, self.use_uncond_mode_at=use_uncond_mode_at self._global_step = 0 - assert(self.data_std is not None) - assert(self.data_mean is not None) - if self.noiseModel is None: - self.likelihood_form = "gaussian" - else: - self.likelihood_form = "noise_model" + self.likelihood_form = likelihood_form + self.logvar_clip = logvar_clip + self.lvclip = lvclip + self.lvtype = lvtype + self.stochasticity = stochasticity + + assert self.data_std is not None, 'Data std is not specified' + assert self.data_mean is not None, 'Data mean is not specified' + assert self.conv_mult in [2, 3], 'Please specify correct conv layers dimension, 2 or 3' + assert self.color_ch in [1, 3], 'Please specify correct number of input channels' self.downsample = [1]*self.n_layers + # Downsample by a factor of 2 at each downsampling operation self.overall_downscale_factor = np.power(2, sum(self.downsample)) if not no_initial_downscaling: # by default do another downscaling @@ -73,27 +108,21 @@ def __init__(self, assert max(self.downsample) <= self.blocks_per_layer assert len(self.downsample) == self.n_layers - # Get class of nonlinear activation from string description - nonlin = { - 'relu': nn.ReLU, - 'leakyrelu': nn.LeakyReLU, - 'elu': nn.ELU, - 'selu': nn.SELU, - }[nonlin] - # First bottom-up layer: change num channels + downsample by factor 2 # unless we want to prevent this stride = 1 if no_initial_downscaling else 2 self.first_bottom_up = nn.Sequential( - nn.Conv2d(color_ch, n_filters, 5, padding=2, stride=stride), - nonlin(), + self.conv_type(color_ch, n_filters[0], 5, padding=2, stride=stride), + self.nonlin(), BottomUpDeterministicResBlock( - c_in=n_filters, - c_out=n_filters, - nonlin=nonlin, + c_in=n_filters[0], + c_out=n_filters[0], + conv_mult=self.conv_mult, + nonlin=self.nonlin, batchnorm=batchnorm, dropout=dropout, res_block_type=res_block_type, + grad_checkpoint=grad_checkpoint )) # Init lists of layers @@ -111,13 +140,16 @@ def __init__(self, self.bottom_up_layers.append( BottomUpLayer( n_res_blocks=self.blocks_per_layer, - n_filters=n_filters, - downsampling_steps=self.downsample[i], - nonlin=nonlin, + n_filters_in=n_filters[i], + n_filters_out=n_filters[i+1], + downsampling_steps=self.downsample[i], + conv_mult=self.conv_mult, + nonlin=self.nonlin, batchnorm=batchnorm, dropout=dropout, res_block_type=res_block_type, gated=gated, + grad_checkpoint=grad_checkpoint )) # Add top-down stochastic layer at level i. @@ -136,19 +168,23 @@ def __init__(self, TopDownLayer( z_dim=z_dims[i], n_res_blocks=blocks_per_layer, - n_filters=n_filters, + n_filters_in=n_filters[i+1], + n_filters_out=n_filters[i], is_top_layer=is_top, downsampling_steps=self.downsample[i], - nonlin=nonlin, + conv_mult=self.conv_mult, + nonlin=self.nonlin, merge_type=merge_type, batchnorm=batchnorm, dropout=dropout, stochastic_skip=stochastic_skip, learn_top_prior=learn_top_prior, - top_prior_param_shape=self.get_top_prior_param_shape(), + top_prior_param_shape=self.get_top_prior_param_shape(dim=self.conv_mult), res_block_type=res_block_type, gated=gated, + grad_checkpoint=grad_checkpoint, analytical_kl=analytical_kl, + stochasticity=self.stochasticity )) # Final top-down layer @@ -158,25 +194,26 @@ def __init__(self, for i in range(blocks_per_layer): modules.append( TopDownDeterministicResBlock( - c_in=n_filters, - c_out=n_filters, - nonlin=nonlin, + c_in=n_filters[0], + c_out=n_filters[0], + conv_mult=self.conv_mult, + nonlin=self.nonlin, batchnorm=batchnorm, dropout=dropout, res_block_type=res_block_type, gated=gated, + grad_checkpoint=grad_checkpoint )) - self.final_top_down = nn.Sequential(*modules) + + self.final_top_down = nn.Sequential(*modules) + # Define likelihood - if self.likelihood_form == 'gaussian': - self.likelihood = GaussianLikelihood(n_filters, color_ch) - elif self.likelihood_form == 'noise_model': - self.likelihood = NoiseModelLikelihood(n_filters, color_ch, data_mean, - data_std, noiseModel) - else: - msg = "Unrecognized likelihood '{}'".format(likelihood_form) - raise RuntimeError(msg) + if self.likelihood_form == "GaussianLikelihood": + self.likelihood = GaussianLikelihood(n_filters[0], color_ch, logvar_clip, conv_mult, lvclip=self.lvclip, lv_type=self.lvtype) + elif self.likelihood_form == "GaussianLikelihood_HDN": + self.likelihood = GaussianLikelihood_HDN(n_filters[0], color_ch, conv_mult) + def increment_global_step(self): """Increments global step by 1.""" @@ -187,11 +224,11 @@ def global_step(self) -> int: """Global step.""" return self._global_step - def forward(self, x): + def forward(self, x,y): img_size = x.size()[2:] - # Pad input to make everything easier with conv strides - x_pad = self.pad_input(x) + # Pad input to make everything easier with conv strides + x_pad = self.pad_input(x, self.conv_mult) # Bottom-up inference: return list of length n_layers (bottom to top) bu_values = self.bottomup_pass(x_pad) @@ -201,28 +238,27 @@ def forward(self, x): # Restore original image size out = crop_img_tensor(out, img_size) - + # Log likelihood and other info (per data point) - ll, likelihood_info = self.likelihood(out, x) + ll, likelihood_info = self.likelihood(out,y) - if self.mode_pred is False: + if self.stochasticity is True and self.mode_pred is False: # kl[i] for each i has length batch_size # resulting kl shape: (batch_size, layers) - kl = torch.cat([kl_layer.unsqueeze(1) for kl_layer in td_data['kl']], - dim=1) - + kl = torch.cat([kl_layer.unsqueeze(1) for kl_layer in td_data['kl']], dim=1) kl_sep = kl.sum(1) kl_avg_layerwise = kl.mean(0) kl_loss = free_bits_kl(kl, self.free_bits).sum() # sum over layers kl = kl_sep.mean() else: - kl = None kl_sep = None kl_avg_layerwise = None kl_loss = None kl = None - + output = { + 'top_bu': bu_values, + 'out_img': likelihood_info['sample'], 'll': ll, 'z': td_data['z'], 'kl': kl, @@ -250,7 +286,7 @@ def bottomup_pass(self, x): bu_values.append(x) return bu_values - + def topdown_pass(self, bu_values=None, n_img_prior=None, @@ -278,10 +314,11 @@ def topdown_pass(self, msg = ("Prior experiments (e.g. sampling from mode) are not" " compatible with inference mode") raise RuntimeError(msg) - + # Sampled latent variables at each layer z = [None] * self.n_layers + # KL divergence of each layer kl = [None] * self.n_layers @@ -302,7 +339,7 @@ def topdown_pass(self, try: bu_value = bu_values[i] except TypeError: - bu_value = None + bu_value = None # Whether the current layer should be sampled from the mode use_mode = i in mode_layers @@ -325,16 +362,16 @@ def topdown_pass(self, mode_pred=self.mode_pred, use_uncond_mode=use_uncond_mode ) + z[i] = aux['z'] # sampled variable at this layer (batch, ch, h, w) kl[i] = aux['kl_samplewise'] # (batch, ) kl_spatial[i] = aux['kl_spatial'] # (batch, h, w) - if self.mode_pred is False: - logprob_p += aux['logprob_p'].mean() # mean over batch - else: - logprob_p = None + #if self.mode_pred is False: + # logprob_p += aux['logprob_p'].mean() # mean over batch + #else: + # logprob_p = None # Final top-down layer out = self.final_top_down(out) - data = { 'z': z, # list of tensors with shape (batch, ch[i], h[i], w[i]) 'kl': kl, # list of tensors with shape (batch, ) @@ -343,60 +380,127 @@ def topdown_pass(self, 'logprob_p': logprob_p, # scalar, mean over batch } return out, data - - def pad_input(self, x): + + + def pad_input(self, x, dim): """ Pads input x so that its sizes are powers of 2 :param x: :return: Padded tensor """ - size = self.get_padded_size(x.size()) + size = self.get_padded_size(x.size(), dim) #TODO check ! x = pad_img_tensor(x, size) + return x - def get_padded_size(self, size): + def get_padded_size(self, size, dim): """ Returns the smallest size (H, W) of the image with actual size given as input, such that H and W are powers of 2. - :param size: input size, tuple either (N, C, H, w) or (H, W) + :param size: input size, tuple either (N, C, H, W) or (N, C, Z, H, W) or (H, W) or (Z, H, W) :return: 2-tuple (H, W) """ - - # Overall downscale factor from input to top layer (power of 2) + #TODO check!!! + # Overall downscale factor from input to top layer (power of 2) dwnsc = self.overall_downscale_factor - - # Make size argument into (heigth, width) - if len(size) == 4: - size = size[2:] - if len(size) != 2: - msg = ("input size must be either (N, C, H, W) or (H, W), but it " - "has length {} (size={})".format(len(size), size)) + # Make size argument into (heigth, width) or (depth, heigth, width) + if len(size) in [2, 3, 4, 5]: + size = size[-dim:] + else: + msg = f"input size must be either (N, C, H, W) or (N, C, Z, H, W) or (H, W) or (Z, H, W), but it " \ + f"has length {len(size)} (size={size})" raise RuntimeError(msg) # Output smallest powers of 2 that are larger than current sizes padded_size = list(((s - 1) // dwnsc + 1) * dwnsc for s in size) - return padded_size def sample_prior(self, n_imgs, mode_layers=None, constant_layers=None): - + """ + Sample from the prior distribution of the model + :param n_imgs: Number of images to sample + :param mode_layers: List of layers for which to sample from the mode + :param constant_layers: List of layers for which to sample from the + mode and keep the output constant + :return: Tensor of shape (n_imgs, C, H, W) or (n_imgs, C, Z, H, W) + """ # Generate from prior out, _ = self.topdown_pass(n_img_prior=n_imgs, mode_layers=mode_layers, constant_layers=constant_layers) - out = crop_img_tensor(out, self.img_shape) + out = crop_img_tensor(out, self.input_array_shape) # Log likelihood and other info (per data point) _, likelihood_data = self.likelihood(out, None) return likelihood_data['sample'] + + + def sample_prior_forced_latents(self, n_imgs, z_values, mode_layers=None, constant_layers=None): + """ + Sample from the prior distribution of the model + :param n_imgs: Number of images to sample + :param mode_layers: List of layers for which to sample from the mode + :param constant_layers: List of layers for which to sample from the + mode and keep the output constant + :return: Tensor of shape (n_imgs, C, H, W) or (n_imgs, C, Z, H, W) + """ + # Generate from prior + out, _ = self.topdown_pass(n_img_prior=n_imgs, + mode_layers=mode_layers, + constant_layers=constant_layers, + forced_latent=z_values) + out = crop_img_tensor(out, self.input_array_shape) - def get_top_prior_param_shape(self, n_imgs=1): + # Log likelihood and other info (per data point) + _, likelihood_data = self.likelihood(out, None) + + return likelihood_data['sample'] + + def get_top_prior_param_shape(self, dim, n_imgs=1): # TODO num channels depends on random variable we're using dwnsc = self.overall_downscale_factor - sz = self.get_padded_size(self.img_shape) - h = sz[0] // dwnsc - w = sz[1] // dwnsc + sz = self.get_padded_size(self.input_array_shape, dim) c = self.z_dims[-1] * 2 # mu and logvar - top_layer_shape = (n_imgs, c, h, w) + if self.conv_mult == 2: + h = sz[0] // dwnsc + w = sz[1] // dwnsc + top_layer_shape = (n_imgs, c, h, w) + elif self.conv_mult == 3: + z = sz[0] // dwnsc + h = sz[1] // dwnsc + w = sz[2] // dwnsc + assert len(self.input_array_shape) >= 3, 'Depth dimension not specified for input array' + top_layer_shape = (n_imgs, c, z, h, w) + else: + raise AssertionError('Incorrect conv layer dimensions') return top_layer_shape + + def sample_prior_with_top_bu_value(self, + n_imgs, + top_bu_value, + mode_layers=None, + constant_layers=None): + """ + Sample from the prior distribution of the model, using a given value + for the top layer + :param top_bu_value: Value for the top layer + :param mode_layers: List of layers for which to sample from the mode + :param constant_layers: List of layers for which to sample from the + mode and keep the output constant + :return: Tensor of shape (n_imgs, C, H, W) or (n_imgs, C, Z, H, W) + """ + # Generate from prior + out, _ = self.topdown_pass_new(n_img_prior=1, + mode_layers=mode_layers, + constant_layers=constant_layers, + forced_latent=None, + bu_values=[None,None,None,None,top_bu_value], + start_layer=4) + + out = crop_img_tensor(out, self.input_array_shape) + + # Log likelihood and other info (per data point) + _, likelihood_data = self.likelihood(out, None) + + return likelihood_data['sample'] \ No newline at end of file diff --git a/models/lvae_layers.py b/models/lvae_layers.py index ce2ad6a..67bcfca 100644 --- a/models/lvae_layers.py +++ b/models/lvae_layers.py @@ -1,8 +1,10 @@ import torch from torch import nn +from typing import Type, Union from lib.nn import ResidualBlock, ResidualGatedBlock -from lib.stochastic import NormalStochasticBlock2d +from lib.stochastic import NormalStochasticConvBlock, NonStochasticBlock2d +import math class TopDownLayer(nn.Module): @@ -29,9 +31,11 @@ class TopDownLayer(nn.Module): def __init__(self, z_dim, n_res_blocks, - n_filters, + n_filters_in, + n_filters_out, is_top_layer=False, downsampling_steps=None, + conv_mult=2, nonlin=None, merge_type=None, batchnorm=True, @@ -39,9 +43,11 @@ def __init__(self, stochastic_skip=False, res_block_type=None, gated=None, + grad_checkpoint=False, learn_top_prior=False, top_prior_param_shape=None, - analytical_kl=False): + analytical_kl=False, + stochasticity=True): super().__init__() @@ -50,6 +56,7 @@ def __init__(self, self.stochastic_skip = stochastic_skip self.learn_top_prior = learn_top_prior self.analytical_kl = analytical_kl + self.stochasticity = stochasticity # Define top layer prior parameters, possibly learnable if is_top_layer: @@ -63,6 +70,7 @@ def __init__(self, # Define deterministic top-down block: sequence of deterministic # residual blocks with downsampling when needed. block_list = [] + n_filters_in_td = n_filters_in for _ in range(n_res_blocks): do_resample = False if dws_left > 0: @@ -70,46 +78,62 @@ def __init__(self, dws_left -= 1 block_list.append( TopDownDeterministicResBlock( - n_filters, - n_filters, - nonlin, + n_filters_in_td, + n_filters_out, + conv_mult=conv_mult, + nonlin=nonlin, upsample=do_resample, batchnorm=batchnorm, dropout=dropout, res_block_type=res_block_type, gated=gated, + grad_checkpoint=grad_checkpoint )) + n_filters_in_td = n_filters_out self.deterministic_block = nn.Sequential(*block_list) - # Define stochastic block with 2d convolutions - self.stochastic = NormalStochasticBlock2d( - c_in=n_filters, - c_vars=z_dim, - c_out=n_filters, - transform_p_params=(not is_top_layer), - ) + # Define stochastic block with convolutions + if not self.stochasticity: + self.stochastic = NonStochasticBlock2d( + c_in=n_filters_in, + c_vars=z_dim, + c_out=n_filters_in, + transform_p_params=(not is_top_layer), + ) + else: + self.stochastic = NormalStochasticConvBlock( + c_in=n_filters_in, + c_vars=z_dim, + c_out=n_filters_in, + conv_mult=conv_mult, + transform_p_params=(not is_top_layer), + ) if not is_top_layer: # Merge layer, combine bottom-up inference with top-down # generative to give posterior parameters self.merge = MergeLayer( - channels=n_filters, + channels=n_filters_in, merge_type=merge_type, + conv_mult=conv_mult, nonlin=nonlin, batchnorm=batchnorm, dropout=dropout, res_block_type=res_block_type, + grad_checkpoint=grad_checkpoint ) # Skip connection that goes around the stochastic top-down layer if stochastic_skip: self.skip_connection_merger = SkipConnectionMerger( - channels=n_filters, + channels=n_filters_in, + conv_mult=conv_mult, nonlin=nonlin, batchnorm=batchnorm, dropout=dropout, res_block_type=res_block_type, + grad_checkpoint=grad_checkpoint ) def forward(self, @@ -128,19 +152,16 @@ def forward(self, inputs_none = input_ is None and skip_connection_input is None if self.is_top_layer and not inputs_none: raise ValueError("In top layer, inputs should be None") - # If top layer, define parameters of prior p(z_L) if self.is_top_layer: p_params = self.top_prior_params - # Sample specific number of images by expanding the prior if n_img_prior is not None: - p_params = p_params.expand(n_img_prior, -1, -1, -1) + p_params = p_params.expand(n_img_prior, *[-1]*len(p_params.shape[1:])) # TODO check dims! # Else the input from the layer above is the prior parameters else: p_params = input_ - # In inference mode, get parameters of q from inference path, # merging with top-down path if it's not the top layer if inference_mode: @@ -158,6 +179,7 @@ def forward(self, # Sample from either q(z_i | z_{i+1}, x) or p(z_i | z_{i+1}) # depending on whether q_params is None + x, data_stoch = self.stochastic( p_params=p_params, q_params=q_params, @@ -194,13 +216,16 @@ class BottomUpLayer(nn.Module): def __init__(self, n_res_blocks, - n_filters, + n_filters_in, + n_filters_out, downsampling_steps=0, + conv_mult=2, nonlin=None, batchnorm=True, dropout=None, res_block_type=None, - gated=None): + gated=None, + grad_checkpoint=False): super().__init__() bu_blocks = [] @@ -209,17 +234,21 @@ def __init__(self, if downsampling_steps > 0: do_resample = True downsampling_steps -= 1 + bu_blocks.append( BottomUpDeterministicResBlock( - c_in=n_filters, - c_out=n_filters, + c_in=n_filters_in, + c_out=n_filters_out, + conv_mult=conv_mult, nonlin=nonlin, downsample=do_resample, batchnorm=batchnorm, dropout=dropout, res_block_type=res_block_type, gated=gated, + grad_checkpoint=grad_checkpoint )) + n_filters_in = n_filters_out # only first block has different input channels self.net = nn.Sequential(*bu_blocks) def forward(self, x): @@ -249,6 +278,7 @@ def __init__(self, mode, c_in, c_out, + conv_mult=2, nonlin=nn.LeakyReLU, resample=False, res_block_kernel=None, @@ -257,38 +287,46 @@ def __init__(self, res_block_type=None, dropout=None, min_inner_channels=None, - gated=None): + gated=None, + grad_checkpoint=False): + super().__init__() assert mode in ['top-down', 'bottom-up'] if min_inner_channels is None: min_inner_channels = 0 inner_filters = max(c_out, min_inner_channels) + self.in_channesl = c_in + + conv_type: Type[Union[nn.Conv2d, nn.Conv3d]] = getattr(nn, f'Conv{conv_mult}d') + upsample_conv: Type[Union[nn.ConvTranspose2d, nn.ConvTranspose3d]] = getattr(nn, f'ConvTranspose{conv_mult}d') + # Define first conv layer to change channels and/or up/downsample if resample: if mode == 'bottom-up': # downsample - self.pre_conv = nn.Conv2d(in_channels=c_in, + self.pre_conv = conv_type(in_channels=c_in, out_channels=inner_filters, kernel_size=3, padding=1, stride=2, groups=groups) elif mode == 'top-down': # upsample - self.pre_conv = nn.ConvTranspose2d(in_channels=c_in, - out_channels=inner_filters, - kernel_size=3, - padding=1, - stride=2, - groups=groups, - output_padding=1) + self.pre_conv = upsample_conv(in_channels=c_in, + out_channels=inner_filters, + kernel_size=3, + padding=1, + stride=2, + groups=groups, + output_padding=1) elif c_in != inner_filters: - self.pre_conv = nn.Conv2d(c_in, inner_filters, 1, groups=groups) + self.pre_conv = conv_type(c_in, inner_filters, 1, groups=groups) else: self.pre_conv = None # Residual block self.res = ResidualBlock( channels=inner_filters, + conv_mult=conv_mult, nonlin=nonlin, kernel=res_block_kernel, groups=groups, @@ -296,11 +334,12 @@ def __init__(self, dropout=dropout, gated=gated, block_type=res_block_type, + grad_checkpoint=grad_checkpoint ) # Define last conv layer to get correct num output channels if inner_filters != c_out: - self.post_conv = nn.Conv2d(inner_filters, c_out, 1, groups=groups) + self.post_conv = conv_type(inner_filters, c_out, 1, groups=groups) else: self.post_conv = None @@ -329,17 +368,19 @@ def __init__(self, *args, downsample=False, **kwargs): class MergeLayer(nn.Module): """ - Merge two 4D input tensors by concatenating along dim=1 and passing the + Merge two 4D/5D input tensors by concatenating along dim=1 and passing the result through 1) a convolutional 1x1 layer, or 2) a residual block """ def __init__(self, channels, merge_type, + conv_mult=2, nonlin=nn.LeakyReLU, batchnorm=True, dropout=None, - res_block_type=None): + res_block_type=None, + grad_checkpoint=False): super().__init__() try: iter(channels) @@ -350,16 +391,20 @@ def __init__(self, channels = [channels[0]] * 3 assert len(channels) == 3 + conv_type: Type[Union[nn.Conv2d, nn.Conv3d]] = getattr(nn, f'Conv{conv_mult}d') + if merge_type == 'linear': - self.layer = nn.Conv2d(channels[0] + channels[1], channels[2], 1) + self.layer = conv_type(channels[0] + channels[1], channels[2], 1) elif merge_type == 'residual': self.layer = nn.Sequential( - nn.Conv2d(channels[0] + channels[1], channels[2], 1, padding=0), + conv_type(channels[0] + channels[1], channels[2], 1, padding=0), ResidualGatedBlock(channels[2], + conv_mult, nonlin, batchnorm=batchnorm, dropout=dropout, - block_type=res_block_type), + block_type=res_block_type, + grad_checkpoint=grad_checkpoint), ) def forward(self, x, y): @@ -374,10 +419,12 @@ class SkipConnectionMerger(MergeLayer): merge_type = 'residual' - def __init__(self, channels, nonlin, batchnorm, dropout, res_block_type): + def __init__(self, channels, conv_mult, nonlin, batchnorm, dropout, res_block_type, grad_checkpoint=False): super().__init__(channels, self.merge_type, + conv_mult, nonlin, batchnorm, dropout=dropout, - res_block_type=res_block_type) + res_block_type=res_block_type, + grad_checkpoint=grad_checkpoint) diff --git a/psnrs.ipynb b/psnrs.ipynb new file mode 100644 index 0000000..e3cf1d3 --- /dev/null +++ b/psnrs.ipynb @@ -0,0 +1,190 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Make the LVAE model" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'stochasticity' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[1], line 11\u001b[0m\n\u001b[1;32m 9\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39mtifffile\u001b[39;00m \u001b[39mimport\u001b[39;00m imread\n\u001b[1;32m 10\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39mmatplotlib\u001b[39;00m \u001b[39mimport\u001b[39;00m pyplot \u001b[39mas\u001b[39;00m plt\n\u001b[0;32m---> 11\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39mboilerplate\u001b[39;00m \u001b[39mimport\u001b[39;00m boilerplate\n\u001b[1;32m 12\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39mmodels\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mlvae\u001b[39;00m \u001b[39mimport\u001b[39;00m LadderVAE\n", + "File \u001b[0;32m~/Projects/Diffusion_September/HDN_Modular/boilerplate/boilerplate.py:97\u001b[0m\n\u001b[1;32m 88\u001b[0m scheduler \u001b[39m=\u001b[39m optim\u001b[39m.\u001b[39mlr_scheduler\u001b[39m.\u001b[39mReduceLROnPlateau(optimizer,\n\u001b[1;32m 89\u001b[0m \u001b[39m'\u001b[39m\u001b[39mmin\u001b[39m\u001b[39m'\u001b[39m,\n\u001b[1;32m 90\u001b[0m patience\u001b[39m=\u001b[39m\u001b[39m10\u001b[39m,\n\u001b[1;32m 91\u001b[0m factor\u001b[39m=\u001b[39m\u001b[39m0.5\u001b[39m,\n\u001b[1;32m 92\u001b[0m min_lr\u001b[39m=\u001b[39m\u001b[39m1e-12\u001b[39m,\n\u001b[1;32m 93\u001b[0m verbose\u001b[39m=\u001b[39m\u001b[39mTrue\u001b[39;00m)\n\u001b[1;32m 94\u001b[0m \u001b[39mreturn\u001b[39;00m optimizer, scheduler\n\u001b[0;32m---> 97\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mforward_pass\u001b[39m(x, y, device, model, gaussian_noise_std, amp\u001b[39m=\u001b[39m\u001b[39mTrue\u001b[39;00m, stochasticity\u001b[39m=\u001b[39mstochasticity)\u001b[39m-\u001b[39m\u001b[39m>\u001b[39m \u001b[39mdict\u001b[39m:\n\u001b[1;32m 98\u001b[0m x \u001b[39m=\u001b[39m x\u001b[39m.\u001b[39mto(device, non_blocking\u001b[39m=\u001b[39m\u001b[39mTrue\u001b[39;00m)\n\u001b[1;32m 99\u001b[0m y \u001b[39m=\u001b[39m y\u001b[39m.\u001b[39mto(device, non_blocking\u001b[39m=\u001b[39m\u001b[39mTrue\u001b[39;00m)\n", + "\u001b[0;31mNameError\u001b[0m: name 'stochasticity' is not defined" + ] + } + ], + "source": [ + "import numpy as np\n", + "import torch\n", + "from tifffile import imread\n", + "from matplotlib import pyplot as plt\n", + "import warnings\n", + "warnings.filterwarnings('ignore')\n", + "# We import all our dependencies.\n", + "import numpy as np\n", + "from tifffile import imread\n", + "from matplotlib import pyplot as plt\n", + "from boilerplate import boilerplate\n", + "from models.lvae import LadderVAE\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "#brisque of GT\n", + "\n", + "brisq_gt = 30.01\n", + "\n", + "#direct prediction of t0 from t[7,1] R()\n", + "R_psnrs = [30.27, 30.479, 30.915, 31.449, 32.151, 33.561, 36.122]\n", + "R_brisques = [28.177, 27.465, 28.042, 26.102, 26.21, 24.03, 24.222]\n", + "\n", + "#unet prediction of t0 from t[7,1]\n", + "psnr_unet_base = 31.25\n", + "brisq_unet_base = 11.46\n", + "\n", + "#hdn prediction of t0 from t[7,1]\n", + "psnr_hdn_base = 29.53\n", + "psnr_hdn_base_mmse = 29.81\n", + "brisq_hdn_base = 9.44\n", + "\n", + "#the basic HDN + R() + cycleGAN predictions: C1\n", + "psnr_basic_C1 = [24.889, 25.09, 25.3, 25.833, 25.989, 26.358, 26.055]\n", + "brisq_basic_C1 = [15.106, 16.216, 16.266, 20.186, 22.83, 28.796, 29.681]\n", + "psnrs_with_GT_t_C1 = [37.42, 34.045, 31.353, 29.696, 28.161, 26.813, 26.055]\n", + "\n", + "#the basic HDN + R() + cycleGAN predictions + convex combination\n", + "psnr_basic_C2 = [24.353933334350586, 24.458938598632812, 24.761808395385742, 25.148488998413086, 25.853254318237305, 27.442310333251953, 29.438190460205078]\n", + "psnrs_with_GT_t_C2 = [40.824832916259766, 37.94643783569336, 35.49945068359375, 33.05961990356445, 31.28070068359375, 30.08182144165039, 29.438190460205078]\n", + "\n", + "#the basic HDN + R() + cycleGAN predictions + convex combination + fakeness loss\n", + "psnr_basic_C3 = [24.316425323486328, 24.491518020629883, 24.709741592407227, 25.128820419311523, 25.873310089111328, 27.309188842773438, 29.393657684326172]\n", + "psnrs_with_GT_t_C3 = [40.560054779052734, 38.2090950012207, 35.46354675292969, 33.2198486328125, 31.53537368774414, 30.0367431640625, 29.393657684326172]\n", + "\n", + "\n", + "#HDNs\n", + "hdn1 = 30.38 # (Stoc, 5blks, lv=None, nF=64)\n", + "hdn2 = 30.69 # (Stoc, 5blks, lv=None, nF=128)\n", + "hdn3 = 30.93 # (Stoc, 5blks, lv=None, nF=256)\n", + "\n", + "hdn1_ns = 29.97 # (Stoc, 5blks, lv=None, nF=64)\n", + "hdn2_ns = 30.29 # (Stoc, 5blks, lv=None, nF=128)\n", + "hdn3_ns = 30.57 # (Stoc, 5blks, lv=None, nF=256)\n", + "\n", + "#Unet\n", + "unet1 = 31.68 \n" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(12, 8))\n", + "plt.rc('legend',fontsize=10, loc='upper right') # using a size in points\n", + "\n", + "#plot a horizontal line for the brisque of GT\n", + "plt.hlines(unet1, 0, 6, colors='k', linestyles='solid', label='UNet T=0|7')\n", + "plt.hlines(psnr_hdn_base_mmse, 0, 6, colors='y', linestyles='dashed', label='HDN MMSE 100 T=0|7')\n", + "\n", + "plt.hlines(hdn1, 0, 6, colors='g', linestyles='solid', label='(Stoc, 5blks, lv=None, nF=64)')\n", + "plt.hlines(hdn2, 0, 6, colors='r', linestyles='solid', label='(Stoc, 5blks, lv=None, nF=128)')\n", + "plt.hlines(hdn3, 0, 6, colors='b', linestyles='solid', label='(Stoc, 5blks, lv=None, nF=256)')\n", + "\n", + "plt.hlines(hdn1_ns, 0, 6, colors='g', linestyles='dashed', label='(Stoc, 5blks, lv=None, nF=64)')\n", + "plt.hlines(hdn2_ns, 0, 6, colors='r', linestyles='dashed', label='(Stoc, 5blks, lv=None, nF=128)')\n", + "plt.hlines(hdn3_ns, 0, 6, colors='b', linestyles='dashed', label='(Stoc, 5blks, lv=None, nF=256)')\n", + "\n", + "\n", + "plt.xticks(np.arange(0, 7, 1), fontsize=14)\n", + "plt.yticks(np.arange(25, 40, 2),fontsize=14)\n", + "#invert the x axis\n", + "plt.gca().invert_xaxis() #this is because the inference happens by reversing the time steps\n", + "plt.xlabel('Time Step', fontsize=18)\n", + "plt.ylabel('PSNR', fontsize=18)\n", + "#plt.title('PSNR of Unet models and time models vs Existing Sampling using D(;)', fontsize=18)\n", + "plt.legend()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "From HDN and UNet Baselines" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.9.7 ('pytorch')", + "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.9.7" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "777931fff02ad60022c6585a049b0eda05d772d5cefd408029ca33f474e52fed" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/ra_psnr.py b/ra_psnr.py new file mode 100644 index 0000000..b533875 --- /dev/null +++ b/ra_psnr.py @@ -0,0 +1,81 @@ +""" +Computes PSNR of a batch of monochrome images. +NOTE that a numpy version and torch.Tensor version have slightly different values. +e9b29ba0b21f3b5fbd0f915309dcd18ecfee0f55 +""" +import numpy as np +import torch + + +def allow_numpy(func): + """ + All optional arguements are passed as is. positional arguments are checked. if they are numpy array, + they are converted to torch Tensor. + """ + + def numpy_wrapper(*args, **kwargs): + new_args = [] + for arg in args: + if isinstance(arg, np.ndarray): + arg = torch.Tensor(arg) + new_args.append(arg) + new_args = tuple(new_args) + + output = func(*new_args, **kwargs) + return output + + return numpy_wrapper + +def zero_mean(x): + return x - torch.mean(x, dim=1, keepdim=True) + + +def fix_range(gt, x): + a = torch.sum(gt * x, dim=1, keepdim=True) / (torch.sum(x * x, dim=1, keepdim=True)) + return x * a + + +def fix(gt, x): + gt_ = zero_mean(gt) + return fix_range(gt_, zero_mean(x)) + + +def _PSNR_internal(gt, pred, range_=None): + if range_ is None: + range_ = torch.max(gt, dim=1).values - torch.min(gt, dim=1).values + + mse = torch.mean((gt - pred) ** 2, dim=1) + return 20 * torch.log10(range_ / torch.sqrt(mse)) + + +@allow_numpy +def PSNR(gt, pred, range_=None): + ''' + Compute PSNR. + Parameters + ---------- + gt: array + Ground truth image. + pred: array + Predicted image. + ''' + assert len(gt.shape) == 3, 'Images must be in shape: (batch,H,W)' + + gt = gt.view(len(gt), -1) + pred = pred.view(len(gt), -1) + return _PSNR_internal(gt, pred, range_=range_) + + +@allow_numpy +def RangeInvariantPsnr(gt, pred): + """ + NOTE: Works only for grayscale images. + Adapted from https://github.com/juglab/ScaleInvPSNR/blob/master/psnr.py + It rescales the prediction to ensure that the prediction has the same range as the ground truth. + """ + assert len(gt.shape) == 3, 'Images must be in shape: (batch,H,W)' + gt = gt.view(len(gt), -1) + pred = pred.view(len(gt), -1) + ra = (torch.max(gt, dim=1).values - torch.min(gt, dim=1).values) / torch.std(gt, dim=1) + gt_ = zero_mean(gt) / torch.std(gt, dim=1, keepdim=True) + return _PSNR_internal(zero_mean(gt_), fix(gt_, pred), ra) \ No newline at end of file diff --git a/training.py b/training.py index e449a09..5dcb591 100644 --- a/training.py +++ b/training.py @@ -1,3 +1,6 @@ +import os +import glob +import random import numpy as np import math import time @@ -11,9 +14,8 @@ from torchvision.utils import save_image from torch.nn import init from torch.optim.optimizer import Optimizer -import os -import glob -import random +from torch.cuda.amp import GradScaler + from tifffile import imread from matplotlib import pyplot as plt from tqdm import tqdm @@ -22,197 +24,388 @@ from models.lvae import LadderVAE import lib.utils as utils +import warnings +warnings.filterwarnings('ignore') +# We import all our dependencies. +import numpy as np +import torch +import sys +from models.lvae import LadderVAE +from lib.gaussianMixtureNoiseModel import GaussianMixtureNoiseModel +from boilerplate import boilerplate +import lib.utils as utils +import training +from tifffile import imread +from matplotlib import pyplot as plt +from tqdm import tqdm +import wandb +from ra_psnr import RangeInvariantPsnr, PSNR +from data import Dataset +from pathlib import Path + + +use_cuda = torch.cuda.is_available() +device = torch.device("cuda" if use_cuda else "cpu") +model_name = "TalleyLines" +# Data-specific +gaussian_noise_std = None +noiseModel = None +image_size = 128 +# Training-specific +batch_size = 64 +virtual_batch = 16 +lr=1e-4 +max_epochs = 600 +free_bits = 0.0 +use_uncond_mode_at=[] + +#================================================================================================================================================================= +# Model-specific +debug = False #[True, False] +save_output = True #[True, False] +project = 'HDN_Baseline_Modular' +num_latents = 5 +z_dims = [32]*int(num_latents) +blocks_per_layer = 3 +n_filters = [64, 64, 128, 256, 512, 1024] +stochasticity = True #[True, False] +likelihood = 'GaussianLikelihood' # [GaussianLikelihood, GaussianLikelihood_HDN] +recons_weight = 1.0 +dropout = 0.2 +isdropout = True +batchnorm = True + +if likelihood == 'GaussianLikelihood': + logvar_clip = 5.0 + lvclip = False + lvtype = 'global' #['global', 'pixelwise'] + kl_weight = 1.0 + gradient_scale = 1.0 +elif likelihood == 'GaussianLikelihood_HDN': + logvar_clip = None + lvclip = None + lvtype = None + kl_weight = 0.0001 + gradient_scale = 8192 + +directory_path = f"NL[{num_latents}]zD[{z_dims[0]}]bpl[{blocks_per_layer}]len_nF[{len(n_filters)}]lh[{likelihood}]Stoc[{stochasticity}]lvClip[{lvclip}]_lvtp[{lvtype}]_DO_[{isdropout}]_BN_[{batchnorm}]" +name = 'T[1,7]->T0_' + directory_path +#================================================================================================================================================================= + +dataset_train = Dataset(Path('/group/jug/Anirban/Datasets/TalleySim_1024/train/'), image_size=image_size) +train_loader = torch.utils.data.DataLoader(dataset_train, batch_size=batch_size, shuffle=True, num_workers=4, drop_last=True) +dataset_val = Dataset(Path('/group/jug/Anirban/Datasets/TalleySim_1024/val/'), image_size=image_size) +val_loader = torch.utils.data.DataLoader(dataset_val, batch_size=10, shuffle=False, num_workers=4, drop_last=True) +#not normalizing the data +data_mean = 0.0 +data_std = 1.0 +max_grad_norm = None -def train_network(model, lr, max_epochs,steps_per_epoch,train_loader, val_loader, test_loader, - virtual_batch, gaussian_noise_std, model_name, - test_log_every=1000, directory_path="./", - val_loss_patience=100, nrows=4, max_grad_norm=None): + +model = LadderVAE(z_dims=z_dims,blocks_per_layer=blocks_per_layer,data_mean=data_mean,data_std=data_std,noiseModel=noiseModel, \ + device=device,batchnorm=batchnorm,free_bits=free_bits,img_shape=(128,128), \ + use_uncond_mode_at=use_uncond_mode_at, likelihood_form=likelihood, logvar_clip = logvar_clip, lvclip=lvclip, \ + lvtype=lvtype, stochasticity=stochasticity, n_filters=n_filters, dropout=dropout).cuda() + +model.train() # Model set in training mode + +#print(model.top_down_layers) +#print(model.final_top_down) + +def count_parameters(model): + return sum(p.numel() for p in model.parameters() if p.requires_grad) + + + +def train_network(model, lr, max_epochs,train_loader, val_loader, + virtual_batch, model_name, directory_path="./Trained_Models", + max_grad_norm=None, amp=True, gradient_scale=gradient_scale, + project_name=project, name_=name, debug=debug, kl_weight=kl_weight, stochasticity=stochasticity, + recons_weight=recons_weight, save_output=True): - """Train Hierarchical DivNoising network. - Parameters - ---------- - model: Ladder VAE object - Hierarchical DivNoising model. - lr: float - Learning rate - max_epochs: int - Number of epochs to train the model for. - train_loader: PyTorch data loader - Data loader for training set. - val_loader: PyTorch data loader - Data loader for validation set. - test_loader: PyTorch data loader - Data loader for test set. - virtual_batch: int - Virtual batch size for training - gaussian_noise_std: float - standard deviation of gaussian noise (required when 'noiseModel' is None). - model_name: String - Name of Hierarchical DivNoising model with which to save weights. - test_log_every: int - Number of training steps after which one test evaluation is performed. - directory_path: String - Path where the DivNoising weights to be saved. - val_loss_patience: int - Number of epoochs after which training should be terminated if validation loss doesn't improve by 1e-6. - max_grad_norm: float - Value to limit/clamp the gradients at. - """ + if debug == False: + use_wandb = True + else: + use_wandb = False + + if use_wandb == True: + experiment = wandb.init(project = project_name, + name = name_, + resume = 'allow', + anonymous = 'must', + mode = 'online', + reinit = True, + save_code = True) + + experiment.config.update(dict(epochs=max_epochs, + batch_size=batch_size, + )) + + wandb.run.log_code(("."), include_fn=lambda path: path.endswith(".py") or path.endswith(".ipynb")) + - model_folder = directory_path+"model/" - img_folder = directory_path+"imgs/" + model_folder = directory_path+"/model/" + img_folder = directory_path+"/imgs/" device = model.device optimizer, scheduler = boilerplate._make_optimizer_and_scheduler(model,lr,0.0) loss_train_history = [] reconstruction_loss_train_history = [] kl_loss_train_history = [] loss_val_history = [] - running_loss = 0.0 - step_counter = 0 - epoch = 0 - + psnr_ra_best = 0.0 patience_ = 0 - first_step = True - - try: - os.makedirs(model_folder) - except FileExistsError: - # directory already exists - pass - try: - os.makedirs(img_folder) - except FileExistsError: - # directory already exists - pass + if save_output == True: + try: + #make directory inside the directory_path + os.makedirs(model_folder) + except FileExistsError: + # directory already exists + pass + + try: + os.makedirs(img_folder) + except FileExistsError: + # directory already exists + pass seconds_last = time.time() - - while step_counter / steps_per_epoch < max_epochs: - epoch = epoch+1 + + #AMP gradscaler + scaler = GradScaler(init_scale=gradient_scale, enabled=amp) + + steps = 0 + + for epoch in tqdm(range(0, max_epochs)): + print(f'Epoch {epoch}/{max_epochs}') running_training_loss = [] running_reconstruction_loss = [] running_kl_loss = [] - - for batch_idx, (x, y) in enumerate(train_loader): - step_counter=batch_idx - x = x.unsqueeze(1) # Remove for RGB - x = x.to(device=device, dtype=torch.float) - step = model.global_step - - if(test_log_every > 0): - if step % test_log_every == 0: - - print("Testing the model at " "step {}". format(step)) - - with torch.no_grad(): - boilerplate._test(epoch, img_folder, device, model, - test_loader, gaussian_noise_std, - model.data_std, nrows) - model.train() - + + for images in tqdm(train_loader, leave=False): # x and y are the same + + images = images.to(device=device, dtype=torch.float) optimizer.zero_grad() - - - ### Make smaller batches - virtual_batches = torch.split(x,virtual_batch,0) + + ### Make smaller batches + virtual_batches = torch.split(images,virtual_batch,0) for batch in virtual_batches: - - outputs = boilerplate.forward_pass(batch, batch, device, model, - gaussian_noise_std) + images_input = batch[:,1:2,:,:] + images_target = batch[:,0:1,:,:] + + outputs = boilerplate.forward_pass(images_input, images_target, device, model, gaussian_noise_std=None, amp=amp, stochasticity=stochasticity) recons_loss = outputs['recons_loss'] - kl_loss = outputs['kl_loss'] - loss = recons_loss + kl_loss - loss.backward() + if stochasticity == True: + kl_loss = outputs['kl_loss'] + loss = recons_weight * recons_loss + kl_loss * kl_weight + else: + loss = recons_weight * recons_loss + steps += 1 + scaler.scale(loss).backward() + + psnr = PSNR(images_target[:,0,...], outputs['out_img'][:,0,...]) + psnr = psnr.mean() + psnr_ra = RangeInvariantPsnr(images_target[:,0,...], outputs['out_img'][:,0,...]) + psnr_ra = psnr_ra.mean() + + if use_wandb == True: + if stochasticity == True: + experiment.log({ + 'recons_loss': recons_loss, + 'kl_loss': kl_loss, + 'loss': loss.item(), + 'psnr': psnr.item(), + 'psnr_ra': psnr_ra.item() + }) + else: + + experiment.log({ + 'recons_loss': recons_loss, + 'loss': loss.item(), + 'psnr': psnr.item(), + 'psnr_ra': psnr_ra.item() + }) - if max_grad_norm is not None: - torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=max_grad_norm) - # Optimization step running_training_loss.append(loss.item()) running_reconstruction_loss.append(recons_loss.item()) - running_kl_loss.append(kl_loss.item()) - + if stochasticity == True: + running_kl_loss.append(kl_loss.item()) + + + + if max_grad_norm is not None: + torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=max_grad_norm) optimizer.step() model.increment_global_step() - - first_step = False - if step_counter % steps_per_epoch == steps_per_epoch-1: - - ### Print training losses - to_print = "Epoch[{}/{}] Training Loss: {:.3f} Reconstruction Loss: {:.3f} KL Loss: {:.3f}" - to_print = to_print.format(epoch, - max_epochs, - np.mean(running_training_loss), - np.mean(running_reconstruction_loss), - np.mean(running_kl_loss)) - - print(to_print) - print('saving',model_folder+model_name+"_last_vae.net") - torch.save(model, model_folder+model_name+"_last_vae.net") - - ### Save training losses - loss_train_history.append(np.mean(running_training_loss)) - reconstruction_loss_train_history.append(np.mean(running_reconstruction_loss)) + step = model.global_step + + if epoch % 50 == 0 and save_output == True: + psnr_fig = PSNR(images_target[0:1:,0,...], outputs['out_img'][0:1:,0,...]) + psnr_fig_ra = RangeInvariantPsnr(images_target[0:1:,0,...], outputs['out_img'][0:1:,0,...]) + plt.figure(figsize=(10,10)) + plt.subplot(1,3,1) + plt.imshow(images_input[0,0,:,:].detach().cpu().numpy()) + plt.axis('off') + plt.title(f'Input') + plt.subplot(1,3,2) + plt.imshow(outputs['out_img'][0,0,:,:].detach().cpu().numpy()) + plt.title(f'Output Image PSNR: {psnr_fig.item():.2f}') + plt.xlabel(f'Output Image PSNR_RA: {psnr_fig_ra.item():.2f}') + plt.subplot(1,3,3) + plt.imshow(images_target[0,0,:,:].detach().cpu().numpy()) + plt.axis('off') + plt.title(f'Target') + plt.savefig(img_folder+'batch_train_'+str(epoch)+'.png') + plt.close() + + + ### Print training losses + if stochasticity == True: + to_print = "Epoch[{}/{}] Training Loss: {:.3f} Reconstruction Loss: {:.3f} KL Loss: {:.3f}" + else: + to_print = "Epoch[{}/{}] Training Loss: {:.3f} Reconstruction Loss: {:.3f}" + if stochasticity == True: + to_print = to_print.format(epoch, + max_epochs, + np.mean(running_training_loss), + np.mean(running_reconstruction_loss), + np.mean(running_kl_loss)) + else: + to_print = to_print.format(epoch, + max_epochs, + np.mean(running_training_loss), + np.mean(running_reconstruction_loss)) + + + print(to_print) + if debug == False: + print('saving',model_folder+model_name+"_last_vae.net") + torch.save(model, model_folder+model_name+"_last_vae.net") + + ### Save training losses + loss_train_history.append(np.mean(running_training_loss)) + reconstruction_loss_train_history.append(np.mean(running_reconstruction_loss)) + np.save(model_folder+"train_loss.npy", np.array(loss_train_history)) + np.save(model_folder+"train_reco_loss.npy", np.array(reconstruction_loss_train_history)) + if stochasticity == True: kl_loss_train_history.append(np.mean(running_kl_loss)) - np.save(model_folder+"train_loss.npy", np.array(loss_train_history)) - np.save(model_folder+"train_reco_loss.npy", np.array(reconstruction_loss_train_history)) np.save(model_folder+"train_kl_loss.npy", np.array(kl_loss_train_history)) - - - ### Validation step - running_validation_loss = [] - model.eval() - with torch.no_grad(): - for i, (x, y) in enumerate(val_loader): - x = x.unsqueeze(1) # Remove for RGB - x = x.to(device=device, dtype=torch.float) - val_outputs = boilerplate.forward_pass(x, y, device, model, gaussian_noise_std) - - val_recons_loss = val_outputs['recons_loss'] + + + ### Validation step + running_validation_loss = [] + psnr_ra_val_list = [] + model.eval() + with torch.no_grad(): + for images_val in tqdm(val_loader, leave=False): + + images_val = images_val.to(device=device, dtype=torch.float) + + ### Make smaller batches + virtual_batches_val = torch.split(images_val,virtual_batch,0) + for batch_val in virtual_batches_val: + + images_input_val = batch_val[:,1:2,:,:] + images_target_val = batch_val[:,0:1,:,:] + + val_outputs = boilerplate.forward_pass(images_input_val, images_target_val, device, model, gaussian_noise_std=None, stochasticity=stochasticity) + val_recons_loss = val_outputs['recons_loss'] + if stochasticity == True: val_kl_loss = val_outputs['kl_loss'] - val_loss = val_recons_loss + val_kl_loss - running_validation_loss.append(val_loss) - model.train() + val_loss = recons_weight * val_recons_loss + val_kl_loss * kl_weight + else: + val_loss = recons_weight * val_recons_loss + running_validation_loss.append(val_loss) - total_epoch_loss_val = torch.mean(torch.stack(running_validation_loss)) - scheduler.step(total_epoch_loss_val) + psnr_val = PSNR(images_target_val[:,0,...], val_outputs['out_img'][:,0,...]) + psnr_val = psnr_val.mean() + psnr_ra_val = RangeInvariantPsnr(images_target_val[:,0,...], val_outputs['out_img'][:,0,...],) + psnr_ra_val = psnr_val.mean() + psnr_ra_val_list.append(psnr_ra_val) - ### Save validation losses - loss_val_history.append(total_epoch_loss_val.item()) - np.save(model_folder+"val_loss.npy", np.array(loss_val_history)) - if total_epoch_loss_val.item() < 1e-6 + np.min(loss_val_history): - patience_ = 0 - print('saving',model_folder+model_name+"_best_vae.net") - torch.save(model, model_folder+model_name+"_best_vae.net") - else: - patience_ +=1 - - print("Patience:", patience_, - "Validation Loss:", total_epoch_loss_val.item(), - "Min validation loss:", np.min(loss_val_history)) - - seconds=time.time() - secondsElapsed=np.float(seconds-seconds_last) - seconds_last=seconds - remainingEps=(max_epochs+1)-(epoch+1) - estRemainSeconds=(secondsElapsed)*(remainingEps) - estRemainSecondsInt=int(secondsElapsed)*(remainingEps) - print('Time for epoch: '+ str(int(secondsElapsed))+ 'seconds') - - print('Est remaining time: '+ - str(datetime.timedelta(seconds= estRemainSecondsInt)) + - ' or ' + - str(estRemainSecondsInt)+ - ' seconds') - - print("----------------------------------------", flush=True) - - if patience_ == val_loss_patience: -# print("Employing early stopping, validation loss did not improve for 100 epochs !" - return - - break \ No newline at end of file + if use_wandb == True: + if stochasticity == True: + experiment.log({ + 'recons_loss_val': val_recons_loss, + 'kl_loss_val': val_kl_loss, + 'loss_val': val_loss.item(), + 'psnr_val': psnr_val.item(), + 'psnr_ra_val': psnr_ra_val.item() + }) + else: + experiment.log({ + 'recons_loss_val': val_recons_loss, + 'loss_val': val_loss.item(), + 'psnr_val': psnr_val.item(), + 'psnr_ra_val': psnr_ra_val.item() + }) + + if epoch % 10 == 0 and save_output == True: + psnr_fig_val = PSNR(images_target_val[0:1:,0,...], val_outputs['out_img'][0:1:,0,...]) + psnr_fig_ra_val = RangeInvariantPsnr(images_target_val[0:1:,0,...], val_outputs['out_img'][0:1:,0,...]) + plt.figure(figsize=(10,10)) + plt.subplot(1,3,1) + plt.imshow(images_input_val[0,0,:,:].detach().cpu().numpy()) + plt.axis('off') + plt.title(f'Input') + plt.subplot(1,3,2) + plt.imshow(val_outputs['out_img'][0,0,:,:].detach().cpu().numpy()) + plt.title(f'Output Image PSNR: {psnr_fig_val.item():.2f}') + plt.xlabel(f'Output Image PSNR_RA: {psnr_fig_ra_val.item():.2f}') + plt.subplot(1,3,3) + plt.imshow(images_target_val[0,0,:,:].detach().cpu().numpy()) + plt.axis('off') + plt.title(f'Target') + plt.savefig(img_folder+'batch_val_'+str(epoch)+'.png') + plt.close() + + model.train() + + total_epoch_loss_val = torch.mean(torch.stack(running_validation_loss)) + scheduler.step(total_epoch_loss_val) + + ### Save validation losses + loss_val_history.append(total_epoch_loss_val.item()) + if save_output == True: + np.save(model_folder+"val_loss.npy", np.array(loss_val_history)) + + if debug == False and save_output == True: + if torch.mean(torch.stack(psnr_ra_val_list)).item() > psnr_ra_best: + psnr_ra_best = torch.mean(torch.stack(psnr_ra_val_list)).item() + print('saving',model_folder+model_name+"_best_vae.net") + torch.save(model, model_folder+model_name+"_best_vae.net") + + else: + patience_ +=1 + + print("Patience:", patience_, + "Validation Loss:", total_epoch_loss_val.item(), + "Min validation loss:", np.min(loss_val_history)) + + seconds=time.time() + secondsElapsed=np.float(seconds-seconds_last) + seconds_last=seconds + remainingEps=(max_epochs+1)-(epoch+1) + estRemainSeconds=(secondsElapsed)*(remainingEps) + estRemainSecondsInt=int(secondsElapsed)*(remainingEps) + print('Time for epoch: '+ str(int(secondsElapsed))+ 'seconds') + + print('Est remaining time: '+ + str(datetime.timedelta(seconds= estRemainSecondsInt)) + + ' or ' + + str(estRemainSecondsInt)+ + ' seconds') + + print("----------------------------------------", flush=True) + +if __name__ == '__main__': + print(count_parameters(model)/ 1e6, 'Million trainable parameters') + train_network(model=model,lr=lr,max_epochs=max_epochs,directory_path="./Trained_Models/"+directory_path,train_loader=train_loader,val_loader=val_loader, + virtual_batch=virtual_batch, max_grad_norm = max_grad_norm, + model_name=model_name, + kl_weight = kl_weight, gradient_scale=gradient_scale, project_name=project, + name_=name, debug=debug, stochasticity=stochasticity, recons_weight=recons_weight, save_output=save_output) \ No newline at end of file