diff --git a/.gitattributes b/.gitattributes index a6344aac8c09253b3b630fb776ae94478aa0275b..9a114164b266b7ab59729ff82f494ffa494dc7fb 100644 --- a/.gitattributes +++ b/.gitattributes @@ -33,3 +33,7 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text *.zip filter=lfs diff=lfs merge=lfs -text *.zst filter=lfs diff=lfs merge=lfs -text *tfevents* filter=lfs diff=lfs merge=lfs -text +assets/robustness.png filter=lfs diff=lfs merge=lfs -text +assets/user_2.jpg filter=lfs diff=lfs merge=lfs -text +assets/user_case_1.png filter=lfs diff=lfs merge=lfs -text +assets/user_case_2.png filter=lfs diff=lfs merge=lfs -text diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000000000000000000000000000000000000..5b2f54449af4daadc3e7ab5db04997d59565e147 --- /dev/null +++ b/.gitignore @@ -0,0 +1,18 @@ +*.bin +*.ckpt +*.pt +logs/ +*.safetensors +*.jpg +*.png +!data/MIST.png +!/MIST_logo.png +*.zip +__pycache__/ +stable-diffusion/*/ +test/ +*.pkl +data/training/* +output/lora/* +output/mist/* +!assets/* \ No newline at end of file diff --git a/MIST_logo.png b/MIST_logo.png new file mode 100644 index 0000000000000000000000000000000000000000..405948e8795e9a5d1bc0cb152f9384a0de0fd02f Binary files /dev/null and b/MIST_logo.png differ diff --git a/README.md b/README.md index 0ba2068d2a69a65e37a849f8ad2dbb88abbfe5e9..5192dfb5685fad9228edab9b1bc29e0bc3985716 100644 --- a/README.md +++ b/README.md @@ -1,12 +1,243 @@ --- -title: Mist V2 -emoji: 👁 -colorFrom: blue -colorTo: gray +title: mist-v2 +app_file: mist-webui.py sdk: gradio sdk_version: 4.11.0 -app_file: app.py -pinned: false --- +

+
+ + +
+

+ + +[![project page](https://img.shields.io/badge/homepage-mist--project.io-blue.svg)](https://mist-project.github.io/index_en.html) +[![arXiv](https://img.shields.io/badge/arXiv-2310.04687-red.svg)](https://arxiv.org/abs/2310.04687) + + + + + + + + + +

+ +

+ + + +> Mist's Effects in User Cases. **The first row:** Lora generation from source images. +**The second row:** Lora generation from Mist-treated samples. Mist V2 significantly disrupts the output of the generation, effectively protecting artists' images. Used images are from anonymous artists. All rights reserved. + + + + + + + + +## Main Features +- Enhanced protection against AI-for-Art applications like Lora and SDEdit +- Imperceptible noise. +- 3-5 minutes processing with only 6GB of GPU memory in most cases. CPU processing supported. +- Resilience against denoising methods. + + +## About Mist +Mist is a powerful image preprocessing tool designed for the purpose of protecting the style and content of +images from being mimicked by state-of-the-art AI-for-Art applications. By adding watermarks to the images, Mist renders them unrecognizable and inmitable for the +models employed by AI-for-Art applications. Attempts by AI-for-Art applications to mimic these Misted images +will be ineffective, and the output image of such mimicry will be scrambled and unusable as artwork. + + +

+ +

+ +In Mist V2, we have enhanced its effectiveness against a wider range of AI-for-Art applications, particularly excelling with Lora. Mist V2 achieves robust defense with even more discreet watermarks compared to [Mist V1](https://github.com/mist-project/mist). Additionally, Mist V2 introduces support for CPU processing and can efficiently run on GPUs with as little as 6GB of memory in most cases. + + + + + + + + + + +## Quick Start + +### Environment + +**Preliminaries:** To run this repository, please have [Anaconda](https://pytorch.org/) installed in your work station. The GPU version of Mist requires a NVIDIA GPU in [Ampere](https://en.wikipedia.org/wiki/Ampere_(microarchitecture)) or more advanced architecture with more than 6GB VRAM. You can also try the CPU version +in a moderate running speed. + +Clone this repository to your local and get into the repository root: + +```bash +git clone https://github.com/mist-project/mist-v2.git +cd mist-v2 +``` + +Then, run the following commands in the root of the repository to install the environment: + +```bash +conda create -n mist-v2 python=3.10 +conda activate mist-v2 +pip install -r requirements.txt +``` + +### Usage + +Run Mist V2 in the default setup on GPU: +```bash +accelerate launch attacks/mist.py --cuda --low_vram_mode --instance_data_dir $INSTANCE_DIR --output_dir $OUTPUT_DIR --class_data_dir $CLASS_DATA_DIR --instance_prompt $PROMPT --class_prompt $CLASS_PROMPT --mixed_precision bf16 +``` + +Run Mist V2 in the default setup on CPU: +```bash +accelerate launch attacks/mist.py --instance_data_dir $INSTANCE_DIR --output_dir $OUTPUT_DIR --class_data_dir $CLASS_DATA_DIR --instance_prompt $PROMPT --class_prompt $CLASS_PROMPT --mixed_precision bf16 +``` + +The parameters are demonstrated in the following table: + +| Parameter | Explanation | +| --------------- | ------------------------------------------------------------------------------------------ | +| $INSTANCE_DIR | Directory of input clean images. The goal is to add adversarial noise to them. | +| $OUTPUT_DIR | Directory for output adversarial examples (misted images). | +| $CLASS_DATA_DIR | Directory for class data in prior preserved training of Dreambooth, required to be empty. | +| $PROMPT | Prompt that describes the input clean images, used to perturb the images. | +| $CLASS_PROMPT | Prompt used to generate class data, recommended to be similar to $PROMPT. | + +Here is a case command to run Mist V2 on GPU: + +```bash +accelerate launch attacks/mist.py --cuda --low_vram_mode --instance_data_dir data/training --output_dir output/ --class_data_dir data/class --instance_prompt "a photo of a misted person, high quality, masterpiece" --class_prompt "a photo of a person, high quality, masterpiece" --mixed_precision bf16 +``` + +We also provide a WebUI with the help of [Gradio](https://www.gradio.app/). To boost the WebUI, run: + +```bash +python mist-webui.py +``` + +### Evaluation + +We provide a simple pipeline to evaluate the output adversarial examples (only for GPU users). +Basically, this pipeline trains a LoRA on the adversarial examples and samples images with the LoRA. +Note that our adversarial examples may induce LoRA to output images with NSFW contents +(for example, chaotic texture). As stated, this is to prevent LoRA training on unauthorized image data. To evaluate the effectiveness of our method, we disable the safety checker in the LoRA sampling script. Following is the instruction to run the pipeline. + +First, train a LoRA on the output adversarial examples. + +```bash +accelerate launch eval/train_dreambooth_lora_15.py --instance_data_dir=$LORA_INPUT_DIR --output_dir=$LORA_OUTPUT_DIR --class_data_dir=$LORA_CLASS_DIR --instance_prompt $LORA_PROMPT --class_prompt $LORA_CLASS_PROMPT --resolution=512 --train_batch_size=1 --learning_rate=1e-4 --scale_lr --max_train_steps=2000 +``` + +The parameters are demonstrated in the following table: + + +| Parameter | Explanation | +| ------------------ | ---------------------------------------------------------------------------------------------------------- | +| $LORA_INPUT_DIR | Directory of training data (adversarial examples), staying the same as $OUTPUT_DIR in the previous table. | +| $LORA_OUTPUT_DIR | Directory to store the trained LoRA. | +| $LORA_CLASS_DIR | Directory for class data in prior preserved training of Dreambooth, required to be empty. | +| $LORA_PROMPT | Prompt that describes the training data, used to train the LoRA. | +| $LORA_CLASS_PROMPT | Prompt used to generate class data, recommended to be related to $LORA_PROMPT. | + + +Next, open the `eval/sample_lora_15.ipynb` and run the first block. After that, change the value of the variable `LORA_OUTPUT_DIR` to be the previous `$LORA_OUTPUT_DIR` when training the LoRA. + +```Python +from lora_diffusion import tune_lora_scale, patch_pipe +torch.manual_seed(time.time()) + +# The directory of LoRA +LORA_OUTPUT_DIR = [The value of $LORA_OUTPUT_DIR] +... +``` + +Finally, run the second block to see the output and evaluate the performance of Mist. + + +## A Glimpse to Methodology + +Mist V2 works by adversarially attacking generative diffusion models. Basically, the attacking is an optimization over the following objective: + +$$ \underset{x'}{min} \mathbb{E} {(z_0', \epsilon,t)} \Vert \epsilon_\theta(z'_t(z'_0,\epsilon),t)-z_0^T\Vert^2_2, \Vert x'-x\Vert\leq\zeta$$ + +We demonstrate the notation in the following table. + +| Variable | Explanation | +| ----------------- | ---------------------------------------------------------------- | +| $x$ / $x'$ | The clean image / The adversarial example | +| $t$ | Time step in the diffusion model. | +| $z'_0$ | The latent variable of $x'$ in the 0th time step | +| $\epsilon$ | A standard Gaussian noise | +| $z_0^T$ | The latent variable of a target image $x^T$ in the 0th time step | +| $\epsilon_\theta$ | The noise predictor (U-Net) in the diffusion model | +| $\zeta$ | The budget of adversarial noise | + + +Intuitively, we find that pushing the output of the U-Net in the diffusion model to the 0th timestep +latent variable of a target image can effectively confuse the diffusion model. This abstracts the +aforementioned objective of Mist V2. + +Our paper is still in working. We are trying to reveal the mechanism behind our method in the paper. Despite of this, you can access [Arxiv]() to view the first draft of our paper. + +## License + +This project is licensed under the [GPL-3.0 license](https://github.com/mist-project/mist/blob/main/LICENSE). + + +## Citation +If you find our work valuable and utilize it, we kindly request that you cite our paper. + +``` +@article{zheng2023understanding, + title={Understanding and Improving Adversarial Attacks on Latent Diffusion Model}, + author={Zheng, Boyang and Liang, Chumeng and Wu, Xiaoyu and Liu, Yan}, + journal={arXiv preprint arXiv:2310.04687}, + year={2023} +} +``` + +Our repository also refers to following papers: + +``` +@inproceedings{van2023anti, + title={Anti-DreamBooth: Protecting users from personalized text-to-image synthesis}, + author={Van Le, Thanh and Phung, Hao and Nguyen, Thuan Hoang and Dao, Quan and Tran, Ngoc N and Tran, Anh}, + booktitle={Proceedings of the IEEE/CVF International Conference on Computer Vision}, + pages={2116--2127}, + year={2023} +} +``` + +``` +@article{liang2023mist, + title={Mist: Towards Improved Adversarial Examples for Diffusion Models}, + author={Liang, Chumeng and Wu, Xiaoyu}, + journal={arXiv preprint arXiv:2305.12683}, + year={2023} +} +``` + + + -Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference diff --git a/assets/MIST_V2_LOGO.png b/assets/MIST_V2_LOGO.png new file mode 100644 index 0000000000000000000000000000000000000000..06aa4b9b87b32feaedb12aff8580f16a186c8828 Binary files /dev/null and b/assets/MIST_V2_LOGO.png differ diff --git a/assets/effect_show.png b/assets/effect_show.png new file mode 100644 index 0000000000000000000000000000000000000000..c95027b6690224b41cf549066c0edda79a20c23e Binary files /dev/null and b/assets/effect_show.png differ diff --git a/assets/output_image.png b/assets/output_image.png new file mode 100644 index 0000000000000000000000000000000000000000..5c2e6fa2eebd644eebbef3b17ec574a6244d2abc Binary files /dev/null and b/assets/output_image.png differ diff --git a/assets/output_image_box.png b/assets/output_image_box.png new file mode 100644 index 0000000000000000000000000000000000000000..c83d92f1e8c86de77329e120db99ac6a85c2e0b8 Binary files /dev/null and b/assets/output_image_box.png differ diff --git a/assets/robustness.png b/assets/robustness.png new file mode 100644 index 0000000000000000000000000000000000000000..bc742fdef176c2966742f463734aa64223146c50 --- /dev/null +++ b/assets/robustness.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:5605609933bfac9a71d68c5072afc2689d3ac80d89a54e3a6f2d09c203057ef1 +size 2108996 diff --git a/assets/user_2.jpg b/assets/user_2.jpg new file mode 100644 index 0000000000000000000000000000000000000000..a7cee014c4ea1ae6612caf47b1b55013fddfa099 --- /dev/null +++ b/assets/user_2.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:dc39fd3f114ff2e3bfe138bf64b43a3c967be0cb87f69b08202906e6edbb7b4f +size 11102679 diff --git a/assets/user_case_1.png b/assets/user_case_1.png new file mode 100644 index 0000000000000000000000000000000000000000..132887dcb1dbc9a7bc00231814f01660327e0a7b --- /dev/null +++ b/assets/user_case_1.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:dd427e23cd5c982ed80bb9c66044dc79ca75300d8ed07aceb215287334b42389 +size 1844410 diff --git a/assets/user_case_2.png b/assets/user_case_2.png new file mode 100644 index 0000000000000000000000000000000000000000..ca48cc7eacf8e7c932d0600665dfd6e89192eb18 --- /dev/null +++ b/assets/user_case_2.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:1370e22afabe2be7f06dd82defc15a34cce535e08d9a151e2d9f63fbe2744de2 +size 1704915 diff --git a/attacks/mist.py b/attacks/mist.py new file mode 100644 index 0000000000000000000000000000000000000000..f51eae61c6c1fc8880c2ddc55d4a3157a6fbdb50 --- /dev/null +++ b/attacks/mist.py @@ -0,0 +1,1156 @@ +import argparse +import copy +import hashlib +import itertools +import logging +import os +import sys +import gc +from pathlib import Path +from colorama import Fore, Style, init,Back +import random, time +'''some system level settings''' +init(autoreset=True) +sys.path.insert(0, sys.path[0]+"/../") +import lpips + +import datasets +import diffusers +import numpy as np +import torch +import torch.nn.functional as F +import torch.utils.checkpoint +import transformers +from accelerate import Accelerator +from accelerate.logging import get_logger +from accelerate.utils import set_seed +from diffusers import AutoencoderKL, DDPMScheduler, DiffusionPipeline, UNet2DConditionModel,DDIMScheduler +from diffusers.utils.import_utils import is_xformers_available +from PIL import Image +from torch.utils.data import Dataset +from torchvision import transforms +from tqdm.auto import tqdm +from transformers import AutoTokenizer, PretrainedConfig +from torch import autograd +from typing import Optional, Tuple +import pynvml +# from utils import print_tensor + +from lora_diffusion import ( + extract_lora_ups_down, + inject_trainable_lora, +) +from lora_diffusion.xformers_utils import set_use_memory_efficient_attention_xformers +from attacks.utils import LatentAttack + +logger = get_logger(__name__) + +def parse_args(input_args=None): + parser = argparse.ArgumentParser(description="Simple example of a training script.") + parser.add_argument( + "--cuda", + action="store_true", + help="Use gpu for attack", + ) + parser.add_argument( + "--pretrained_model_name_or_path", + "-p", + type=str, + default="./stable-diffusion/stable-diffusion-1-5", + required=False, + help="Path to pretrained model or model identifier from huggingface.co/models.", + ) + parser.add_argument( + "--revision", + type=str, + default=None, + required=False, + help=( + "Revision of pretrained model identifier from huggingface.co/models. Trainable model components should be" + " float32 precision." + ), + ) + parser.add_argument( + "--tokenizer_name", + type=str, + default=None, + help="Pretrained tokenizer name or path if not the same as model_name", + ) + parser.add_argument( + "--instance_data_dir", + type=str, + default="", + required=False, + help="A folder containing the images to add adversarial noise", + ) + parser.add_argument( + "--class_data_dir", + type=str, + default="", + required=False, + help="A folder containing the training data of class images.", + ) + parser.add_argument( + "--instance_prompt", + type=str, + default="a picture", + required=False, + help="The prompt with identifier specifying the instance", + ) + parser.add_argument( + "--class_prompt", + type=str, + default="a picture", + help="The prompt to specify images in the same class as provided instance images.", + ) + parser.add_argument( + "--with_prior_preservation", + default=True, + help="Flag to add prior preservation loss.", + ) + parser.add_argument( + "--prior_loss_weight", + type=float, + default=0.1, + help="The weight of prior preservation loss.", + ) + parser.add_argument( + "--num_class_images", + type=int, + default=50, + help=( + "Minimal class images for prior preservation loss. If there are not enough images already present in" + " class_data_dir, additional images will be sampled with class_prompt." + ), + ) + parser.add_argument( + "--output_dir", + type=str, + default="", + help="The output directory where the perturbed data is stored", + ) + parser.add_argument("--seed", type=int, default=None, help="A seed for reproducible training.") + parser.add_argument( + "--resolution", + type=int, + default=512, + help=( + "The resolution for input images, all the images in the train/validation dataset will be resized to this" + " resolution" + ), + ) + parser.add_argument( + "--center_crop", + default=True, + help=( + "Whether to center crop the input images to the resolution. If not set, the images will be randomly" + " cropped. The images will be resized to the resolution first before cropping." + ), + ) + parser.add_argument( + "--train_text_encoder", + action="store_false", + help="Whether to train the text encoder. If set, the text encoder should be float32 precision.", + ) + parser.add_argument( + "--train_batch_size", + type=int, + default=1, + help="Batch size (per device) for the training dataloader.", + ) + parser.add_argument( + "--sample_batch_size", + type=int, + default=1, + help="Batch size (per device) for sampling images.", + ) + parser.add_argument( + "--max_train_steps", + type=int, + default=5, + help="Total number of training steps to perform.", + ) + parser.add_argument( + "--max_f_train_steps", + type=int, + default=10, + help="Total number of sub-steps to train surogate model.", + ) + parser.add_argument( + "--max_adv_train_steps", + type=int, + default=30, + help="Total number of sub-steps to train adversarial noise.", + ) + parser.add_argument( + "--gradient_accumulation_steps", + type=int, + default=1, + help="Number of updates steps to accumulate before performing a backward/update pass.", + ) + parser.add_argument( + "--checkpointing_iterations", + type=int, + default=5, + help=("Save a checkpoint of the training state every X iterations."), + ) + + parser.add_argument( + "--logging_dir", + type=str, + default="logs", + help=( + "[TensorBoard](https://www.tensorflow.org/tensorboard) log directory. Will default to" + " *output_dir/runs/**CURRENT_DATETIME_HOSTNAME***." + ), + ) + parser.add_argument( + "--allow_tf32", + action="store_true", + help=( + "Whether or not to allow TF32 on Ampere GPUs. Can be used to speed up training. For more information, see" + " https://pytorch.org/docs/stable/notes/cuda.html#tensorfloat-32-tf32-on-ampere-devices" + ), + ) + parser.add_argument( + "--report_to", + type=str, + default="tensorboard", + help=( + 'The integration to report the results and logs to. Supported platforms are `"tensorboard"`' + ' (default), `"wandb"` and `"comet_ml"`. Use `"all"` to report to all integrations.' + ), + ) + parser.add_argument( + "--mixed_precision", + type=str, + default="bf16", + choices=["no", "fp16", "bf16"], + help=( + "Whether to use mixed precision. Choose between fp16 and bf16 (bfloat16). Bf16 requires PyTorch >=" + " 1.10.and an Nvidia Ampere GPU. Default to the value of accelerate config of the current system or the" + " flag passed with the `accelerate.launch` command. Use this argument to override the accelerate config." + ), + ) + parser.add_argument( + "--low_vram_mode", + action="store_false", + help="Whether or not to use low vram mode.", + ) + parser.add_argument( + "--pgd_alpha", + type=float, + default=5e-3, + help="The step size for pgd.", + ) + parser.add_argument( + "--pgd_eps", + type=float, + default=float(8.0/255.0), + help="The noise budget for pgd.", + ) + parser.add_argument( + "--lpips_bound", + type=float, + default=0.1, + help="The noise budget for pgd.", + ) + parser.add_argument( + "--lpips_weight", + type=float, + default=0.5, + help="The noise budget for pgd.", + ) + parser.add_argument( + "--fused_weight", + type=float, + default=1e-5, + help="The decay of alpha and eps when applying pre_attack", + ) + parser.add_argument( + "--target_image_path", + default="data/MIST.png", + help="target image for attacking", + ) + + parser.add_argument( + "--lora_rank", + type=int, + default=4, + help="Rank of LoRA approximation.", + ) + parser.add_argument( + "--learning_rate", + type=float, + default=1e-4, + help="Initial learning rate (after the potential warmup period) to use.", + ) + parser.add_argument( + "--learning_rate_text", + type=float, + default=5e-6, + help="Initial learning rate for text encoder (after the potential warmup period) to use.", + ) + parser.add_argument( + "--scale_lr", + action="store_true", + default=False, + help="Scale the learning rate by the number of GPUs, gradient accumulation steps, and batch size.", + ) + parser.add_argument( + "--lr_scheduler", + type=str, + default="constant", + help=( + 'The scheduler type to use. Choose between ["linear", "cosine", "cosine_with_restarts", "polynomial",' + ' "constant", "constant_with_warmup"]' + ), + ) + parser.add_argument( + "--mode", + type=str, + choices=['lunet','fused', 'anti-db'], + default='lunet', + help="The mode of attack", + ) + parser.add_argument( + "--constraint", + type=str, + choices=['eps','lpips'], + default='eps', + help="The constraint of attack", + ) + parser.add_argument( + "--use_8bit_adam", + action="store_true", + help="Whether or not to use 8-bit Adam from bitsandbytes.", + ) + parser.add_argument( + "--adam_beta1", + type=float, + default=0.9, + help="The beta1 parameter for the Adam optimizer.", + ) + parser.add_argument( + "--adam_beta2", + type=float, + default=0.999, + help="The beta2 parameter for the Adam optimizer.", + ) + parser.add_argument( + "--adam_weight_decay", type=float, default=1e-2, help="Weight decay to use." + ) + parser.add_argument( + "--adam_epsilon", + type=float, + default=1e-08, + help="Epsilon value for the Adam optimizer", + ) + parser.add_argument( + "--max_grad_norm", default=1.0, type=float, help="Max gradient norm." + ) + + parser.add_argument( + "--local_rank", + type=int, + default=-1, + help="For distributed training: local_rank", + ) + parser.add_argument( + "--resume_unet", + type=str, + default=None, + help=("File path for unet lora to resume training."), + ) + parser.add_argument( + "--resume_text_encoder", + type=str, + default=None, + help=("File path for text encoder lora to resume training."), + ) + parser.add_argument( + "--resize", + action='store_true', + required=False, + help="Should images be resized to --resolution after attacking?", + ) + + + if input_args is not None: + args = parser.parse_args(input_args) + else: + args = parser.parse_args() + if args.output_dir != "": + if not os.path.exists(args.output_dir): + os.makedirs(args.output_dir,exist_ok=True) + print(Back.BLUE+Fore.GREEN+'create output dir: {}'.format(args.output_dir)) + return args + + +class DreamBoothDatasetFromTensor(Dataset): + """Just like DreamBoothDataset, but take instance_images_tensor instead of path""" + + def __init__( + self, + instance_images_tensor, + prompts, + instance_prompt, + tokenizer, + class_data_root=None, + class_prompt=None, + size=512, + center_crop=False, + ): + self.size = size + self.center_crop = center_crop + self.tokenizer = tokenizer + + self.instance_images_tensor = instance_images_tensor + self.instance_prompts = prompts + self.num_instance_images = len(self.instance_images_tensor) + self.instance_prompt = instance_prompt + self._length = self.num_instance_images + + if class_data_root is not None: + self.class_data_root = Path(class_data_root) + self.class_data_root.mkdir(parents=True, exist_ok=True) + self.class_images_path = list(self.class_data_root.iterdir()) + self.num_class_images = len(self.class_images_path) + # self._length = max(self.num_class_images, self.num_instance_images) + self.class_prompt = class_prompt + else: + self.class_data_root = None + + self.image_transforms = transforms.Compose( + [ + transforms.Resize(size, interpolation=transforms.InterpolationMode.BILINEAR), + transforms.CenterCrop(size) if center_crop else transforms.RandomCrop(size), + transforms.ToTensor(), + transforms.Normalize([0.5], [0.5]), + ] + ) + + def __len__(self): + return self._length + + def __getitem__(self, index): + example = {} + instance_image = self.instance_images_tensor[index % self.num_instance_images] + instance_prompt = self.instance_prompts[index % self.num_instance_images] + if instance_prompt == None: + instance_prompt = self.instance_prompt + instance_prompt = \ + 'masterpiece,best quality,extremely detailed CG unity 8k wallpaper,illustration,cinematic lighting,beautiful detailed glow' + instance_prompt + example["instance_images"] = instance_image + example["instance_prompt_ids"] = self.tokenizer( + instance_prompt, + truncation=True, + padding="max_length", + max_length=self.tokenizer.model_max_length, + return_tensors="pt", + ).input_ids + + if self.class_data_root: + class_image = Image.open(self.class_images_path[index % self.num_class_images]) + if not class_image.mode == "RGB": + class_image = class_image.convert("RGB") + example["class_images"] = self.image_transforms(class_image) + example["class_prompt_ids"] = self.tokenizer( + self.class_prompt, + truncation=True, + padding="max_length", + max_length=self.tokenizer.model_max_length, + return_tensors="pt", + ).input_ids + + return example + + +def import_model_class_from_model_name_or_path(pretrained_model_name_or_path: str, revision: str): + text_encoder_config = PretrainedConfig.from_pretrained( + pretrained_model_name_or_path, + subfolder="text_encoder", + revision=revision, + ) + model_class = text_encoder_config.architectures[0] + + if model_class == "CLIPTextModel": + from transformers import CLIPTextModel + + return CLIPTextModel + elif model_class == "RobertaSeriesModelWithTransformation": + from diffusers.pipelines.alt_diffusion.modeling_roberta_series import RobertaSeriesModelWithTransformation + + return RobertaSeriesModelWithTransformation + else: + raise ValueError(f"{model_class} is not supported.") + + +class PromptDataset(Dataset): + "A simple dataset to prepare the prompts to generate class images on multiple GPUs." + + def __init__(self, prompt, num_samples): + self.prompt = prompt + self.num_samples = num_samples + + def __len__(self): + return self.num_samples + + def __getitem__(self, index): + example = {} + example["prompt"] = self.prompt + example["index"] = index + return example + + +def load_data(data_dir, size=512, center_crop=True) -> torch.Tensor: + image_transforms = transforms.Compose( + [ + transforms.Resize((size,size), interpolation=transforms.InterpolationMode.BILINEAR), + # transforms.Resize(size, interpolation=transforms.InterpolationMode.BILINEAR), + # transforms.CenterCrop(size) if center_crop else transforms.RandomCrop(size), + transforms.ToTensor(), + transforms.Normalize([0.5], [0.5]), + ] + ) + + # load images & prompts + images, prompts = [], [] + num_image = 0 + for filename in os.listdir(data_dir): + if filename.endswith(".png") or filename.endswith(".jpg"): + file_path = os.path.join(data_dir, filename) + images.append(Image.open(file_path).convert("RGB")) + num_image += 1 + + prompt_name = filename[:-3] + 'txt' + prompt_path = os.path.join(data_dir, prompt_name) + if os.path.exists(prompt_path): + with open(prompt_path, "r") as file: + text_string = file.read() + prompts.append(text_string) + print("==load image {} from {}, prompt: {}==".format(num_image-1, file_path, text_string)) + else: + prompts.append(None) + print("==load image {} from {}, prompt: None, args.instance_prompt used==".format(num_image-1, file_path)) + + # load sizes + sizes = [img.size for img in images] + + # preprocess images + images = [image_transforms(img) for img in images] + images = torch.stack(images) + print("==tensor shape: {}==".format(images.shape)) + + return images, prompts, sizes + + +def train_one_epoch( + args, + accelerator, + models, + tokenizer, + noise_scheduler, + vae, + data_tensor: torch.Tensor, + prompts, + weight_dtype=torch.bfloat16, +): + # prepare training data + train_dataset = DreamBoothDatasetFromTensor( + data_tensor, + prompts, + args.instance_prompt, + tokenizer, + args.class_data_dir, + args.class_prompt, + args.resolution, + args.center_crop, + ) + + device = accelerator.device + + # prepare models & inject lora layers + unet, text_encoder = copy.deepcopy(models[0]), copy.deepcopy(models[1]) + vae.to(device, dtype=weight_dtype) + vae.requires_grad_(False) + text_encoder.to(device, dtype=weight_dtype) + unet.to(device, dtype=weight_dtype) + if args.low_vram_mode: + set_use_memory_efficient_attention_xformers(unet,True) + + # this is only done at the first epoch + unet_lora_params, _ = inject_trainable_lora( + unet, r=args.lora_rank, loras=args.resume_unet + ) + if args.train_text_encoder: + text_encoder_lora_params, _ = inject_trainable_lora( + text_encoder, + target_replace_module=["CLIPAttention"], + r=args.lora_rank, + ) + # for _up, _down in extract_lora_ups_down( + # text_encoder, target_replace_module=["CLIPAttention"] + # ): + # print("Before training: text encoder First Layer lora up", _up.weight.data) + # print( + # "Before training: text encoder First Layer lora down", _down.weight.data + # ) + # break + + # build the optimizer + optimizer_class = torch.optim.AdamW + + text_lr = ( + args.learning_rate + if args.learning_rate_text is None + else args.learning_rate_text + ) + + params_to_optimize = ( + [ + { + "params": itertools.chain(*unet_lora_params), + "lr": args.learning_rate}, + { + "params": itertools.chain(*text_encoder_lora_params), + "lr": text_lr, + }, + ] + if args.train_text_encoder + else itertools.chain(*unet_lora_params) + ) + + optimizer = optimizer_class( + params_to_optimize, + lr=args.learning_rate, + betas=(args.adam_beta1, args.adam_beta2), + weight_decay=args.adam_weight_decay, + eps=args.adam_epsilon, + ) + + # begin training + for step in range(args.max_f_train_steps): + unet.train() + text_encoder.train() + + random.seed(time.time()) + instance_idx = random.randint(0, len(train_dataset)-1) + step_data = train_dataset[instance_idx] + pixel_values = torch.stack([step_data["instance_images"], step_data["class_images"]]) + #print("pixel_values shape: {}".format(pixel_values.shape)) + input_ids = torch.cat([step_data["instance_prompt_ids"], step_data["class_prompt_ids"]], dim=0).to(device) + for k in range(pixel_values.shape[0]): + #calculate loss of instance and class seperately + pixel_value = pixel_values[k, :].unsqueeze(0).to(device, dtype=weight_dtype) + latents = vae.encode(pixel_value).latent_dist.sample().detach().clone() + latents = latents * vae.config.scaling_factor + # Sample noise that we'll add to the latents + noise = torch.randn_like(latents) + bsz = latents.shape[0] + # Sample a random timestep for each image + timesteps = torch.randint(0, noise_scheduler.config.num_train_timesteps, (bsz,), device=latents.device) + timesteps = timesteps.long() + # Add noise to the latents according to the noise magnitude at each timestep + # (this is the forward diffusion process) + noisy_latents = noise_scheduler.add_noise(latents, noise, timesteps) + # encode text + input_id = input_ids[k, :].unsqueeze(0) + encode_hidden_states = text_encoder(input_id)[0] + # Get the target for loss depending on the prediction type + if noise_scheduler.config.prediction_type == "epsilon": + target = noise + elif noise_scheduler.config.prediction_type == "v_prediction": + target = noise_scheduler.get_velocity(latents, noise, timesteps) + else: + raise ValueError(f"Unknown prediction type {noise_scheduler.config.prediction_type}") + model_pred= unet(noisy_latents, timesteps, encode_hidden_states).sample + loss = F.mse_loss(model_pred.float(), target.float(), reduction="mean") + if k == 1: + # calculate loss of class(prior) + loss *= args.prior_loss_weight + loss.backward() + if k == 1: + print(f"==loss - image index {instance_idx}, loss: {loss.detach().item() / args.prior_loss_weight}, prior") + else: + print(f"==loss - image index {instance_idx}, loss: {loss.detach().item()}, instance") + + params_to_clip = ( + itertools.chain(unet.parameters(), text_encoder.parameters()) + if args.train_text_encoder + else unet.parameters() + ) + torch.nn.utils.clip_grad_norm_(params_to_clip, 1.0, error_if_nonfinite=True) + optimizer.step() + optimizer.zero_grad() + + return [unet, text_encoder] + + + +def pgd_attack( + args, + accelerator, + models, + tokenizer, + noise_scheduler:DDIMScheduler, + vae:AutoencoderKL, + data_tensor: torch.Tensor, + original_images: torch.Tensor, + target_tensor: torch.Tensor, + weight_dtype = torch.bfloat16, +): + """Return new perturbed data""" + + num_steps = args.max_adv_train_steps + + unet, text_encoder = models + device = accelerator.device + if args.constraint == 'lpips': + lpips_vgg = lpips.LPIPS(net='vgg') + + vae.to(device, dtype=weight_dtype) + text_encoder.to(device, dtype=weight_dtype) + unet.to(device, dtype=weight_dtype) + if args.low_vram_mode: + unet.set_use_memory_efficient_attention_xformers(True) + vae.requires_grad_(False) + text_encoder.requires_grad_(False) + unet.requires_grad_(False) + data_tensor = data_tensor.detach().clone() + num_image = len(data_tensor) + image_list = [] + tbar = tqdm(range(num_image)) + tbar.set_description("PGD attack") + for id in range(num_image): + tbar.update(1) + perturbed_image = data_tensor[id, :].unsqueeze(0) + perturbed_image.requires_grad = True + original_image = original_images[id, :].unsqueeze(0) + input_ids = tokenizer( + args.instance_prompt, + truncation=True, + padding="max_length", + max_length=tokenizer.model_max_length, + return_tensors="pt", + ).input_ids + input_ids = input_ids.to(device) + for step in range(num_steps): + perturbed_image.requires_grad = False + with torch.no_grad(): + latents = vae.encode(perturbed_image.to(device, dtype=weight_dtype)).latent_dist.mean + #offload vae + latents = latents.detach().clone() + latents.requires_grad = True + latents = latents * vae.config.scaling_factor + + # Sample noise that we'll add to the latents + noise = torch.randn_like(latents) + bsz = latents.shape[0] + # Sample a random timestep for each image + timesteps = torch.randint(0, noise_scheduler.config.num_train_timesteps, (bsz,), device=latents.device) + timesteps = timesteps.long() + + # Add noise to the latents according to the noise magnitude at each timestep + # (this is the forward diffusion process) + noisy_latents = noise_scheduler.add_noise(latents, noise, timesteps) + + # Get the text embedding for conditioning + encoder_hidden_states = text_encoder(input_ids)[0] + + # Predict the noise residual + model_pred = unet(noisy_latents, timesteps, encoder_hidden_states).sample + + # Get the target for loss depending on the prediction type + if noise_scheduler.config.prediction_type == "epsilon": + target = noise + elif noise_scheduler.config.prediction_type == "v_prediction": + target = noise_scheduler.get_velocity(latents, noise, timesteps) + else: + raise ValueError(f"Unknown prediction type {noise_scheduler.config.prediction_type}") + + unet.zero_grad() + text_encoder.zero_grad() + loss = F.mse_loss(model_pred.float(), target.float(), reduction="mean") + + # target-shift loss + if target_tensor is not None: + if args.mode != 'anti-db': + loss = - F.mse_loss(model_pred, target_tensor) + # fused mode + if args.mode == 'fused': + latent_attack = LatentAttack() + loss = loss - 1e2 * latent_attack(latents, target_tensor=target_tensor) + + loss = loss / args.gradient_accumulation_steps + grads = autograd.grad(loss, latents)[0].detach().clone() + # now loss is backproped to latents + #print('grads: {}'.format(grads)) + #do forward on vae again + perturbed_image.requires_grad = True + gc_latents = vae.encode(perturbed_image.to(device, dtype=weight_dtype)).latent_dist.mean + gc_latents.backward(gradient=grads) + + if step % args.gradient_accumulation_steps == args.gradient_accumulation_steps - 1: + + if args.constraint == 'eps': + alpha = args.pgd_alpha + adv_images = perturbed_image + alpha * perturbed_image.grad.sign() + + # hard constraint + eps = args.pgd_eps + eta = torch.clamp(adv_images - original_image, min=-eps, max=+eps) + perturbed_image = torch.clamp(original_image + eta, min=-1, max=+1).detach_() + perturbed_image.requires_grad = True + elif args.constraint == 'lpips': + # compute reg loss + lpips_distance = lpips_vgg(perturbed_image, original_image) + reg_loss = args.lpips_weight * torch.max(lpips_distance - args.lpips_bound, 0)[0].squeeze() + reg_loss.backward() + + alpha = args.pgd_alpha + adv_images = perturbed_image + alpha * perturbed_image.grad.sign() + + eta = adv_images - original_image + perturbed_image = torch.clamp(original_image + eta, min=-1, max=+1).detach_() + perturbed_image.requires_grad = True + else: + raise NotImplementedError + + #print(f"PGD loss - step {step}, loss: {loss.detach().item()}") + + image_list.append(perturbed_image.detach().clone().squeeze(0)) + outputs = torch.stack(image_list) + + + return outputs + +def main(args): + if args.cuda: + try: + pynvml.nvmlInit() + handle = pynvml.nvmlDeviceGetHandleByIndex(0) + mem_info = pynvml.nvmlDeviceGetMemoryInfo(handle) + mem_free = mem_info.free / float(1073741824) + if mem_free < 5.5: + raise NotImplementedError("Your GPU memory is not enough for running Mist on GPU. Please try CPU mode.") + except: + raise NotImplementedError("No GPU found in GPU mode. Please try CPU mode.") + + + logging_dir = Path(args.output_dir, args.logging_dir) + + if not args.cuda: + accelerator = Accelerator( + mixed_precision=args.mixed_precision, + log_with=args.report_to, + project_dir=logging_dir, + cpu=True + ) + else: + accelerator = Accelerator( + mixed_precision=args.mixed_precision, + log_with=args.report_to, + project_dir=logging_dir + ) + + logging.basicConfig( + format="%(asctime)s - %(levelname)s - %(name)s - %(message)s", + datefmt="%m/%d/%Y %H:%M:%S", + level=logging.INFO, + ) + logger.info(accelerator.state, main_process_only=False) + if accelerator.is_local_main_process: + datasets.utils.logging.set_verbosity_warning() + transformers.utils.logging.set_verbosity_warning() + diffusers.utils.logging.set_verbosity_info() + else: + datasets.utils.logging.set_verbosity_error() + transformers.utils.logging.set_verbosity_error() + diffusers.utils.logging.set_verbosity_error() + + if args.seed is not None: + set_seed(args.seed) + + weight_dtype = torch.float32 + if args.cuda: + if accelerator.mixed_precision == "fp16": + weight_dtype = torch.float16 + elif accelerator.mixed_precision == "bf16": + weight_dtype = torch.bfloat16 + print("==precision: {}==".format(weight_dtype)) + + # Generate class images if prior preservation is enabled. + if args.with_prior_preservation: + class_images_dir = Path(args.class_data_dir) + if not class_images_dir.exists(): + class_images_dir.mkdir(parents=True) + cur_class_images = len(list(class_images_dir.iterdir())) + + if cur_class_images < args.num_class_images: + torch_dtype = torch.float16 if accelerator.device.type == "cuda" else torch.float32 + if args.mixed_precision == "fp32": + torch_dtype = torch.float32 + elif args.mixed_precision == "fp16": + torch_dtype = torch.float16 + elif args.mixed_precision == "bf16": + torch_dtype = torch.bfloat16 + pipeline = DiffusionPipeline.from_pretrained( + args.pretrained_model_name_or_path, + torch_dtype=torch_dtype, + safety_checker=None, + revision=args.revision, + ) + pipeline.set_progress_bar_config(disable=True) + + num_new_images = args.num_class_images - cur_class_images + logger.info(f"Number of class images to sample: {num_new_images}.") + + sample_dataset = PromptDataset(args.class_prompt, num_new_images) + sample_dataloader = torch.utils.data.DataLoader(sample_dataset, batch_size=args.sample_batch_size) + + sample_dataloader = accelerator.prepare(sample_dataloader) + pipeline.to(accelerator.device) + + for example in tqdm( + sample_dataloader, + desc="Generating class images", + disable=not accelerator.is_local_main_process, + ): + images = pipeline(example["prompt"]).images + + for i, image in enumerate(images): + hash_image = hashlib.sha1(image.tobytes()).hexdigest() + image_filename = class_images_dir / f"{example['index'][i] + cur_class_images}-{hash_image}.jpg" + image.save(image_filename) + + del pipeline + if torch.cuda.is_available(): + torch.cuda.empty_cache() + + # import correct text encoder class + text_encoder_cls = import_model_class_from_model_name_or_path(args.pretrained_model_name_or_path, args.revision) + + # Load scheduler and models + text_encoder = text_encoder_cls.from_pretrained( + args.pretrained_model_name_or_path, + subfolder="text_encoder", + revision=args.revision, + ) + unet = UNet2DConditionModel.from_pretrained( + args.pretrained_model_name_or_path, subfolder="unet", revision=args.revision + ) + + # add by lora + unet.requires_grad_(False) + # end: added by lora + + tokenizer = AutoTokenizer.from_pretrained( + args.pretrained_model_name_or_path, + subfolder="tokenizer", + revision=args.revision, + use_fast=False, + ) + + + noise_scheduler = DDIMScheduler.from_pretrained(args.pretrained_model_name_or_path, subfolder="scheduler") + if not args.cuda: + vae = AutoencoderKL.from_pretrained( + args.pretrained_model_name_or_path, subfolder="vae", revision=args.revision + ).cuda() + else: + vae = AutoencoderKL.from_pretrained( + args.pretrained_model_name_or_path, subfolder="vae", revision=args.revision + ) + vae.to(accelerator.device, dtype=weight_dtype) + vae.requires_grad_(False) + vae.encoder.training = True + vae.encoder.gradient_checkpointing = True + + #print info about train_text_encoder + + if not args.train_text_encoder: + text_encoder.requires_grad_(False) + + if args.allow_tf32: + torch.backends.cuda.matmul.allow_tf32 = True + + perturbed_data, prompts, data_sizes = load_data( + args.instance_data_dir, + size=args.resolution, + center_crop=args.center_crop, + ) + original_data = perturbed_data.clone() + original_data.requires_grad_(False) + + + target_latent_tensor = None + if args.target_image_path is not None and args.target_image_path != "": + # print(Style.BRIGHT+Back.BLUE+Fore.GREEN+'load target image from {}'.format(args.target_image_path)) + target_image_path = Path(args.target_image_path) + assert target_image_path.is_file(), f"Target image path {target_image_path} does not exist" + + target_image = Image.open(target_image_path).convert("RGB").resize((args.resolution, args.resolution)) + target_image = np.array(target_image)[None].transpose(0, 3, 1, 2) + if args.cuda: + target_image_tensor = torch.from_numpy(target_image).to("cuda", dtype=weight_dtype) / 127.5 - 1.0 + else: + target_image_tensor = torch.from_numpy(target_image).to(dtype=weight_dtype) / 127.5 - 1.0 + target_latent_tensor = ( + vae.encode(target_image_tensor).latent_dist.sample().to(dtype=weight_dtype) * vae.config.scaling_factor + ) + target_image_tensor = target_image_tensor.to('cpu') + del target_image_tensor + #target_latent_tensor = target_latent_tensor.repeat(len(perturbed_data), 1, 1, 1).cuda() + f = [unet, text_encoder] + for i in range(args.max_train_steps): + f_sur = copy.deepcopy(f) + perturbed_data = pgd_attack( + args, + accelerator, + f_sur, + tokenizer, + noise_scheduler, + vae, + perturbed_data, + original_data, + target_latent_tensor, + weight_dtype, + ) + del f_sur + if args.cuda: + gc.collect() + f = train_one_epoch( + args, + accelerator, + f, + tokenizer, + noise_scheduler, + vae, + perturbed_data, + prompts, + weight_dtype, + ) + + for model in f: + if model != None: + model.to('cpu') + + if args.cuda: + gc.collect() + pynvml.nvmlInit() + handle = pynvml.nvmlDeviceGetHandleByIndex(0) + mem_info = pynvml.nvmlDeviceGetMemoryInfo(handle) + print("=======Epoch {} ends! Memory cost: {}======".format(i, mem_info.used / float(1073741824))) + else: + print("=======Epoch {} ends!======".format(i)) + + if (i + 1) % args.max_train_steps == 0: + save_folder = f"{args.output_dir}" + os.makedirs(save_folder, exist_ok=True) + noised_imgs = perturbed_data.detach().cpu() + origin_imgs = original_data.detach().cpu() + img_names = [] + for filename in os.listdir(args.instance_data_dir): + if filename.endswith(".png") or filename.endswith(".jpg"): + img_names.append(str(filename)) + for img_pixel, ori_img_pixel, img_name, img_size in zip(noised_imgs, origin_imgs, img_names, data_sizes): + save_path = os.path.join(save_folder, f"{i+1}_noise_{img_name}") + if not args.resize: + Image.fromarray( + (img_pixel * 127.5 + 128).clamp(0, 255).to(torch.uint8).permute(1, 2, 0).numpy() + ).save(save_path) + else: + ori_img_path = os.path.join(args.instance_data_dir, img_name) + ori_img = np.array(Image.open(ori_img_path).convert("RGB")) + + ori_img_duzzy = np.array(Image.fromarray( + (ori_img_pixel * 127.5 + 128).clamp(0, 255).to(torch.uint8).permute(1, 2, 0).numpy() + ).resize(img_size), dtype=np.int32) + perturbed_img_duzzy = np.array(Image.fromarray( + (img_pixel * 127.5 + 128).clamp(0, 255).to(torch.uint8).permute(1, 2, 0).numpy() + ).resize(img_size), dtype=np.int32) + + perturbation = perturbed_img_duzzy - ori_img_duzzy + assert perturbation.shape == ori_img.shape + + perturbed_img = (ori_img + perturbation).clip(0, 255).astype(np.uint8) + # print("perturbation: {}, ori: {}, res: {}".format( + # perturbed_img_duzzy[:2, :2, :], ori_img_duzzy[:2, :2, :], perturbed_img_duzzy[:2, :2, :])) + Image.fromarray(perturbed_img).save(save_path) + + + print(f"==Saved misted image to {save_path}, size: {img_size}==") + # print(f"Saved noise at step {i+1} to {save_folder}") + del noised_imgs + +def update_args_with_config(args, config): + ''' + Update the default augments in args with config assigned by users + args list: + eps: + max train epoch: + data path: + class path: + output path: + device: + gpu normal, + gpu low vram, + cpu, + mode: + lunet, full + ''' + + args = parse_args() + eps, device, mode, resize, data_path, output_path, model_path, class_path, prompt, \ + class_prompt, max_train_steps, max_f_train_steps, max_adv_train_steps, lora_lr, pgd_lr, \ + rank, prior_loss_weight, fused_weight, constraint_mode, lpips_bound, lpips_weight = config + args.pgd_eps = float(eps)/255.0 + if device == 'cpu': + args.cuda, args.low_vram_mode = False, False + else: + args.cuda, args.low_vram_mode = True, True + # if precision == 'bfloat16': + # args.mixed_precision = 'bf16' + # else: + # args.mixed_precision = 'fp16' + if mode == 'Mode 1': + args.mode = 'lunet' + elif mode == 'Mode 2': + args.mode = 'fused' + elif mode == 'Mode 3': + args.mode = 'anti-db' + if resize: + args.resize = True + + assert os.path.exists(data_path) and os.path.exists(output_path) + args.instance_data_dir = data_path + args.output_dir = output_path + args.pretrained_model_name_or_path = model_path + args.class_data_dir = class_path + args.instance_prompt = prompt + + args.class_prompt = class_prompt + args.max_train_steps = max_train_steps + args.max_f_train_steps = max_f_train_steps + args.max_adv_train_steps = max_adv_train_steps + args.learning_rate = lora_lr + args.pgd_alpha = pgd_lr + args.rank = rank + args.prior_loss_weight = prior_loss_weight + args.fused_weight = fused_weight + + if constraint_mode == 'LPIPS': + args.constraint = 'lpips' + else: + args.constraint = 'eps' + args.lpips_bound = lpips_bound + args.lpips_weight = lpips_weight + + return args + + +if __name__ == "__main__": + args = parse_args() + main(args) + diff --git a/attacks/utils.py b/attacks/utils.py new file mode 100644 index 0000000000000000000000000000000000000000..efd43e9089b0ccd0491f7b20a31cebe35d25cbb8 --- /dev/null +++ b/attacks/utils.py @@ -0,0 +1,113 @@ +import torch +import torch.nn.functional as F + +prompt_dataset = [ + "Portrait of an astronaut in space, detailed starry background, reflective helmet,", + "Painting of a floating island with giant clock gears, populated with mythical creatures,", + "Landscape of a Japanese garden in autumn, with a bridge over a koi pond,", + "Painting representing the sound of jazz music, using vibrant colors and erratic shapes,", + "Painting of a modern smartphone with classic art pieces appearing on the screen,", + "Battle scene with futuristic robots and a golden palace in the background,", + "Scene of a bustling city market with different perspectives of people and stalls,", + "Scene of a ship sailing in a stormy sea, with dramatic lighting and powerful waves,", + "Portraint of a female botanist surrounded by exotic plants in a greenhouse,", + "Painting of an ancient castle at night, with a full moon, gargoyles, and shadows,", +] + +style_dataset = [ + "Art Nouveau", + "Romantic", + "Cubist", + "Baroque", + "Pop Art", + "Abstract", + "Impressionist", + "Surrealist", + "Renaissance", + "Pointillism", +] + + + +class attack_mixin: + def __call__( + self, + latents: torch.Tensor, + timesteps: torch.Tensor, + encoder_hidden_states: torch.Tensor, + unet: torch.nn.Module, + target_tensor: torch.Tensor, + noise_scheduler + ): + raise NotImplementedError + +class AdvDM(attack_mixin): + """ + This attack aims to maximize the training loss of diffusion model + """ + def __call__( + self, + latents: torch.Tensor, + noise: torch.Tensor, + timesteps: torch.Tensor, + encoder_hidden_states: torch.Tensor, + unet: torch.nn.Module, + text_encoder: torch.nn.Module, + input_ids, + target_tensor: torch.Tensor, + noise_scheduler + ): + noisy_latents = noise_scheduler.add_noise(latents, noise, timesteps) + + # Get the text embedding for conditioning + encoder_hidden_states = text_encoder(input_ids)[0] + + # Predict the noise residual + model_pred = unet(noisy_latents, timesteps, encoder_hidden_states).sample + + # Get the target for loss depending on the prediction type + if noise_scheduler.config.prediction_type == "epsilon": + target = noise + elif noise_scheduler.config.prediction_type == "v_prediction": + target = noise_scheduler.get_velocity(latents, noise, timesteps) + else: + raise ValueError(f"Unknown prediction type {noise_scheduler.config.prediction_type}") + + unet.zero_grad() + text_encoder.zero_grad() + loss = F.mse_loss(model_pred.float(), target.float(), reduction="mean") + + # target-shift loss + if target_tensor is not None: + xtm1_pred = torch.cat( + [ + noise_scheduler.step( + model_pred[idx : idx + 1], + timesteps[idx : idx + 1], + noisy_latents[idx : idx + 1], + ).prev_sample + for idx in range(len(model_pred)) + ] + ) + xtm1_target = noise_scheduler.add_noise(target_tensor, noise, timesteps - 1) + loss = loss - F.mse_loss(xtm1_pred, xtm1_target) + + return loss + +class LatentAttack(attack_mixin): + """ + This attack aims to minimize the l2 distance between latent and target_tensor + """ + def __call__( + self, + latents: torch.Tensor, + timesteps: torch.Tensor=None, + encoder_hidden_states: torch.Tensor=None, + unet: torch.nn.Module=None, + target_tensor: torch.Tensor=None, + noise_scheduler=None + ): + if target_tensor == None: + raise ValueError("Need a target tensor for pre-attack") + loss = - F.mse_loss(latents, target_tensor, reduction="mean") + return loss \ No newline at end of file diff --git a/data/MIST.png b/data/MIST.png new file mode 100644 index 0000000000000000000000000000000000000000..76419f283b3aaffa0e3894a697343150b97bd8f3 Binary files /dev/null and b/data/MIST.png differ diff --git a/eval/sample_lora_15.ipynb b/eval/sample_lora_15.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..339720eaf5fd4007a34390e6ec154cf28982fddc --- /dev/null +++ b/eval/sample_lora_15.ipynb @@ -0,0 +1,149 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Demo: Sampling with LoRA in Diffusion Models\n", + "\n", + "Sample with vanilla Stable Diffusion.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/caradryan/programs/anaconda3/envs/ITA/lib/python3.10/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", + " from .autonotebook import tqdm as notebook_tqdm\n", + "100%|██████████| 50/50 [00:05<00:00, 9.85it/s]\n" + ] + }, + { + "data": { + "image/jpeg": "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", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from diffusers import StableDiffusionPipeline, EulerAncestralDiscreteScheduler, StableDiffusionImg2ImgPipeline\n", + "import torch\n", + "import sys\n", + "import time\n", + "sys.path.insert(0, sys.path[0]+\"/../\")\n", + "\n", + "model_id = \"../stable-diffusion/stable-diffusion-1-5\"\n", + "\n", + "pipe = StableDiffusionPipeline.from_pretrained(model_id, torch_dtype=torch.float16).to(\n", + " \"cuda\"\n", + ")\n", + "pipe.scheduler = EulerAncestralDiscreteScheduler.from_config(pipe.scheduler.config)\n", + "\n", + "prompt = \"a photo of a sks person\"\n", + "torch.manual_seed(time.time())\n", + "image = pipe(prompt, num_inference_steps=50, guidance_scale=7, height=512,width=512).images[0]\n", + "\n", + "image # nice. diffusers are cool.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Sample with LoRA in Stable Diffusion" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 50/50 [00:05<00:00, 9.61it/s]\n" + ] + }, + { + "data": { + "image/jpeg": "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", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from lora_diffusion import tune_lora_scale, patch_pipe\n", + "torch.manual_seed(time.time())\n", + "\n", + "# The directory of LoRA, modify it to $LORA_OUTPUT_DIR after training the LoRA\n", + "LORA_OUTPUT_DIR = '../output/lora/'\n", + "\n", + "# necessary for outputing attack performance\n", + "def dummy(images, **kwargs):\n", + " return images, [False] * images.shape[0]\n", + "pipe.safety_checker = None \n", + "\n", + "patch_pipe(\n", + " pipe,\n", + " LORA_OUTPUT_DIR,\n", + " patch_text=True,\n", + " patch_ti=False,\n", + " patch_unet=True,\n", + ")\n", + "\n", + "tune_lora_scale(pipe.unet, 0.75)\n", + "tune_lora_scale(pipe.text_encoder, 0.75)\n", + "# prompt = 'a painting of a sks person, high quality, masterpiece'\n", + "prompt = 'a painting of a sks person in dress, high quality, masterpiece'\n", + "image = pipe(prompt, num_inference_steps=50, guidance_scale=7, height=512,width=512).images[0]\n", + "image.save(\"../output/lora_output_example.jpg\")\n", + "image\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.8.12 ('pytorch_latest')", + "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.10.13" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "952e1bebe1b278d85469a034aefc1854b777c1b518feedf8249123f6f86cec05" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/eval/train_dreambooth_lora_15.py b/eval/train_dreambooth_lora_15.py new file mode 100644 index 0000000000000000000000000000000000000000..5f2e89abf5a266ae7d60acdf0aa4914b597e551d --- /dev/null +++ b/eval/train_dreambooth_lora_15.py @@ -0,0 +1,1007 @@ +# Bootstrapped from: +# https://github.com/huggingface/diffusers/blob/main/examples/dreambooth/train_dreambooth.py + +import argparse +import hashlib +import itertools +import math +import os +import inspect +from pathlib import Path +from typing import Optional + +import torch +import torch.nn.functional as F +import torch.utils.checkpoint +import os +import sys +sys.path.insert(0, sys.path[0]+"/../") +from accelerate import Accelerator +from accelerate.logging import get_logger +from accelerate.utils import set_seed +from diffusers import ( + AutoencoderKL, + DDPMScheduler, + StableDiffusionPipeline, + UNet2DConditionModel, +) +from diffusers.optimization import get_scheduler +from huggingface_hub import HfFolder, Repository, whoami + +from tqdm.auto import tqdm +from transformers import CLIPTextModel, CLIPTokenizer + +from lora_diffusion import ( + extract_lora_ups_down, + inject_trainable_lora, + safetensors_available, + save_lora_weight, + save_safeloras, +) +from lora_diffusion.xformers_utils import set_use_memory_efficient_attention_xformers +from PIL import Image +from torch.utils.data import Dataset +from torchvision import transforms + +from pathlib import Path + +import random +import re + + +class DreamBoothDataset(Dataset): + """ + A dataset to prepare the instance and class images with the prompts for fine-tuning the model. + It pre-processes the images and the tokenizes prompts. + """ + + def __init__( + self, + instance_data_root, + instance_prompt, + tokenizer, + class_data_root=None, + class_prompt=None, + size=512, + center_crop=False, + color_jitter=False, + h_flip=False, + resize=False, + ): + self.size = size + self.center_crop = center_crop + self.tokenizer = tokenizer + self.resize = resize + + self.instance_data_root = Path(instance_data_root) + if not self.instance_data_root.exists(): + raise ValueError("Instance images root doesn't exists.") + + self.instance_images_path = [] + for filename in os.listdir(instance_data_root): + if filename.endswith(".png") or filename.endswith(".jpg"): + self.instance_images_path.append(os.path.join(instance_data_root, filename)) + self.num_instance_images = len(self.instance_images_path) + self.instance_prompt = instance_prompt + self._length = self.num_instance_images + + if class_data_root is not None: + self.class_data_root = Path(class_data_root) + self.class_data_root.mkdir(parents=True, exist_ok=True) + self.class_images_path = list(self.class_data_root.iterdir()) + self.num_class_images = len(self.class_images_path) + self._length = max(self.num_class_images, self.num_instance_images) + self.class_prompt = class_prompt + else: + self.class_data_root = None + + img_transforms = [] + + if resize: + img_transforms.append( + transforms.Resize( + size, interpolation=transforms.InterpolationMode.BILINEAR + ) + ) + if center_crop: + img_transforms.append(transforms.CenterCrop(size)) + if color_jitter: + img_transforms.append(transforms.ColorJitter(0.2, 0.1)) + if h_flip: + img_transforms.append(transforms.RandomHorizontalFlip()) + + self.image_transforms = transforms.Compose( + [*img_transforms, transforms.ToTensor(), transforms.Normalize([0.5], [0.5])] + ) + + def __len__(self): + return self._length + + def __getitem__(self, index): + example = {} + instance_image = Image.open( + self.instance_images_path[index % self.num_instance_images] + ) + if not instance_image.mode == "RGB": + instance_image = instance_image.convert("RGB") + example["instance_images"] = self.image_transforms(instance_image) + example["instance_prompt_ids"] = self.tokenizer( + self.instance_prompt, + padding="do_not_pad", + truncation=True, + max_length=self.tokenizer.model_max_length, + ).input_ids + + if self.class_data_root: + class_image = Image.open( + self.class_images_path[index % self.num_class_images] + ) + if not class_image.mode == "RGB": + class_image = class_image.convert("RGB") + example["class_images"] = self.image_transforms(class_image) + example["class_prompt_ids"] = self.tokenizer( + self.class_prompt, + padding="do_not_pad", + truncation=True, + max_length=self.tokenizer.model_max_length, + ).input_ids + + return example + + +class PromptDataset(Dataset): + "A simple dataset to prepare the prompts to generate class images on multiple GPUs." + + def __init__(self, prompt, num_samples): + self.prompt = prompt + self.num_samples = num_samples + + def __len__(self): + return self.num_samples + + def __getitem__(self, index): + example = {} + example["prompt"] = self.prompt + example["index"] = index + return example + + +logger = get_logger(__name__) + + +def parse_args(input_args=None): + parser = argparse.ArgumentParser(description="Simple example of a training script.") + parser.add_argument( + "--pretrained_model_name_or_path", + type=str, + default="stable-diffusion/stable-diffusion-1-5", + help="Path to pretrained model or model identifier from huggingface.co/models.", + ) + parser.add_argument( + "--pretrained_vae_name_or_path", + type=str, + default=None, + help="Path to pretrained vae or vae identifier from huggingface.co/models.", + ) + parser.add_argument( + "--revision", + type=str, + default=None, + help="Revision of pretrained model identifier from huggingface.co/models.", + ) + parser.add_argument( + "--tokenizer_name", + type=str, + default=None, + help="Pretrained tokenizer name or path if not the same as model_name", + ) + parser.add_argument( + "--instance_data_dir", + type=str, + default="outputs/celeba-20-121/noise-ckpt/5", + help="A folder containing the training data of instance images.", + ) + parser.add_argument( + "--class_data_dir", + type=str, + default="data/celeba-20-121", + required=False, + help="A folder containing the training data of class images.", + ) + parser.add_argument( + "--instance_prompt", + type=str, + default="a photo of sks person", + help="The prompt with identifier specifying the instance", + ) + parser.add_argument( + "--class_prompt", + type=str, + default="a photo of person", + help="The prompt to specify images in the same class as provided instance images.", + ) + parser.add_argument( + "--with_prior_preservation", + default=True, + help="Flag to add prior preservation loss.", + ) + parser.add_argument( + "--prior_loss_weight", + type=float, + default=1.0, + help="The weight of prior preservation loss.", + ) + parser.add_argument( + "--num_class_images", + type=int, + default=100, + help=( + "Minimal class images for prior preservation loss. If not have enough images, additional images will be" + " sampled with class_prompt." + ), + ) + parser.add_argument( + "--output_dir", + type=str, + default="lora_repo/model", + help="The output directory where the model predictions and checkpoints will be written.", + ) + parser.add_argument( + "--output_format", + type=str, + choices=["pt", "safe", "both"], + default="both", + help="The output format of the model predicitions and checkpoints.", + ) + parser.add_argument( + "--seed", type=int, default=None, help="A seed for reproducible training." + ) + parser.add_argument( + "--resolution", + type=int, + default=512, + help=( + "The resolution for input images, all the images in the train/validation dataset will be resized to this" + " resolution" + ), + ) + parser.add_argument( + "--center_crop", + default=True, + help="Whether to center crop images before resizing to resolution", + ) + parser.add_argument( + "--color_jitter", + action="store_true", + help="Whether to apply color jitter to images", + ) + parser.add_argument( + "--train_text_encoder", + default=True, + help="Whether to train the text encoder", + ) + parser.add_argument( + "--train_batch_size", + type=int, + default=1, + help="Batch size (per device) for the training dataloader.", + ) + parser.add_argument( + "--sample_batch_size", + type=int, + default=4, + help="Batch size (per device) for sampling images.", + ) + parser.add_argument("--num_train_epochs", type=int, default=1) + parser.add_argument( + "--max_train_steps", + type=int, + default=1000, + help="Total number of training steps to perform. If provided, overrides num_train_epochs.", + ) + parser.add_argument( + "--save_steps", + type=int, + default=1000, + help="Save checkpoint every X updates steps.", + ) + parser.add_argument( + "--gradient_accumulation_steps", + type=int, + default=1, + help="Number of updates steps to accumulate before performing a backward/update pass.", + ) + parser.add_argument( + "--gradient_checkpointing", + action="store_true", + help="Whether or not to use gradient checkpointing to save memory at the expense of slower backward pass.", + ) + parser.add_argument( + "--lora_rank", + type=int, + default=4, + help="Rank of LoRA approximation.", + ) + parser.add_argument( + "--learning_rate", + type=float, + default=1e-4, + help="Initial learning rate (after the potential warmup period) to use.", + ) + parser.add_argument( + "--learning_rate_text", + type=float, + default=5e-5, + help="Initial learning rate for text encoder (after the potential warmup period) to use.", + ) + parser.add_argument( + "--scale_lr", + action="store_true", + default=False, + help="Scale the learning rate by the number of GPUs, gradient accumulation steps, and batch size.", + ) + parser.add_argument( + "--lr_scheduler", + type=str, + default="constant", + help=( + 'The scheduler type to use. Choose between ["linear", "cosine", "cosine_with_restarts", "polynomial",' + ' "constant", "constant_with_warmup"]' + ), + ) + parser.add_argument( + "--lr_warmup_steps", + type=int, + default=500, + help="Number of steps for the warmup in the lr scheduler.", + ) + parser.add_argument( + "--use_8bit_adam", + action="store_true", + help="Whether or not to use 8-bit Adam from bitsandbytes.", + ) + parser.add_argument( + "--adam_beta1", + type=float, + default=0.9, + help="The beta1 parameter for the Adam optimizer.", + ) + parser.add_argument( + "--adam_beta2", + type=float, + default=0.999, + help="The beta2 parameter for the Adam optimizer.", + ) + parser.add_argument( + "--adam_weight_decay", type=float, default=1e-2, help="Weight decay to use." + ) + parser.add_argument( + "--adam_epsilon", + type=float, + default=1e-08, + help="Epsilon value for the Adam optimizer", + ) + parser.add_argument( + "--max_grad_norm", default=1.0, type=float, help="Max gradient norm." + ) + parser.add_argument( + "--push_to_hub", + action="store_true", + help="Whether or not to push the model to the Hub.", + ) + parser.add_argument( + "--hub_token", + type=str, + default=None, + help="The token to use to push to the Model Hub.", + ) + parser.add_argument( + "--logging_dir", + type=str, + default="logs", + help=( + "[TensorBoard](https://www.tensorflow.org/tensorboard) log directory. Will default to" + " *output_dir/runs/**CURRENT_DATETIME_HOSTNAME***." + ), + ) + parser.add_argument( + "--mixed_precision", + type=str, + default=None, + choices=["no", "fp16", "bf16"], + help=( + "Whether to use mixed precision. Choose between fp16 and bf16 (bfloat16). Bf16 requires PyTorch >=" + " 1.10.and an Nvidia Ampere GPU. Default to the value of accelerate config of the current system or the" + " flag passed with the `accelerate.launch` command. Use this argument to override the accelerate config." + ), + ) + parser.add_argument( + "--local_rank", + type=int, + default=-1, + help="For distributed training: local_rank", + ) + parser.add_argument( + "--resume_unet", + type=str, + default=None, + help=("File path for unet lora to resume training."), + ) + parser.add_argument( + "--resume_text_encoder", + type=str, + default=None, + help=("File path for text encoder lora to resume training."), + ) + parser.add_argument( + "--resize", + type=bool, + default=True, + required=False, + help="Should images be resized to --resolution before training?", + ) + parser.add_argument( + "--use_xformers", action="store_true", help="Whether or not to use xformers" + ) + + if input_args is not None: + args = parser.parse_args(input_args) + else: + args = parser.parse_args() + + env_local_rank = int(os.environ.get("LOCAL_RANK", -1)) + if env_local_rank != -1 and env_local_rank != args.local_rank: + args.local_rank = env_local_rank + + if args.with_prior_preservation: + if args.class_data_dir is None: + raise ValueError("You must specify a data directory for class images.") + if args.class_prompt is None: + raise ValueError("You must specify prompt for class images.") + else: + if args.class_data_dir is not None: + logger.warning( + "You need not use --class_data_dir without --with_prior_preservation." + ) + if args.class_prompt is not None: + logger.warning( + "You need not use --class_prompt without --with_prior_preservation." + ) + + if not safetensors_available: + if args.output_format == "both": + print( + "Safetensors is not available - changing output format to just output PyTorch files" + ) + args.output_format = "pt" + elif args.output_format == "safe": + raise ValueError( + "Safetensors is not available - either install it, or change output_format." + ) + + return args + + +def main(args): + logging_dir = Path(args.output_dir, args.logging_dir) + + accelerator = Accelerator( + gradient_accumulation_steps=args.gradient_accumulation_steps, + mixed_precision=args.mixed_precision, + log_with="tensorboard", + project_dir=logging_dir, + ) + + # Currently, it's not possible to do gradient accumulation when training two models with accelerate.accumulate + # This will be enabled soon in accelerate. For now, we don't allow gradient accumulation when training two models. + # TODO (patil-suraj): Remove this check when gradient accumulation with two models is enabled in accelerate. + if ( + args.train_text_encoder + and args.gradient_accumulation_steps > 1 + and accelerator.num_processes > 1 + ): + raise ValueError( + "Gradient accumulation is not supported when training the text encoder in distributed training. " + "Please set gradient_accumulation_steps to 1. This feature will be supported in the future." + ) + + if args.seed is not None: + set_seed(args.seed) + + if args.with_prior_preservation: + class_images_dir = Path(args.class_data_dir) + if not class_images_dir.exists(): + class_images_dir.mkdir(parents=True) + cur_class_images = len(list(class_images_dir.iterdir())) + + if cur_class_images < args.num_class_images: + torch_dtype = ( + torch.float16 if accelerator.device.type == "cuda" else torch.float32 + ) + pipeline = StableDiffusionPipeline.from_pretrained( + args.pretrained_model_name_or_path, + torch_dtype=torch_dtype, + safety_checker=None, + revision=args.revision, + ) + pipeline.set_progress_bar_config(disable=True) + + num_new_images = args.num_class_images - cur_class_images + logger.info(f"Number of class images to sample: {num_new_images}.") + + sample_dataset = PromptDataset(args.class_prompt, num_new_images) + sample_dataloader = torch.utils.data.DataLoader( + sample_dataset, batch_size=args.sample_batch_size + ) + + sample_dataloader = accelerator.prepare(sample_dataloader) + pipeline.to(accelerator.device) + + for example in tqdm( + sample_dataloader, + desc="Generating class images", + disable=not accelerator.is_local_main_process, + ): + images = pipeline(example["prompt"]).images + + for i, image in enumerate(images): + hash_image = hashlib.sha1(image.tobytes()).hexdigest() + image_filename = ( + class_images_dir + / f"{example['index'][i] + cur_class_images}-{hash_image}.jpg" + ) + image.save(image_filename) + + del pipeline + if torch.cuda.is_available(): + torch.cuda.empty_cache() + + # Handle the repository creation + if accelerator.is_main_process: + + if args.output_dir is not None: + os.makedirs(args.output_dir, exist_ok=True) + + # Load the tokenizer + if args.tokenizer_name: + tokenizer = CLIPTokenizer.from_pretrained( + args.tokenizer_name, + revision=args.revision, + ) + elif args.pretrained_model_name_or_path: + tokenizer = CLIPTokenizer.from_pretrained( + args.pretrained_model_name_or_path, + subfolder="tokenizer", + revision=args.revision, + ) + + # Load models and create wrapper for stable diffusion + text_encoder = CLIPTextModel.from_pretrained( + args.pretrained_model_name_or_path, + subfolder="text_encoder", + revision=args.revision, + ) + vae = AutoencoderKL.from_pretrained( + args.pretrained_vae_name_or_path or args.pretrained_model_name_or_path, + subfolder=None if args.pretrained_vae_name_or_path else "vae", + revision=None if args.pretrained_vae_name_or_path else args.revision, + ) + unet = UNet2DConditionModel.from_pretrained( + args.pretrained_model_name_or_path, + subfolder="unet", + revision=args.revision, + ) + unet.requires_grad_(False) + unet_lora_params, _ = inject_trainable_lora( + unet, r=args.lora_rank, loras=args.resume_unet + ) + + for _up, _down in extract_lora_ups_down(unet): + print("Before training: Unet First Layer lora up", _up.weight.data) + print("Before training: Unet First Layer lora down", _down.weight.data) + break + + vae.requires_grad_(False) + text_encoder.requires_grad_(False) + + if args.train_text_encoder: + text_encoder_lora_params, _ = inject_trainable_lora( + text_encoder, + target_replace_module=["CLIPAttention"], + r=args.lora_rank, + ) + for _up, _down in extract_lora_ups_down( + text_encoder, target_replace_module=["CLIPAttention"] + ): + print("Before training: text encoder First Layer lora up", _up.weight.data) + print( + "Before training: text encoder First Layer lora down", _down.weight.data + ) + break + + if args.use_xformers: + set_use_memory_efficient_attention_xformers(unet, True) + set_use_memory_efficient_attention_xformers(vae, True) + + if args.gradient_checkpointing: + unet.enable_gradient_checkpointing() + if args.train_text_encoder: + text_encoder.gradient_checkpointing_enable() + + if args.scale_lr: + args.learning_rate = ( + args.learning_rate + * args.gradient_accumulation_steps + * args.train_batch_size + * accelerator.num_processes + ) + + # Use 8-bit Adam for lower memory usage or to fine-tune the model in 16GB GPUs + if args.use_8bit_adam: + try: + import bitsandbytes as bnb + except ImportError: + raise ImportError( + "To use 8-bit Adam, please install the bitsandbytes library: `pip install bitsandbytes`." + ) + + optimizer_class = bnb.optim.AdamW8bit + else: + optimizer_class = torch.optim.AdamW + + text_lr = ( + args.learning_rate + if args.learning_rate_text is None + else args.learning_rate_text + ) + + params_to_optimize = ( + [ + {"params": itertools.chain(*unet_lora_params), "lr": args.learning_rate}, + { + "params": itertools.chain(*text_encoder_lora_params), + "lr": text_lr, + }, + ] + if args.train_text_encoder + else itertools.chain(*unet_lora_params) + ) + optimizer = optimizer_class( + params_to_optimize, + lr=args.learning_rate, + betas=(args.adam_beta1, args.adam_beta2), + weight_decay=args.adam_weight_decay, + eps=args.adam_epsilon, + ) + + noise_scheduler = DDPMScheduler.from_config( + args.pretrained_model_name_or_path, subfolder="scheduler" + ) + + train_dataset = DreamBoothDataset( + instance_data_root=args.instance_data_dir, + instance_prompt=args.instance_prompt, + class_data_root=args.class_data_dir if args.with_prior_preservation else None, + class_prompt=args.class_prompt, + tokenizer=tokenizer, + size=args.resolution, + center_crop=args.center_crop, + color_jitter=args.color_jitter, + resize=args.resize, + ) + + def collate_fn(examples): + input_ids = [example["instance_prompt_ids"] for example in examples] + pixel_values = [example["instance_images"] for example in examples] + + # Concat class and instance examples for prior preservation. + # We do this to avoid doing two forward passes. + if args.with_prior_preservation: + input_ids += [example["class_prompt_ids"] for example in examples] + pixel_values += [example["class_images"] for example in examples] + + pixel_values = torch.stack(pixel_values) + pixel_values = pixel_values.to(memory_format=torch.contiguous_format).float() + + input_ids = tokenizer.pad( + {"input_ids": input_ids}, + padding="max_length", + max_length=tokenizer.model_max_length, + return_tensors="pt", + ).input_ids + + batch = { + "input_ids": input_ids, + "pixel_values": pixel_values, + } + return batch + + train_dataloader = torch.utils.data.DataLoader( + train_dataset, + batch_size=args.train_batch_size, + shuffle=True, + collate_fn=collate_fn, + num_workers=0, + ) + + # Scheduler and math around the number of training steps. + overrode_max_train_steps = False + num_update_steps_per_epoch = math.ceil( + len(train_dataloader) / args.gradient_accumulation_steps + ) + if args.max_train_steps is None: + args.max_train_steps = args.num_train_epochs * num_update_steps_per_epoch + overrode_max_train_steps = True + + lr_scheduler = get_scheduler( + args.lr_scheduler, + optimizer=optimizer, + num_warmup_steps=args.lr_warmup_steps * args.gradient_accumulation_steps, + num_training_steps=args.max_train_steps * args.gradient_accumulation_steps, + ) + + if args.train_text_encoder: + ( + unet, + text_encoder, + optimizer, + train_dataloader, + lr_scheduler, + ) = accelerator.prepare( + unet, text_encoder, optimizer, train_dataloader, lr_scheduler + ) + else: + unet, optimizer, train_dataloader, lr_scheduler = accelerator.prepare( + unet, optimizer, train_dataloader, lr_scheduler + ) + + weight_dtype = torch.float32 + if accelerator.mixed_precision == "fp16": + weight_dtype = torch.float16 + elif accelerator.mixed_precision == "bf16": + weight_dtype = torch.bfloat16 + + # Move text_encode and vae to gpu. + # For mixed precision training we cast the text_encoder and vae weights to half-precision + # as these models are only used for inference, keeping weights in full precision is not required. + vae.to(accelerator.device, dtype=weight_dtype) + if not args.train_text_encoder: + text_encoder.to(accelerator.device, dtype=weight_dtype) + + # We need to recalculate our total training steps as the size of the training dataloader may have changed. + num_update_steps_per_epoch = math.ceil( + len(train_dataloader) / args.gradient_accumulation_steps + ) + if overrode_max_train_steps: + args.max_train_steps = args.num_train_epochs * num_update_steps_per_epoch + # Afterwards we recalculate our number of training epochs + args.num_train_epochs = math.ceil(args.max_train_steps / num_update_steps_per_epoch) + + # We need to initialize the trackers we use, and also store our configuration. + # The trackers initializes automatically on the main process. + if accelerator.is_main_process: + accelerator.init_trackers("dreambooth", config=vars(args)) + + # Train! + total_batch_size = ( + args.train_batch_size + * accelerator.num_processes + * args.gradient_accumulation_steps + ) + + print("***** Running training *****") + print(f" Num examples = {len(train_dataset)}") + print(f" Num batches each epoch = {len(train_dataloader)}") + print(f" Num Epochs = {args.num_train_epochs}") + print(f" Instantaneous batch size per device = {args.train_batch_size}") + print( + f" Total train batch size (w. parallel, distributed & accumulation) = {total_batch_size}" + ) + print(f" Gradient Accumulation steps = {args.gradient_accumulation_steps}") + print(f" Total optimization steps = {args.max_train_steps}") + # Only show the progress bar once on each machine. + progress_bar = tqdm( + range(args.max_train_steps), disable=not accelerator.is_local_main_process + ) + progress_bar.set_description("Steps") + global_step = 0 + last_save = 0 + + for epoch in range(args.num_train_epochs): + unet.train() + if args.train_text_encoder: + text_encoder.train() + + for step, batch in enumerate(train_dataloader): + # Convert images to latent space + latents = vae.encode( + batch["pixel_values"].to(dtype=weight_dtype) + ).latent_dist.sample() + latents = latents * 0.18215 + + # Sample noise that we'll add to the latents + noise = torch.randn_like(latents) + bsz = latents.shape[0] + # Sample a random timestep for each image + timesteps = torch.randint( + 0, + noise_scheduler.config.num_train_timesteps, + (bsz,), + device=latents.device, + ) + timesteps = timesteps.long() + + # Add noise to the latents according to the noise magnitude at each timestep + # (this is the forward diffusion process) + noisy_latents = noise_scheduler.add_noise(latents, noise, timesteps) + + # Get the text embedding for conditioning + encoder_hidden_states = text_encoder(batch["input_ids"])[0] + + # Predict the noise residual + model_pred = unet(noisy_latents, timesteps, encoder_hidden_states).sample + + # Get the target for loss depending on the prediction type + if noise_scheduler.config.prediction_type == "epsilon": + target = noise + elif noise_scheduler.config.prediction_type == "v_prediction": + target = noise_scheduler.get_velocity(latents, noise, timesteps) + else: + raise ValueError( + f"Unknown prediction type {noise_scheduler.config.prediction_type}" + ) + + if args.with_prior_preservation: + # Chunk the noise and model_pred into two parts and compute the loss on each part separately. + model_pred, model_pred_prior = torch.chunk(model_pred, 2, dim=0) + target, target_prior = torch.chunk(target, 2, dim=0) + + # Compute instance loss + loss = ( + F.mse_loss(model_pred.float(), target.float(), reduction="none") + .mean([1, 2, 3]) + .mean() + ) + + # Compute prior loss + prior_loss = F.mse_loss( + model_pred_prior.float(), target_prior.float(), reduction="mean" + ) + + # Add the prior loss to the instance loss. + loss = loss + args.prior_loss_weight * prior_loss + else: + loss = F.mse_loss(model_pred.float(), target.float(), reduction="mean") + + accelerator.backward(loss) + if accelerator.sync_gradients: + params_to_clip = ( + itertools.chain(unet.parameters(), text_encoder.parameters()) + if args.train_text_encoder + else unet.parameters() + ) + accelerator.clip_grad_norm_(params_to_clip, args.max_grad_norm) + optimizer.step() + lr_scheduler.step() + progress_bar.update(1) + optimizer.zero_grad() + + global_step += 1 + + # Checks if the accelerator has performed an optimization step behind the scenes + if accelerator.sync_gradients: + if args.save_steps and global_step - last_save >= args.save_steps: + if accelerator.is_main_process: + # newer versions of accelerate allow the 'keep_fp32_wrapper' arg. without passing + # it, the models will be unwrapped, and when they are then used for further training, + # we will crash. pass this, but only to newer versions of accelerate. fixes + # https://github.com/huggingface/diffusers/issues/1566 + accepts_keep_fp32_wrapper = "keep_fp32_wrapper" in set( + inspect.signature( + accelerator.unwrap_model + ).parameters.keys() + ) + extra_args = ( + {"keep_fp32_wrapper": True} + if accepts_keep_fp32_wrapper + else {} + ) + pipeline = StableDiffusionPipeline.from_pretrained( + args.pretrained_model_name_or_path, + unet=accelerator.unwrap_model(unet, **extra_args), + text_encoder=accelerator.unwrap_model( + text_encoder, **extra_args + ), + revision=args.revision, + ) + + filename_unet = ( + f"{args.output_dir}/lora_weight_e{epoch}_s{global_step}.pt" + ) + filename_text_encoder = f"{args.output_dir}/lora_weight_e{epoch}_s{global_step}.text_encoder.pt" + print(f"save weights {filename_unet}, {filename_text_encoder}") + save_lora_weight(pipeline.unet, filename_unet) + if args.train_text_encoder: + save_lora_weight( + pipeline.text_encoder, + filename_text_encoder, + target_replace_module=["CLIPAttention"], + ) + + for _up, _down in extract_lora_ups_down(pipeline.unet): + print( + "First Unet Layer's Up Weight is now : ", + _up.weight.data, + ) + print( + "First Unet Layer's Down Weight is now : ", + _down.weight.data, + ) + break + if args.train_text_encoder: + for _up, _down in extract_lora_ups_down( + pipeline.text_encoder, + target_replace_module=["CLIPAttention"], + ): + print( + "First Text Encoder Layer's Up Weight is now : ", + _up.weight.data, + ) + print( + "First Text Encoder Layer's Down Weight is now : ", + _down.weight.data, + ) + break + + last_save = global_step + + logs = {"loss": loss.detach().item(), "lr": lr_scheduler.get_last_lr()[0]} + progress_bar.set_postfix(**logs) + accelerator.log(logs, step=global_step) + + if global_step >= args.max_train_steps: + break + + accelerator.wait_for_everyone() + + # Create the pipeline using using the trained modules and save it. + if accelerator.is_main_process: + pipeline = StableDiffusionPipeline.from_pretrained( + args.pretrained_model_name_or_path, + unet=accelerator.unwrap_model(unet), + text_encoder=accelerator.unwrap_model(text_encoder), + revision=args.revision, + ) + + print("\n\nLora TRAINING DONE!\n\n") + + if args.output_format == "pt" or args.output_format == "both": + save_lora_weight(pipeline.unet, args.output_dir + "/lora_weight.pt") + if args.train_text_encoder: + save_lora_weight( + pipeline.text_encoder, + args.output_dir + "/lora_weight.text_encoder.pt", + target_replace_module=["CLIPAttention"], + ) + + if args.output_format == "safe" or args.output_format == "both": + loras = {} + loras["unet"] = (pipeline.unet, {"CrossAttention", "Attention", "GEGLU"}) + if args.train_text_encoder: + loras["text_encoder"] = (pipeline.text_encoder, {"CLIPAttention"}) + + save_safeloras(loras, args.output_dir + "/lora_weight.safetensors") + + if args.push_to_hub: + repo.push_to_hub( + commit_message="End of training", + blocking=False, + auto_lfs_prune=True, + ) + + accelerator.end_training() + + +if __name__ == "__main__": + args = parse_args() + main(args) \ No newline at end of file diff --git a/ldm/configs/karlo/decoder_900M_vit_l.yaml b/ldm/configs/karlo/decoder_900M_vit_l.yaml new file mode 100644 index 0000000000000000000000000000000000000000..02a35303aaa3c3556c649768643814cbd7c8fe66 --- /dev/null +++ b/ldm/configs/karlo/decoder_900M_vit_l.yaml @@ -0,0 +1,37 @@ +model: + type: t2i-decoder + diffusion_sampler: uniform + hparams: + image_size: 64 + num_channels: 320 + num_res_blocks: 3 + channel_mult: '' + attention_resolutions: 32,16,8 + num_heads: -1 + num_head_channels: 64 + num_heads_upsample: -1 + use_scale_shift_norm: true + dropout: 0.1 + clip_dim: 768 + clip_emb_mult: 4 + text_ctx: 77 + xf_width: 1536 + xf_layers: 0 + xf_heads: 0 + xf_final_ln: false + resblock_updown: true + learn_sigma: true + text_drop: 0.3 + clip_emb_type: image + clip_emb_drop: 0.1 + use_plm: true + +diffusion: + steps: 1000 + learn_sigma: true + sigma_small: false + noise_schedule: squaredcos_cap_v2 + use_kl: false + predict_xstart: false + rescale_learned_sigmas: true + timestep_respacing: '' diff --git a/ldm/configs/karlo/improved_sr_64_256_1.4B.yaml b/ldm/configs/karlo/improved_sr_64_256_1.4B.yaml new file mode 100644 index 0000000000000000000000000000000000000000..282d3cb0db6a51e076e9848f8d26e55e7ae406bb --- /dev/null +++ b/ldm/configs/karlo/improved_sr_64_256_1.4B.yaml @@ -0,0 +1,27 @@ +model: + type: improved_sr_64_256 + diffusion_sampler: uniform + hparams: + channels: 320 + depth: 3 + channels_multiple: + - 1 + - 2 + - 3 + - 4 + dropout: 0.0 + +diffusion: + steps: 1000 + learn_sigma: false + sigma_small: true + noise_schedule: squaredcos_cap_v2 + use_kl: false + predict_xstart: false + rescale_learned_sigmas: true + timestep_respacing: '7' + + +sampling: + timestep_respacing: '7' # fix + clip_denoise: true diff --git a/ldm/configs/karlo/prior_1B_vit_l.yaml b/ldm/configs/karlo/prior_1B_vit_l.yaml new file mode 100644 index 0000000000000000000000000000000000000000..159330d3085527ae142f122b182cfec7a560a3db --- /dev/null +++ b/ldm/configs/karlo/prior_1B_vit_l.yaml @@ -0,0 +1,21 @@ +model: + type: prior + diffusion_sampler: uniform + hparams: + text_ctx: 77 + xf_width: 2048 + xf_layers: 20 + xf_heads: 32 + xf_final_ln: true + text_drop: 0.2 + clip_dim: 768 + +diffusion: + steps: 1000 + learn_sigma: false + sigma_small: true + noise_schedule: squaredcos_cap_v2 + use_kl: false + predict_xstart: true + rescale_learned_sigmas: false + timestep_respacing: '' diff --git a/ldm/configs/stable-diffusion/intel/v2-inference-bf16.yaml b/ldm/configs/stable-diffusion/intel/v2-inference-bf16.yaml new file mode 100644 index 0000000000000000000000000000000000000000..66f0dbd8331d84a78a3448fdb2a69dcd7020eb59 --- /dev/null +++ b/ldm/configs/stable-diffusion/intel/v2-inference-bf16.yaml @@ -0,0 +1,71 @@ +# Copyright (C) 2022 Intel Corporation +# SPDX-License-Identifier: MIT + +model: + base_learning_rate: 1.0e-4 + target: ldm.models.diffusion.ddpm.LatentDiffusion + params: + linear_start: 0.00085 + linear_end: 0.0120 + num_timesteps_cond: 1 + log_every_t: 200 + timesteps: 1000 + first_stage_key: "jpg" + cond_stage_key: "txt" + image_size: 64 + channels: 4 + cond_stage_trainable: false + conditioning_key: crossattn + monitor: val/loss_simple_ema + scale_factor: 0.18215 + use_ema: False # we set this to false because this is an inference only config + + unet_config: + target: ldm.modules.diffusionmodules.openaimodel.UNetModel + params: + use_checkpoint: False + use_fp16: False + use_bf16: True + image_size: 32 # unused + in_channels: 4 + out_channels: 4 + model_channels: 320 + attention_resolutions: [ 4, 2, 1 ] + num_res_blocks: 2 + channel_mult: [ 1, 2, 4, 4 ] + num_head_channels: 64 # need to fix for flash-attn + use_spatial_transformer: True + use_linear_in_transformer: True + transformer_depth: 1 + context_dim: 1024 + legacy: False + + first_stage_config: + target: ldm.models.autoencoder.AutoencoderKL + params: + embed_dim: 4 + monitor: val/rec_loss + ddconfig: + #attn_type: "vanilla-xformers" + double_z: true + z_channels: 4 + resolution: 256 + in_channels: 3 + out_ch: 3 + ch: 128 + ch_mult: + - 1 + - 2 + - 4 + - 4 + num_res_blocks: 2 + attn_resolutions: [] + dropout: 0.0 + lossconfig: + target: torch.nn.Identity + + cond_stage_config: + target: ldm.modules.encoders.modules.FrozenOpenCLIPEmbedder + params: + freeze: True + layer: "penultimate" diff --git a/ldm/configs/stable-diffusion/intel/v2-inference-fp32.yaml b/ldm/configs/stable-diffusion/intel/v2-inference-fp32.yaml new file mode 100644 index 0000000000000000000000000000000000000000..7b66ac85830e8884b26cb9e70e094172c9ee5e62 --- /dev/null +++ b/ldm/configs/stable-diffusion/intel/v2-inference-fp32.yaml @@ -0,0 +1,70 @@ +# Copyright (C) 2022 Intel Corporation +# SPDX-License-Identifier: MIT + +model: + base_learning_rate: 1.0e-4 + target: ldm.models.diffusion.ddpm.LatentDiffusion + params: + linear_start: 0.00085 + linear_end: 0.0120 + num_timesteps_cond: 1 + log_every_t: 200 + timesteps: 1000 + first_stage_key: "jpg" + cond_stage_key: "txt" + image_size: 64 + channels: 4 + cond_stage_trainable: false + conditioning_key: crossattn + monitor: val/loss_simple_ema + scale_factor: 0.18215 + use_ema: False # we set this to false because this is an inference only config + + unet_config: + target: ldm.modules.diffusionmodules.openaimodel.UNetModel + params: + use_checkpoint: False + use_fp16: False + image_size: 32 # unused + in_channels: 4 + out_channels: 4 + model_channels: 320 + attention_resolutions: [ 4, 2, 1 ] + num_res_blocks: 2 + channel_mult: [ 1, 2, 4, 4 ] + num_head_channels: 64 # need to fix for flash-attn + use_spatial_transformer: True + use_linear_in_transformer: True + transformer_depth: 1 + context_dim: 1024 + legacy: False + + first_stage_config: + target: ldm.models.autoencoder.AutoencoderKL + params: + embed_dim: 4 + monitor: val/rec_loss + ddconfig: + #attn_type: "vanilla-xformers" + double_z: true + z_channels: 4 + resolution: 256 + in_channels: 3 + out_ch: 3 + ch: 128 + ch_mult: + - 1 + - 2 + - 4 + - 4 + num_res_blocks: 2 + attn_resolutions: [] + dropout: 0.0 + lossconfig: + target: torch.nn.Identity + + cond_stage_config: + target: ldm.modules.encoders.modules.FrozenOpenCLIPEmbedder + params: + freeze: True + layer: "penultimate" diff --git a/ldm/configs/stable-diffusion/intel/v2-inference-v-bf16.yaml b/ldm/configs/stable-diffusion/intel/v2-inference-v-bf16.yaml new file mode 100644 index 0000000000000000000000000000000000000000..2b4b0e6fabce186a0e5cd29d4efa29eebee152f7 --- /dev/null +++ b/ldm/configs/stable-diffusion/intel/v2-inference-v-bf16.yaml @@ -0,0 +1,72 @@ +# Copyright (C) 2022 Intel Corporation +# SPDX-License-Identifier: MIT + +model: + base_learning_rate: 1.0e-4 + target: ldm.models.diffusion.ddpm.LatentDiffusion + params: + parameterization: "v" + linear_start: 0.00085 + linear_end: 0.0120 + num_timesteps_cond: 1 + log_every_t: 200 + timesteps: 1000 + first_stage_key: "jpg" + cond_stage_key: "txt" + image_size: 64 + channels: 4 + cond_stage_trainable: false + conditioning_key: crossattn + monitor: val/loss_simple_ema + scale_factor: 0.18215 + use_ema: False # we set this to false because this is an inference only config + + unet_config: + target: ldm.modules.diffusionmodules.openaimodel.UNetModel + params: + use_checkpoint: False + use_fp16: False + use_bf16: True + image_size: 32 # unused + in_channels: 4 + out_channels: 4 + model_channels: 320 + attention_resolutions: [ 4, 2, 1 ] + num_res_blocks: 2 + channel_mult: [ 1, 2, 4, 4 ] + num_head_channels: 64 # need to fix for flash-attn + use_spatial_transformer: True + use_linear_in_transformer: True + transformer_depth: 1 + context_dim: 1024 + legacy: False + + first_stage_config: + target: ldm.models.autoencoder.AutoencoderKL + params: + embed_dim: 4 + monitor: val/rec_loss + ddconfig: + #attn_type: "vanilla-xformers" + double_z: true + z_channels: 4 + resolution: 256 + in_channels: 3 + out_ch: 3 + ch: 128 + ch_mult: + - 1 + - 2 + - 4 + - 4 + num_res_blocks: 2 + attn_resolutions: [] + dropout: 0.0 + lossconfig: + target: torch.nn.Identity + + cond_stage_config: + target: ldm.modules.encoders.modules.FrozenOpenCLIPEmbedder + params: + freeze: True + layer: "penultimate" diff --git a/ldm/configs/stable-diffusion/intel/v2-inference-v-fp32.yaml b/ldm/configs/stable-diffusion/intel/v2-inference-v-fp32.yaml new file mode 100644 index 0000000000000000000000000000000000000000..8ccd92e295d71681750f749bb7972a62cc44b3cb --- /dev/null +++ b/ldm/configs/stable-diffusion/intel/v2-inference-v-fp32.yaml @@ -0,0 +1,71 @@ +# Copyright (C) 2022 Intel Corporation +# SPDX-License-Identifier: MIT + +model: + base_learning_rate: 1.0e-4 + target: ldm.models.diffusion.ddpm.LatentDiffusion + params: + parameterization: "v" + linear_start: 0.00085 + linear_end: 0.0120 + num_timesteps_cond: 1 + log_every_t: 200 + timesteps: 1000 + first_stage_key: "jpg" + cond_stage_key: "txt" + image_size: 64 + channels: 4 + cond_stage_trainable: false + conditioning_key: crossattn + monitor: val/loss_simple_ema + scale_factor: 0.18215 + use_ema: False # we set this to false because this is an inference only config + + unet_config: + target: ldm.modules.diffusionmodules.openaimodel.UNetModel + params: + use_checkpoint: False + use_fp16: False + image_size: 32 # unused + in_channels: 4 + out_channels: 4 + model_channels: 320 + attention_resolutions: [ 4, 2, 1 ] + num_res_blocks: 2 + channel_mult: [ 1, 2, 4, 4 ] + num_head_channels: 64 # need to fix for flash-attn + use_spatial_transformer: True + use_linear_in_transformer: True + transformer_depth: 1 + context_dim: 1024 + legacy: False + + first_stage_config: + target: ldm.models.autoencoder.AutoencoderKL + params: + embed_dim: 4 + monitor: val/rec_loss + ddconfig: + #attn_type: "vanilla-xformers" + double_z: true + z_channels: 4 + resolution: 256 + in_channels: 3 + out_ch: 3 + ch: 128 + ch_mult: + - 1 + - 2 + - 4 + - 4 + num_res_blocks: 2 + attn_resolutions: [] + dropout: 0.0 + lossconfig: + target: torch.nn.Identity + + cond_stage_config: + target: ldm.modules.encoders.modules.FrozenOpenCLIPEmbedder + params: + freeze: True + layer: "penultimate" diff --git a/ldm/configs/stable-diffusion/v2-1-stable-unclip-h-inference.yaml b/ldm/configs/stable-diffusion/v2-1-stable-unclip-h-inference.yaml new file mode 100644 index 0000000000000000000000000000000000000000..1bd0c64d3cdf2e3027fcd68b986b3236d4b4101c --- /dev/null +++ b/ldm/configs/stable-diffusion/v2-1-stable-unclip-h-inference.yaml @@ -0,0 +1,80 @@ +model: + base_learning_rate: 1.0e-04 + target: ldm.models.diffusion.ddpm.ImageEmbeddingConditionedLatentDiffusion + params: + embedding_dropout: 0.25 + parameterization: "v" + linear_start: 0.00085 + linear_end: 0.0120 + log_every_t: 200 + timesteps: 1000 + first_stage_key: "jpg" + cond_stage_key: "txt" + image_size: 96 + channels: 4 + cond_stage_trainable: false + conditioning_key: crossattn-adm + scale_factor: 0.18215 + monitor: val/loss_simple_ema + use_ema: False + + embedder_config: + target: ldm.modules.encoders.modules.FrozenOpenCLIPImageEmbedder + + noise_aug_config: + target: ldm.modules.encoders.modules.CLIPEmbeddingNoiseAugmentation + params: + timestep_dim: 1024 + noise_schedule_config: + timesteps: 1000 + beta_schedule: squaredcos_cap_v2 + + unet_config: + target: ldm.modules.diffusionmodules.openaimodel.UNetModel + params: + num_classes: "sequential" + adm_in_channels: 2048 + use_checkpoint: True + image_size: 32 # unused + in_channels: 4 + out_channels: 4 + model_channels: 320 + attention_resolutions: [ 4, 2, 1 ] + num_res_blocks: 2 + channel_mult: [ 1, 2, 4, 4 ] + num_head_channels: 64 # need to fix for flash-attn + use_spatial_transformer: True + use_linear_in_transformer: True + transformer_depth: 1 + context_dim: 1024 + legacy: False + + first_stage_config: + target: ldm.models.autoencoder.AutoencoderKL + params: + embed_dim: 4 + monitor: val/rec_loss + ddconfig: + attn_type: "vanilla-xformers" + double_z: true + z_channels: 4 + resolution: 256 + in_channels: 3 + out_ch: 3 + ch: 128 + ch_mult: + - 1 + - 2 + - 4 + - 4 + num_res_blocks: 2 + attn_resolutions: [ ] + dropout: 0.0 + lossconfig: + target: torch.nn.Identity + + cond_stage_config: + target: ldm.modules.encoders.modules.FrozenOpenCLIPEmbedder + params: + freeze: True + layer: "penultimate" diff --git a/ldm/configs/stable-diffusion/v2-1-stable-unclip-l-inference.yaml b/ldm/configs/stable-diffusion/v2-1-stable-unclip-l-inference.yaml new file mode 100644 index 0000000000000000000000000000000000000000..335fd61f3e559ba093320b67c950dec5494bf489 --- /dev/null +++ b/ldm/configs/stable-diffusion/v2-1-stable-unclip-l-inference.yaml @@ -0,0 +1,83 @@ +model: + base_learning_rate: 1.0e-04 + target: ldm.models.diffusion.ddpm.ImageEmbeddingConditionedLatentDiffusion + params: + embedding_dropout: 0.25 + parameterization: "v" + linear_start: 0.00085 + linear_end: 0.0120 + log_every_t: 200 + timesteps: 1000 + first_stage_key: "jpg" + cond_stage_key: "txt" + image_size: 96 + channels: 4 + cond_stage_trainable: false + conditioning_key: crossattn-adm + scale_factor: 0.18215 + monitor: val/loss_simple_ema + use_ema: False + + embedder_config: + target: ldm.modules.encoders.modules.ClipImageEmbedder + params: + model: "ViT-L/14" + + noise_aug_config: + target: ldm.modules.encoders.modules.CLIPEmbeddingNoiseAugmentation + params: + clip_stats_path: "checkpoints/karlo_models/ViT-L-14_stats.th" + timestep_dim: 768 + noise_schedule_config: + timesteps: 1000 + beta_schedule: squaredcos_cap_v2 + + unet_config: + target: ldm.modules.diffusionmodules.openaimodel.UNetModel + params: + num_classes: "sequential" + adm_in_channels: 1536 + use_checkpoint: True + image_size: 32 # unused + in_channels: 4 + out_channels: 4 + model_channels: 320 + attention_resolutions: [ 4, 2, 1 ] + num_res_blocks: 2 + channel_mult: [ 1, 2, 4, 4 ] + num_head_channels: 64 # need to fix for flash-attn + use_spatial_transformer: True + use_linear_in_transformer: True + transformer_depth: 1 + context_dim: 1024 + legacy: False + + first_stage_config: + target: ldm.models.autoencoder.AutoencoderKL + params: + embed_dim: 4 + monitor: val/rec_loss + ddconfig: + attn_type: "vanilla-xformers" + double_z: true + z_channels: 4 + resolution: 256 + in_channels: 3 + out_ch: 3 + ch: 128 + ch_mult: + - 1 + - 2 + - 4 + - 4 + num_res_blocks: 2 + attn_resolutions: [ ] + dropout: 0.0 + lossconfig: + target: torch.nn.Identity + + cond_stage_config: + target: ldm.modules.encoders.modules.FrozenOpenCLIPEmbedder + params: + freeze: True + layer: "penultimate" \ No newline at end of file diff --git a/ldm/configs/stable-diffusion/v2-inference-v.yaml b/ldm/configs/stable-diffusion/v2-inference-v.yaml new file mode 100644 index 0000000000000000000000000000000000000000..8ec8dfbfefe94ae8522c93017668fea78d580acf --- /dev/null +++ b/ldm/configs/stable-diffusion/v2-inference-v.yaml @@ -0,0 +1,68 @@ +model: + base_learning_rate: 1.0e-4 + target: ldm.models.diffusion.ddpm.LatentDiffusion + params: + parameterization: "v" + linear_start: 0.00085 + linear_end: 0.0120 + num_timesteps_cond: 1 + log_every_t: 200 + timesteps: 1000 + first_stage_key: "jpg" + cond_stage_key: "txt" + image_size: 64 + channels: 4 + cond_stage_trainable: false + conditioning_key: crossattn + monitor: val/loss_simple_ema + scale_factor: 0.18215 + use_ema: False # we set this to false because this is an inference only config + + unet_config: + target: ldm.modules.diffusionmodules.openaimodel.UNetModel + params: + use_checkpoint: True + use_fp16: True + image_size: 32 # unused + in_channels: 4 + out_channels: 4 + model_channels: 320 + attention_resolutions: [ 4, 2, 1 ] + num_res_blocks: 2 + channel_mult: [ 1, 2, 4, 4 ] + num_head_channels: 64 # need to fix for flash-attn + use_spatial_transformer: True + use_linear_in_transformer: True + transformer_depth: 1 + context_dim: 1024 + legacy: False + + first_stage_config: + target: ldm.models.autoencoder.AutoencoderKL + params: + embed_dim: 4 + monitor: val/rec_loss + ddconfig: + #attn_type: "vanilla-xformers" + double_z: true + z_channels: 4 + resolution: 256 + in_channels: 3 + out_ch: 3 + ch: 128 + ch_mult: + - 1 + - 2 + - 4 + - 4 + num_res_blocks: 2 + attn_resolutions: [] + dropout: 0.0 + lossconfig: + target: torch.nn.Identity + + cond_stage_config: + target: ldm.modules.encoders.modules.FrozenOpenCLIPEmbedder + params: + freeze: True + layer: "penultimate" diff --git a/ldm/configs/stable-diffusion/v2-inference.yaml b/ldm/configs/stable-diffusion/v2-inference.yaml new file mode 100644 index 0000000000000000000000000000000000000000..152c4f3c2b36c3b246a9cb10eb8166134b0d2e1c --- /dev/null +++ b/ldm/configs/stable-diffusion/v2-inference.yaml @@ -0,0 +1,67 @@ +model: + base_learning_rate: 1.0e-4 + target: ldm.models.diffusion.ddpm.LatentDiffusion + params: + linear_start: 0.00085 + linear_end: 0.0120 + num_timesteps_cond: 1 + log_every_t: 200 + timesteps: 1000 + first_stage_key: "jpg" + cond_stage_key: "txt" + image_size: 64 + channels: 4 + cond_stage_trainable: false + conditioning_key: crossattn + monitor: val/loss_simple_ema + scale_factor: 0.18215 + use_ema: False # we set this to false because this is an inference only config + + unet_config: + target: ldm.modules.diffusionmodules.openaimodel.UNetModel + params: + use_checkpoint: True + use_fp16: True + image_size: 32 # unused + in_channels: 4 + out_channels: 4 + model_channels: 320 + attention_resolutions: [ 4, 2, 1 ] + num_res_blocks: 2 + channel_mult: [ 1, 2, 4, 4 ] + num_head_channels: 64 # need to fix for flash-attn + use_spatial_transformer: True + use_linear_in_transformer: True + transformer_depth: 1 + context_dim: 1024 + legacy: False + + first_stage_config: + target: ldm.models.autoencoder.AutoencoderKL + params: + embed_dim: 4 + monitor: val/rec_loss + ddconfig: + #attn_type: "vanilla-xformers" + double_z: true + z_channels: 4 + resolution: 256 + in_channels: 3 + out_ch: 3 + ch: 128 + ch_mult: + - 1 + - 2 + - 4 + - 4 + num_res_blocks: 2 + attn_resolutions: [] + dropout: 0.0 + lossconfig: + target: torch.nn.Identity + + cond_stage_config: + target: ldm.modules.encoders.modules.FrozenOpenCLIPEmbedder + params: + freeze: True + layer: "penultimate" diff --git a/ldm/configs/stable-diffusion/v2-inpainting-inference.yaml b/ldm/configs/stable-diffusion/v2-inpainting-inference.yaml new file mode 100644 index 0000000000000000000000000000000000000000..32a9471d71b828c51bcbbabfe34c5f6c8282c803 --- /dev/null +++ b/ldm/configs/stable-diffusion/v2-inpainting-inference.yaml @@ -0,0 +1,158 @@ +model: + base_learning_rate: 5.0e-05 + target: ldm.models.diffusion.ddpm.LatentInpaintDiffusion + params: + linear_start: 0.00085 + linear_end: 0.0120 + num_timesteps_cond: 1 + log_every_t: 200 + timesteps: 1000 + first_stage_key: "jpg" + cond_stage_key: "txt" + image_size: 64 + channels: 4 + cond_stage_trainable: false + conditioning_key: hybrid + scale_factor: 0.18215 + monitor: val/loss_simple_ema + finetune_keys: null + use_ema: False + + unet_config: + target: ldm.modules.diffusionmodules.openaimodel.UNetModel + params: + use_checkpoint: True + image_size: 32 # unused + in_channels: 9 + out_channels: 4 + model_channels: 320 + attention_resolutions: [ 4, 2, 1 ] + num_res_blocks: 2 + channel_mult: [ 1, 2, 4, 4 ] + num_head_channels: 64 # need to fix for flash-attn + use_spatial_transformer: True + use_linear_in_transformer: True + transformer_depth: 1 + context_dim: 1024 + legacy: False + + first_stage_config: + target: ldm.models.autoencoder.AutoencoderKL + params: + embed_dim: 4 + monitor: val/rec_loss + ddconfig: + #attn_type: "vanilla-xformers" + double_z: true + z_channels: 4 + resolution: 256 + in_channels: 3 + out_ch: 3 + ch: 128 + ch_mult: + - 1 + - 2 + - 4 + - 4 + num_res_blocks: 2 + attn_resolutions: [ ] + dropout: 0.0 + lossconfig: + target: torch.nn.Identity + + cond_stage_config: + target: ldm.modules.encoders.modules.FrozenOpenCLIPEmbedder + params: + freeze: True + layer: "penultimate" + + +data: + target: ldm.data.laion.WebDataModuleFromConfig + params: + tar_base: null # for concat as in LAION-A + p_unsafe_threshold: 0.1 + filter_word_list: "data/filters.yaml" + max_pwatermark: 0.45 + batch_size: 8 + num_workers: 6 + multinode: True + min_size: 512 + train: + shards: + - "pipe:aws s3 cp s3://stability-aws/laion-a-native/part-0/{00000..18699}.tar -" + - "pipe:aws s3 cp s3://stability-aws/laion-a-native/part-1/{00000..18699}.tar -" + - "pipe:aws s3 cp s3://stability-aws/laion-a-native/part-2/{00000..18699}.tar -" + - "pipe:aws s3 cp s3://stability-aws/laion-a-native/part-3/{00000..18699}.tar -" + - "pipe:aws s3 cp s3://stability-aws/laion-a-native/part-4/{00000..18699}.tar -" #{00000-94333}.tar" + shuffle: 10000 + image_key: jpg + image_transforms: + - target: torchvision.transforms.Resize + params: + size: 512 + interpolation: 3 + - target: torchvision.transforms.RandomCrop + params: + size: 512 + postprocess: + target: ldm.data.laion.AddMask + params: + mode: "512train-large" + p_drop: 0.25 + # NOTE use enough shards to avoid empty validation loops in workers + validation: + shards: + - "pipe:aws s3 cp s3://deep-floyd-s3/datasets/laion_cleaned-part5/{93001..94333}.tar - " + shuffle: 0 + image_key: jpg + image_transforms: + - target: torchvision.transforms.Resize + params: + size: 512 + interpolation: 3 + - target: torchvision.transforms.CenterCrop + params: + size: 512 + postprocess: + target: ldm.data.laion.AddMask + params: + mode: "512train-large" + p_drop: 0.25 + +lightning: + find_unused_parameters: True + modelcheckpoint: + params: + every_n_train_steps: 5000 + + callbacks: + metrics_over_trainsteps_checkpoint: + params: + every_n_train_steps: 10000 + + image_logger: + target: main.ImageLogger + params: + enable_autocast: False + disabled: False + batch_frequency: 1000 + max_images: 4 + increase_log_steps: False + log_first_step: False + log_images_kwargs: + use_ema_scope: False + inpaint: False + plot_progressive_rows: False + plot_diffusion_rows: False + N: 4 + unconditional_guidance_scale: 5.0 + unconditional_guidance_label: [""] + ddim_steps: 50 # todo check these out for depth2img, + ddim_eta: 0.0 # todo check these out for depth2img, + + trainer: + benchmark: True + val_check_interval: 5000000 + num_sanity_val_steps: 0 + accumulate_grad_batches: 1 diff --git a/ldm/configs/stable-diffusion/v2-midas-inference.yaml b/ldm/configs/stable-diffusion/v2-midas-inference.yaml new file mode 100644 index 0000000000000000000000000000000000000000..f20c30f618b81091e31c2c4cf15325fa38638af4 --- /dev/null +++ b/ldm/configs/stable-diffusion/v2-midas-inference.yaml @@ -0,0 +1,74 @@ +model: + base_learning_rate: 5.0e-07 + target: ldm.models.diffusion.ddpm.LatentDepth2ImageDiffusion + params: + linear_start: 0.00085 + linear_end: 0.0120 + num_timesteps_cond: 1 + log_every_t: 200 + timesteps: 1000 + first_stage_key: "jpg" + cond_stage_key: "txt" + image_size: 64 + channels: 4 + cond_stage_trainable: false + conditioning_key: hybrid + scale_factor: 0.18215 + monitor: val/loss_simple_ema + finetune_keys: null + use_ema: False + + depth_stage_config: + target: ldm.modules.midas.api.MiDaSInference + params: + model_type: "dpt_hybrid" + + unet_config: + target: ldm.modules.diffusionmodules.openaimodel.UNetModel + params: + use_checkpoint: True + image_size: 32 # unused + in_channels: 5 + out_channels: 4 + model_channels: 320 + attention_resolutions: [ 4, 2, 1 ] + num_res_blocks: 2 + channel_mult: [ 1, 2, 4, 4 ] + num_head_channels: 64 # need to fix for flash-attn + use_spatial_transformer: True + use_linear_in_transformer: True + transformer_depth: 1 + context_dim: 1024 + legacy: False + + first_stage_config: + target: ldm.models.autoencoder.AutoencoderKL + params: + embed_dim: 4 + monitor: val/rec_loss + ddconfig: + #attn_type: "vanilla-xformers" + double_z: true + z_channels: 4 + resolution: 256 + in_channels: 3 + out_ch: 3 + ch: 128 + ch_mult: + - 1 + - 2 + - 4 + - 4 + num_res_blocks: 2 + attn_resolutions: [ ] + dropout: 0.0 + lossconfig: + target: torch.nn.Identity + + cond_stage_config: + target: ldm.modules.encoders.modules.FrozenOpenCLIPEmbedder + params: + freeze: True + layer: "penultimate" + + diff --git a/ldm/configs/stable-diffusion/x4-upscaling.yaml b/ldm/configs/stable-diffusion/x4-upscaling.yaml new file mode 100644 index 0000000000000000000000000000000000000000..2db0964af699f86d1891c761710a2d53f59b842c --- /dev/null +++ b/ldm/configs/stable-diffusion/x4-upscaling.yaml @@ -0,0 +1,76 @@ +model: + base_learning_rate: 1.0e-04 + target: ldm.models.diffusion.ddpm.LatentUpscaleDiffusion + params: + parameterization: "v" + low_scale_key: "lr" + linear_start: 0.0001 + linear_end: 0.02 + num_timesteps_cond: 1 + log_every_t: 200 + timesteps: 1000 + first_stage_key: "jpg" + cond_stage_key: "txt" + image_size: 128 + channels: 4 + cond_stage_trainable: false + conditioning_key: "hybrid-adm" + monitor: val/loss_simple_ema + scale_factor: 0.08333 + use_ema: False + + low_scale_config: + target: ldm.modules.diffusionmodules.upscaling.ImageConcatWithNoiseAugmentation + params: + noise_schedule_config: # image space + linear_start: 0.0001 + linear_end: 0.02 + max_noise_level: 350 + + unet_config: + target: ldm.modules.diffusionmodules.openaimodel.UNetModel + params: + use_checkpoint: True + num_classes: 1000 # timesteps for noise conditioning (here constant, just need one) + image_size: 128 + in_channels: 7 + out_channels: 4 + model_channels: 256 + attention_resolutions: [ 2,4,8] + num_res_blocks: 2 + channel_mult: [ 1, 2, 2, 4] + disable_self_attentions: [True, True, True, False] + disable_middle_self_attn: False + num_heads: 8 + use_spatial_transformer: True + transformer_depth: 1 + context_dim: 1024 + legacy: False + use_linear_in_transformer: True + + first_stage_config: + target: ldm.models.autoencoder.AutoencoderKL + params: + embed_dim: 4 + ddconfig: + # attn_type: "vanilla-xformers" this model needs efficient attention to be feasible on HR data, also the decoder seems to break in half precision (UNet is fine though) + double_z: True + z_channels: 4 + resolution: 256 + in_channels: 3 + out_ch: 3 + ch: 128 + ch_mult: [ 1,2,4 ] # num_down = len(ch_mult)-1 + num_res_blocks: 2 + attn_resolutions: [ ] + dropout: 0.0 + + lossconfig: + target: torch.nn.Identity + + cond_stage_config: + target: ldm.modules.encoders.modules.FrozenOpenCLIPEmbedder + params: + freeze: True + layer: "penultimate" + diff --git a/ldm/data/__init__.py b/ldm/data/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/ldm/data/util.py b/ldm/data/util.py new file mode 100644 index 0000000000000000000000000000000000000000..5b60ceb2349e3bd7900ff325740e2022d2903b1c --- /dev/null +++ b/ldm/data/util.py @@ -0,0 +1,24 @@ +import torch + +from ldm.modules.midas.api import load_midas_transform + + +class AddMiDaS(object): + def __init__(self, model_type): + super().__init__() + self.transform = load_midas_transform(model_type) + + def pt2np(self, x): + x = ((x + 1.0) * .5).detach().cpu().numpy() + return x + + def np2pt(self, x): + x = torch.from_numpy(x) * 2 - 1. + return x + + def __call__(self, sample): + # sample['jpg'] is tensor hwc in [-1, 1] at this point + x = self.pt2np(sample['jpg']) + x = self.transform({"image": x})["image"] + sample['midas_in'] = x + return sample \ No newline at end of file diff --git a/ldm/models/autoencoder.py b/ldm/models/autoencoder.py new file mode 100644 index 0000000000000000000000000000000000000000..d122549995ce2cd64092c81a58419ed4a15a02fd --- /dev/null +++ b/ldm/models/autoencoder.py @@ -0,0 +1,219 @@ +import torch +import pytorch_lightning as pl +import torch.nn.functional as F +from contextlib import contextmanager + +from ldm.modules.diffusionmodules.model import Encoder, Decoder +from ldm.modules.distributions.distributions import DiagonalGaussianDistribution + +from ldm.util import instantiate_from_config +from ldm.modules.ema import LitEma + + +class AutoencoderKL(pl.LightningModule): + def __init__(self, + ddconfig, + lossconfig, + embed_dim, + ckpt_path=None, + ignore_keys=[], + image_key="image", + colorize_nlabels=None, + monitor=None, + ema_decay=None, + learn_logvar=False + ): + super().__init__() + self.learn_logvar = learn_logvar + self.image_key = image_key + self.encoder = Encoder(**ddconfig) + self.decoder = Decoder(**ddconfig) + self.loss = instantiate_from_config(lossconfig) + assert ddconfig["double_z"] + self.quant_conv = torch.nn.Conv2d(2*ddconfig["z_channels"], 2*embed_dim, 1) + self.post_quant_conv = torch.nn.Conv2d(embed_dim, ddconfig["z_channels"], 1) + self.embed_dim = embed_dim + if colorize_nlabels is not None: + assert type(colorize_nlabels)==int + self.register_buffer("colorize", torch.randn(3, colorize_nlabels, 1, 1)) + if monitor is not None: + self.monitor = monitor + + self.use_ema = ema_decay is not None + if self.use_ema: + self.ema_decay = ema_decay + assert 0. < ema_decay < 1. + self.model_ema = LitEma(self, decay=ema_decay) + print(f"Keeping EMAs of {len(list(self.model_ema.buffers()))}.") + + if ckpt_path is not None: + self.init_from_ckpt(ckpt_path, ignore_keys=ignore_keys) + + def init_from_ckpt(self, path, ignore_keys=list()): + sd = torch.load(path, map_location="cpu")["state_dict"] + keys = list(sd.keys()) + for k in keys: + for ik in ignore_keys: + if k.startswith(ik): + print("Deleting key {} from state_dict.".format(k)) + del sd[k] + self.load_state_dict(sd, strict=False) + print(f"Restored from {path}") + + @contextmanager + def ema_scope(self, context=None): + if self.use_ema: + self.model_ema.store(self.parameters()) + self.model_ema.copy_to(self) + if context is not None: + print(f"{context}: Switched to EMA weights") + try: + yield None + finally: + if self.use_ema: + self.model_ema.restore(self.parameters()) + if context is not None: + print(f"{context}: Restored training weights") + + def on_train_batch_end(self, *args, **kwargs): + if self.use_ema: + self.model_ema(self) + + def encode(self, x): + h = self.encoder(x) + moments = self.quant_conv(h) + posterior = DiagonalGaussianDistribution(moments) + return posterior + + def decode(self, z): + z = self.post_quant_conv(z) + dec = self.decoder(z) + return dec + + def forward(self, input, sample_posterior=True): + posterior = self.encode(input) + if sample_posterior: + z = posterior.sample() + else: + z = posterior.mode() + dec = self.decode(z) + return dec, posterior + + def get_input(self, batch, k): + x = batch[k] + if len(x.shape) == 3: + x = x[..., None] + x = x.permute(0, 3, 1, 2).to(memory_format=torch.contiguous_format).float() + return x + + def training_step(self, batch, batch_idx, optimizer_idx): + inputs = self.get_input(batch, self.image_key) + reconstructions, posterior = self(inputs) + + if optimizer_idx == 0: + # train encoder+decoder+logvar + aeloss, log_dict_ae = self.loss(inputs, reconstructions, posterior, optimizer_idx, self.global_step, + last_layer=self.get_last_layer(), split="train") + self.log("aeloss", aeloss, prog_bar=True, logger=True, on_step=True, on_epoch=True) + self.log_dict(log_dict_ae, prog_bar=False, logger=True, on_step=True, on_epoch=False) + return aeloss + + if optimizer_idx == 1: + # train the discriminator + discloss, log_dict_disc = self.loss(inputs, reconstructions, posterior, optimizer_idx, self.global_step, + last_layer=self.get_last_layer(), split="train") + + self.log("discloss", discloss, prog_bar=True, logger=True, on_step=True, on_epoch=True) + self.log_dict(log_dict_disc, prog_bar=False, logger=True, on_step=True, on_epoch=False) + return discloss + + def validation_step(self, batch, batch_idx): + log_dict = self._validation_step(batch, batch_idx) + with self.ema_scope(): + log_dict_ema = self._validation_step(batch, batch_idx, postfix="_ema") + return log_dict + + def _validation_step(self, batch, batch_idx, postfix=""): + inputs = self.get_input(batch, self.image_key) + reconstructions, posterior = self(inputs) + aeloss, log_dict_ae = self.loss(inputs, reconstructions, posterior, 0, self.global_step, + last_layer=self.get_last_layer(), split="val"+postfix) + + discloss, log_dict_disc = self.loss(inputs, reconstructions, posterior, 1, self.global_step, + last_layer=self.get_last_layer(), split="val"+postfix) + + self.log(f"val{postfix}/rec_loss", log_dict_ae[f"val{postfix}/rec_loss"]) + self.log_dict(log_dict_ae) + self.log_dict(log_dict_disc) + return self.log_dict + + def configure_optimizers(self): + lr = self.learning_rate + ae_params_list = list(self.encoder.parameters()) + list(self.decoder.parameters()) + list( + self.quant_conv.parameters()) + list(self.post_quant_conv.parameters()) + if self.learn_logvar: + print(f"{self.__class__.__name__}: Learning logvar") + ae_params_list.append(self.loss.logvar) + opt_ae = torch.optim.Adam(ae_params_list, + lr=lr, betas=(0.5, 0.9)) + opt_disc = torch.optim.Adam(self.loss.discriminator.parameters(), + lr=lr, betas=(0.5, 0.9)) + return [opt_ae, opt_disc], [] + + def get_last_layer(self): + return self.decoder.conv_out.weight + + @torch.no_grad() + def log_images(self, batch, only_inputs=False, log_ema=False, **kwargs): + log = dict() + x = self.get_input(batch, self.image_key) + x = x.to(self.device) + if not only_inputs: + xrec, posterior = self(x) + if x.shape[1] > 3: + # colorize with random projection + assert xrec.shape[1] > 3 + x = self.to_rgb(x) + xrec = self.to_rgb(xrec) + log["samples"] = self.decode(torch.randn_like(posterior.sample())) + log["reconstructions"] = xrec + if log_ema or self.use_ema: + with self.ema_scope(): + xrec_ema, posterior_ema = self(x) + if x.shape[1] > 3: + # colorize with random projection + assert xrec_ema.shape[1] > 3 + xrec_ema = self.to_rgb(xrec_ema) + log["samples_ema"] = self.decode(torch.randn_like(posterior_ema.sample())) + log["reconstructions_ema"] = xrec_ema + log["inputs"] = x + return log + + def to_rgb(self, x): + assert self.image_key == "segmentation" + if not hasattr(self, "colorize"): + self.register_buffer("colorize", torch.randn(3, x.shape[1], 1, 1).to(x)) + x = F.conv2d(x, weight=self.colorize) + x = 2.*(x-x.min())/(x.max()-x.min()) - 1. + return x + + +class IdentityFirstStage(torch.nn.Module): + def __init__(self, *args, vq_interface=False, **kwargs): + self.vq_interface = vq_interface + super().__init__() + + def encode(self, x, *args, **kwargs): + return x + + def decode(self, x, *args, **kwargs): + return x + + def quantize(self, x, *args, **kwargs): + if self.vq_interface: + return x, None, [None, None, None] + return x + + def forward(self, x, *args, **kwargs): + return x + diff --git a/ldm/models/diffusion/__init__.py b/ldm/models/diffusion/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/ldm/models/diffusion/ddim.py b/ldm/models/diffusion/ddim.py new file mode 100644 index 0000000000000000000000000000000000000000..c6cfd5712281a72c086e592ed57fc0730c5a5a3b --- /dev/null +++ b/ldm/models/diffusion/ddim.py @@ -0,0 +1,337 @@ +"""SAMPLING ONLY.""" + +import torch +import numpy as np +from tqdm import tqdm + +from ldm.modules.diffusionmodules.util import make_ddim_sampling_parameters, make_ddim_timesteps, noise_like, extract_into_tensor + + +class DDIMSampler(object): + def __init__(self, model, schedule="linear", device=torch.device("cuda"), **kwargs): + super().__init__() + self.model = model + self.ddpm_num_timesteps = model.num_timesteps + self.schedule = schedule + self.device = device + + def register_buffer(self, name, attr): + if type(attr) == torch.Tensor: + if attr.device != self.device: + attr = attr.to(self.device) + setattr(self, name, attr) + + def make_schedule(self, ddim_num_steps, ddim_discretize="uniform", ddim_eta=0., verbose=True): + self.ddim_timesteps = make_ddim_timesteps(ddim_discr_method=ddim_discretize, num_ddim_timesteps=ddim_num_steps, + num_ddpm_timesteps=self.ddpm_num_timesteps,verbose=verbose) + alphas_cumprod = self.model.alphas_cumprod + assert alphas_cumprod.shape[0] == self.ddpm_num_timesteps, 'alphas have to be defined for each timestep' + to_torch = lambda x: x.clone().detach().to(torch.float32).to(self.model.device) + + self.register_buffer('betas', to_torch(self.model.betas)) + self.register_buffer('alphas_cumprod', to_torch(alphas_cumprod)) + self.register_buffer('alphas_cumprod_prev', to_torch(self.model.alphas_cumprod_prev)) + + # calculations for diffusion q(x_t | x_{t-1}) and others + self.register_buffer('sqrt_alphas_cumprod', to_torch(np.sqrt(alphas_cumprod.cpu()))) + self.register_buffer('sqrt_one_minus_alphas_cumprod', to_torch(np.sqrt(1. - alphas_cumprod.cpu()))) + self.register_buffer('log_one_minus_alphas_cumprod', to_torch(np.log(1. - alphas_cumprod.cpu()))) + self.register_buffer('sqrt_recip_alphas_cumprod', to_torch(np.sqrt(1. / alphas_cumprod.cpu()))) + self.register_buffer('sqrt_recipm1_alphas_cumprod', to_torch(np.sqrt(1. / alphas_cumprod.cpu() - 1))) + + # ddim sampling parameters + ddim_sigmas, ddim_alphas, ddim_alphas_prev = make_ddim_sampling_parameters(alphacums=alphas_cumprod.cpu(), + ddim_timesteps=self.ddim_timesteps, + eta=ddim_eta,verbose=verbose) + self.register_buffer('ddim_sigmas', ddim_sigmas) + self.register_buffer('ddim_alphas', ddim_alphas) + self.register_buffer('ddim_alphas_prev', ddim_alphas_prev) + self.register_buffer('ddim_sqrt_one_minus_alphas', np.sqrt(1. - ddim_alphas)) + sigmas_for_original_sampling_steps = ddim_eta * torch.sqrt( + (1 - self.alphas_cumprod_prev) / (1 - self.alphas_cumprod) * ( + 1 - self.alphas_cumprod / self.alphas_cumprod_prev)) + self.register_buffer('ddim_sigmas_for_original_num_steps', sigmas_for_original_sampling_steps) + + @torch.no_grad() + def sample(self, + S, + batch_size, + shape, + conditioning=None, + callback=None, + normals_sequence=None, + img_callback=None, + quantize_x0=False, + eta=0., + mask=None, + x0=None, + temperature=1., + noise_dropout=0., + score_corrector=None, + corrector_kwargs=None, + verbose=True, + x_T=None, + log_every_t=100, + unconditional_guidance_scale=1., + unconditional_conditioning=None, # this has to come in the same format as the conditioning, # e.g. as encoded tokens, ... + dynamic_threshold=None, + ucg_schedule=None, + **kwargs + ): + if conditioning is not None: + if isinstance(conditioning, dict): + ctmp = conditioning[list(conditioning.keys())[0]] + while isinstance(ctmp, list): ctmp = ctmp[0] + cbs = ctmp.shape[0] + if cbs != batch_size: + print(f"Warning: Got {cbs} conditionings but batch-size is {batch_size}") + + elif isinstance(conditioning, list): + for ctmp in conditioning: + if ctmp.shape[0] != batch_size: + print(f"Warning: Got {cbs} conditionings but batch-size is {batch_size}") + + else: + if conditioning.shape[0] != batch_size: + print(f"Warning: Got {conditioning.shape[0]} conditionings but batch-size is {batch_size}") + + self.make_schedule(ddim_num_steps=S, ddim_eta=eta, verbose=verbose) + # sampling + C, H, W = shape + size = (batch_size, C, H, W) + print(f'Data shape for DDIM sampling is {size}, eta {eta}') + + samples, intermediates = self.ddim_sampling(conditioning, size, + callback=callback, + img_callback=img_callback, + quantize_denoised=quantize_x0, + mask=mask, x0=x0, + ddim_use_original_steps=False, + noise_dropout=noise_dropout, + temperature=temperature, + score_corrector=score_corrector, + corrector_kwargs=corrector_kwargs, + x_T=x_T, + log_every_t=log_every_t, + unconditional_guidance_scale=unconditional_guidance_scale, + unconditional_conditioning=unconditional_conditioning, + dynamic_threshold=dynamic_threshold, + ucg_schedule=ucg_schedule + ) + return samples, intermediates + + @torch.no_grad() + def ddim_sampling(self, cond, shape, + x_T=None, ddim_use_original_steps=False, + callback=None, timesteps=None, quantize_denoised=False, + mask=None, x0=None, img_callback=None, log_every_t=100, + temperature=1., noise_dropout=0., score_corrector=None, corrector_kwargs=None, + unconditional_guidance_scale=1., unconditional_conditioning=None, dynamic_threshold=None, + ucg_schedule=None): + device = self.model.betas.device + b = shape[0] + if x_T is None: + img = torch.randn(shape, device=device) + else: + img = x_T + + if timesteps is None: + timesteps = self.ddpm_num_timesteps if ddim_use_original_steps else self.ddim_timesteps + elif timesteps is not None and not ddim_use_original_steps: + subset_end = int(min(timesteps / self.ddim_timesteps.shape[0], 1) * self.ddim_timesteps.shape[0]) - 1 + timesteps = self.ddim_timesteps[:subset_end] + + intermediates = {'x_inter': [img], 'pred_x0': [img]} + time_range = reversed(range(0,timesteps)) if ddim_use_original_steps else np.flip(timesteps) + total_steps = timesteps if ddim_use_original_steps else timesteps.shape[0] + print(f"Running DDIM Sampling with {total_steps} timesteps") + + iterator = tqdm(time_range, desc='DDIM Sampler', total=total_steps) + + for i, step in enumerate(iterator): + index = total_steps - i - 1 + ts = torch.full((b,), step, device=device, dtype=torch.long) + + if mask is not None: + assert x0 is not None + img_orig = self.model.q_sample(x0, ts) # TODO: deterministic forward pass? + img = img_orig * mask + (1. - mask) * img + + if ucg_schedule is not None: + assert len(ucg_schedule) == len(time_range) + unconditional_guidance_scale = ucg_schedule[i] + + outs = self.p_sample_ddim(img, cond, ts, index=index, use_original_steps=ddim_use_original_steps, + quantize_denoised=quantize_denoised, temperature=temperature, + noise_dropout=noise_dropout, score_corrector=score_corrector, + corrector_kwargs=corrector_kwargs, + unconditional_guidance_scale=unconditional_guidance_scale, + unconditional_conditioning=unconditional_conditioning, + dynamic_threshold=dynamic_threshold) + img, pred_x0 = outs + if callback: callback(i) + if img_callback: img_callback(pred_x0, i) + + if index % log_every_t == 0 or index == total_steps - 1: + intermediates['x_inter'].append(img) + intermediates['pred_x0'].append(pred_x0) + + return img, intermediates + + @torch.no_grad() + def p_sample_ddim(self, x, c, t, index, repeat_noise=False, use_original_steps=False, quantize_denoised=False, + temperature=1., noise_dropout=0., score_corrector=None, corrector_kwargs=None, + unconditional_guidance_scale=1., unconditional_conditioning=None, + dynamic_threshold=None): + b, *_, device = *x.shape, x.device + + if unconditional_conditioning is None or unconditional_guidance_scale == 1.: + model_output = self.model.apply_model(x, t, c) + else: + x_in = torch.cat([x] * 2) + t_in = torch.cat([t] * 2) + if isinstance(c, dict): + assert isinstance(unconditional_conditioning, dict) + c_in = dict() + for k in c: + if isinstance(c[k], list): + c_in[k] = [torch.cat([ + unconditional_conditioning[k][i], + c[k][i]]) for i in range(len(c[k]))] + else: + c_in[k] = torch.cat([ + unconditional_conditioning[k], + c[k]]) + elif isinstance(c, list): + c_in = list() + assert isinstance(unconditional_conditioning, list) + for i in range(len(c)): + c_in.append(torch.cat([unconditional_conditioning[i], c[i]])) + else: + c_in = torch.cat([unconditional_conditioning, c]) + model_uncond, model_t = self.model.apply_model(x_in, t_in, c_in).chunk(2) + model_output = model_uncond + unconditional_guidance_scale * (model_t - model_uncond) + + if self.model.parameterization == "v": + e_t = self.model.predict_eps_from_z_and_v(x, t, model_output) + else: + e_t = model_output + + if score_corrector is not None: + assert self.model.parameterization == "eps", 'not implemented' + e_t = score_corrector.modify_score(self.model, e_t, x, t, c, **corrector_kwargs) + + alphas = self.model.alphas_cumprod if use_original_steps else self.ddim_alphas + alphas_prev = self.model.alphas_cumprod_prev if use_original_steps else self.ddim_alphas_prev + sqrt_one_minus_alphas = self.model.sqrt_one_minus_alphas_cumprod if use_original_steps else self.ddim_sqrt_one_minus_alphas + sigmas = self.model.ddim_sigmas_for_original_num_steps if use_original_steps else self.ddim_sigmas + # select parameters corresponding to the currently considered timestep + a_t = torch.full((b, 1, 1, 1), alphas[index], device=device) + a_prev = torch.full((b, 1, 1, 1), alphas_prev[index], device=device) + sigma_t = torch.full((b, 1, 1, 1), sigmas[index], device=device) + sqrt_one_minus_at = torch.full((b, 1, 1, 1), sqrt_one_minus_alphas[index],device=device) + + # current prediction for x_0 + if self.model.parameterization != "v": + pred_x0 = (x - sqrt_one_minus_at * e_t) / a_t.sqrt() + else: + pred_x0 = self.model.predict_start_from_z_and_v(x, t, model_output) + + if quantize_denoised: + pred_x0, _, *_ = self.model.first_stage_model.quantize(pred_x0) + + if dynamic_threshold is not None: + raise NotImplementedError() + + # direction pointing to x_t + dir_xt = (1. - a_prev - sigma_t**2).sqrt() * e_t + noise = sigma_t * noise_like(x.shape, device, repeat_noise) * temperature + if noise_dropout > 0.: + noise = torch.nn.functional.dropout(noise, p=noise_dropout) + x_prev = a_prev.sqrt() * pred_x0 + dir_xt + noise + return x_prev, pred_x0 + + @torch.no_grad() + def encode(self, x0, c, t_enc, use_original_steps=False, return_intermediates=None, + unconditional_guidance_scale=1.0, unconditional_conditioning=None, callback=None): + num_reference_steps = self.ddpm_num_timesteps if use_original_steps else self.ddim_timesteps.shape[0] + + assert t_enc <= num_reference_steps + num_steps = t_enc + + if use_original_steps: + alphas_next = self.alphas_cumprod[:num_steps] + alphas = self.alphas_cumprod_prev[:num_steps] + else: + alphas_next = self.ddim_alphas[:num_steps] + alphas = torch.tensor(self.ddim_alphas_prev[:num_steps]) + + x_next = x0 + intermediates = [] + inter_steps = [] + for i in tqdm(range(num_steps), desc='Encoding Image'): + t = torch.full((x0.shape[0],), i, device=self.model.device, dtype=torch.long) + if unconditional_guidance_scale == 1.: + noise_pred = self.model.apply_model(x_next, t, c) + else: + assert unconditional_conditioning is not None + e_t_uncond, noise_pred = torch.chunk( + self.model.apply_model(torch.cat((x_next, x_next)), torch.cat((t, t)), + torch.cat((unconditional_conditioning, c))), 2) + noise_pred = e_t_uncond + unconditional_guidance_scale * (noise_pred - e_t_uncond) + + xt_weighted = (alphas_next[i] / alphas[i]).sqrt() * x_next + weighted_noise_pred = alphas_next[i].sqrt() * ( + (1 / alphas_next[i] - 1).sqrt() - (1 / alphas[i] - 1).sqrt()) * noise_pred + x_next = xt_weighted + weighted_noise_pred + if return_intermediates and i % ( + num_steps // return_intermediates) == 0 and i < num_steps - 1: + intermediates.append(x_next) + inter_steps.append(i) + elif return_intermediates and i >= num_steps - 2: + intermediates.append(x_next) + inter_steps.append(i) + if callback: callback(i) + + out = {'x_encoded': x_next, 'intermediate_steps': inter_steps} + if return_intermediates: + out.update({'intermediates': intermediates}) + return x_next, out + + @torch.no_grad() + def stochastic_encode(self, x0, t, use_original_steps=False, noise=None): + # fast, but does not allow for exact reconstruction + # t serves as an index to gather the correct alphas + if use_original_steps: + sqrt_alphas_cumprod = self.sqrt_alphas_cumprod + sqrt_one_minus_alphas_cumprod = self.sqrt_one_minus_alphas_cumprod + else: + sqrt_alphas_cumprod = torch.sqrt(self.ddim_alphas) + sqrt_one_minus_alphas_cumprod = self.ddim_sqrt_one_minus_alphas + + if noise is None: + noise = torch.randn_like(x0) + return (extract_into_tensor(sqrt_alphas_cumprod, t, x0.shape) * x0 + + extract_into_tensor(sqrt_one_minus_alphas_cumprod, t, x0.shape) * noise) + + @torch.no_grad() + def decode(self, x_latent, cond, t_start, unconditional_guidance_scale=1.0, unconditional_conditioning=None, + use_original_steps=False, callback=None): + + timesteps = np.arange(self.ddpm_num_timesteps) if use_original_steps else self.ddim_timesteps + timesteps = timesteps[:t_start] + + time_range = np.flip(timesteps) + total_steps = timesteps.shape[0] + print(f"Running DDIM Sampling with {total_steps} timesteps") + + iterator = tqdm(time_range, desc='Decoding image', total=total_steps) + x_dec = x_latent + for i, step in enumerate(iterator): + index = total_steps - i - 1 + ts = torch.full((x_latent.shape[0],), step, device=x_latent.device, dtype=torch.long) + x_dec, _ = self.p_sample_ddim(x_dec, cond, ts, index=index, use_original_steps=use_original_steps, + unconditional_guidance_scale=unconditional_guidance_scale, + unconditional_conditioning=unconditional_conditioning) + if callback: callback(i) + return x_dec \ No newline at end of file diff --git a/ldm/models/diffusion/ddpm.py b/ldm/models/diffusion/ddpm.py new file mode 100644 index 0000000000000000000000000000000000000000..289a50c7569418e75fbf9184d819d3422fef8597 --- /dev/null +++ b/ldm/models/diffusion/ddpm.py @@ -0,0 +1,1884 @@ +""" +wild mixture of +https://github.com/lucidrains/denoising-diffusion-pytorch/blob/7706bdfc6f527f58d33f84b7b522e61e6e3164b3/denoising_diffusion_pytorch/denoising_diffusion_pytorch.py +https://github.com/openai/improved-diffusion/blob/e94489283bb876ac1477d5dd7709bbbd2d9902ce/improved_diffusion/gaussian_diffusion.py +https://github.com/CompVis/taming-transformers +-- merci +""" + +import torch +import torch.nn as nn +import numpy as np +import pytorch_lightning as pl +from torch.optim.lr_scheduler import LambdaLR +from einops import rearrange, repeat +from contextlib import contextmanager, nullcontext +from functools import partial +import itertools +from tqdm import tqdm +from torchvision.utils import make_grid +from pytorch_lightning.utilities.distributed import rank_zero_only +from omegaconf import ListConfig + +from ldm.util import log_txt_as_img, exists, default, ismap, isimage, mean_flat, count_params, instantiate_from_config +from ldm.modules.ema import LitEma +from ldm.modules.distributions.distributions import normal_kl, DiagonalGaussianDistribution +from ldm.models.autoencoder import IdentityFirstStage, AutoencoderKL +from ldm.modules.diffusionmodules.util import make_beta_schedule, extract_into_tensor, noise_like +from ldm.models.diffusion.ddim import DDIMSampler + + +__conditioning_keys__ = {'concat': 'c_concat', + 'crossattn': 'c_crossattn', + 'adm': 'y'} + + +def disabled_train(self, mode=True): + """Overwrite model.train with this function to make sure train/eval mode + does not change anymore.""" + return self + + +def uniform_on_device(r1, r2, shape, device): + return (r1 - r2) * torch.rand(*shape, device=device) + r2 + +''' + class tree: + LatentDiffusion (son of DDPM) + self.model: DiffusionWrapper (defined in DDPM) + self.diffusion_model: UNet + self.first_stage_model: AutoencoderKL + self.cond_stage_model: FrozenOpenCLIP +''' + + +class DDPM(pl.LightningModule): + # classic DDPM with Gaussian diffusion, in image space + def __init__(self, + unet_config, + timesteps=1000, + beta_schedule="linear", + loss_type="l2", + ckpt_path=None, + ignore_keys=[], + load_only_unet=False, + monitor="val/loss", + use_ema=True, + first_stage_key="image", + image_size=256, + channels=3, + log_every_t=100, + clip_denoised=True, + linear_start=1e-4, + linear_end=2e-2, + cosine_s=8e-3, + given_betas=None, + original_elbo_weight=0., + v_posterior=0., # weight for choosing posterior variance as sigma = (1-v) * beta_tilde + v * beta + l_simple_weight=1., + conditioning_key=None, + parameterization="eps", # all assuming fixed variance schedules + scheduler_config=None, + use_positional_encodings=False, + learn_logvar=False, + logvar_init=0., + make_it_fit=False, + ucg_training=None, + reset_ema=False, + reset_num_ema_updates=False, + ): + super().__init__() + assert parameterization in ["eps", "x0", "v"], 'currently only supporting "eps" and "x0" and "v"' + self.parameterization = parameterization + print(f"{self.__class__.__name__}: Running in {self.parameterization}-prediction mode") + self.cond_stage_model = None + self.clip_denoised = clip_denoised + self.log_every_t = log_every_t + self.first_stage_key = first_stage_key + self.image_size = image_size # try conv? + self.channels = channels + self.use_positional_encodings = use_positional_encodings + self.model = DiffusionWrapper(unet_config, conditioning_key) + count_params(self.model, verbose=True) + self.use_ema = use_ema + if self.use_ema: + self.model_ema = LitEma(self.model) + print(f"Keeping EMAs of {len(list(self.model_ema.buffers()))}.") + + self.use_scheduler = scheduler_config is not None + if self.use_scheduler: + self.scheduler_config = scheduler_config + + self.v_posterior = v_posterior + self.original_elbo_weight = original_elbo_weight + self.l_simple_weight = l_simple_weight + + if monitor is not None: + self.monitor = monitor + self.make_it_fit = make_it_fit + if reset_ema: assert exists(ckpt_path) + if ckpt_path is not None: + self.init_from_ckpt(ckpt_path, ignore_keys=ignore_keys, only_model=load_only_unet) + if reset_ema: + assert self.use_ema + print(f"Resetting ema to pure model weights. This is useful when restoring from an ema-only checkpoint.") + self.model_ema = LitEma(self.model) + if reset_num_ema_updates: + print(" +++++++++++ WARNING: RESETTING NUM_EMA UPDATES TO ZERO +++++++++++ ") + assert self.use_ema + self.model_ema.reset_num_updates() + + self.register_schedule(given_betas=given_betas, beta_schedule=beta_schedule, timesteps=timesteps, + linear_start=linear_start, linear_end=linear_end, cosine_s=cosine_s) + + self.loss_type = loss_type + + self.learn_logvar = learn_logvar + self.logvar = torch.full(fill_value=logvar_init, size=(self.num_timesteps,)) + if self.learn_logvar: + self.logvar = nn.Parameter(self.logvar, requires_grad=True) + + self.ucg_training = ucg_training or dict() + if self.ucg_training: + self.ucg_prng = np.random.RandomState() + + def register_schedule(self, given_betas=None, beta_schedule="linear", timesteps=1000, + linear_start=1e-4, linear_end=2e-2, cosine_s=8e-3): + if exists(given_betas): + betas = given_betas + else: + betas = make_beta_schedule(beta_schedule, timesteps, linear_start=linear_start, linear_end=linear_end, + cosine_s=cosine_s) + alphas = 1. - betas + alphas_cumprod = np.cumprod(alphas, axis=0) + alphas_cumprod_prev = np.append(1., alphas_cumprod[:-1]) + + timesteps, = betas.shape + self.num_timesteps = int(timesteps) + self.linear_start = linear_start + self.linear_end = linear_end + assert alphas_cumprod.shape[0] == self.num_timesteps, 'alphas have to be defined for each timestep' + + to_torch = partial(torch.tensor, dtype=torch.float32) + + self.register_buffer('betas', to_torch(betas)) + self.register_buffer('alphas_cumprod', to_torch(alphas_cumprod)) + self.register_buffer('alphas_cumprod_prev', to_torch(alphas_cumprod_prev)) + + # calculations for diffusion q(x_t | x_{t-1}) and others + self.register_buffer('sqrt_alphas_cumprod', to_torch(np.sqrt(alphas_cumprod))) + self.register_buffer('sqrt_one_minus_alphas_cumprod', to_torch(np.sqrt(1. - alphas_cumprod))) + self.register_buffer('log_one_minus_alphas_cumprod', to_torch(np.log(1. - alphas_cumprod))) + self.register_buffer('sqrt_recip_alphas_cumprod', to_torch(np.sqrt(1. / alphas_cumprod))) + self.register_buffer('sqrt_recipm1_alphas_cumprod', to_torch(np.sqrt(1. / alphas_cumprod - 1))) + + # calculations for posterior q(x_{t-1} | x_t, x_0) + posterior_variance = (1 - self.v_posterior) * betas * (1. - alphas_cumprod_prev) / ( + 1. - alphas_cumprod) + self.v_posterior * betas + # above: equal to 1. / (1. / (1. - alpha_cumprod_tm1) + alpha_t / beta_t) + self.register_buffer('posterior_variance', to_torch(posterior_variance)) + # below: log calculation clipped because the posterior variance is 0 at the beginning of the diffusion chain + self.register_buffer('posterior_log_variance_clipped', to_torch(np.log(np.maximum(posterior_variance, 1e-20)))) + self.register_buffer('posterior_mean_coef1', to_torch( + betas * np.sqrt(alphas_cumprod_prev) / (1. - alphas_cumprod))) + self.register_buffer('posterior_mean_coef2', to_torch( + (1. - alphas_cumprod_prev) * np.sqrt(alphas) / (1. - alphas_cumprod))) + + if self.parameterization == "eps": + lvlb_weights = self.betas ** 2 / ( + 2 * self.posterior_variance * to_torch(alphas) * (1 - self.alphas_cumprod)) + elif self.parameterization == "x0": + lvlb_weights = 0.5 * np.sqrt(torch.Tensor(alphas_cumprod)) / (2. * 1 - torch.Tensor(alphas_cumprod)) + elif self.parameterization == "v": + lvlb_weights = torch.ones_like(self.betas ** 2 / ( + 2 * self.posterior_variance * to_torch(alphas) * (1 - self.alphas_cumprod))) + else: + raise NotImplementedError("mu not supported") + lvlb_weights[0] = lvlb_weights[1] + self.register_buffer('lvlb_weights', lvlb_weights, persistent=False) + assert not torch.isnan(self.lvlb_weights).all() + + @contextmanager + def ema_scope(self, context=None): + if self.use_ema: + self.model_ema.store(self.model.parameters()) + self.model_ema.copy_to(self.model) + if context is not None: + print(f"{context}: Switched to EMA weights") + try: + yield None + finally: + if self.use_ema: + self.model_ema.restore(self.model.parameters()) + if context is not None: + print(f"{context}: Restored training weights") + + @torch.no_grad() + def init_from_ckpt(self, path, ignore_keys=list(), only_model=False): + sd = torch.load(path, map_location="cpu") + if "state_dict" in list(sd.keys()): + sd = sd["state_dict"] + keys = list(sd.keys()) + for k in keys: + for ik in ignore_keys: + if k.startswith(ik): + print("Deleting key {} from state_dict.".format(k)) + del sd[k] + if self.make_it_fit: + n_params = len([name for name, _ in + itertools.chain(self.named_parameters(), + self.named_buffers())]) + for name, param in tqdm( + itertools.chain(self.named_parameters(), + self.named_buffers()), + desc="Fitting old weights to new weights", + total=n_params + ): + if not name in sd: + continue + old_shape = sd[name].shape + new_shape = param.shape + assert len(old_shape) == len(new_shape) + if len(new_shape) > 2: + # we only modify first two axes + assert new_shape[2:] == old_shape[2:] + # assumes first axis corresponds to output dim + if not new_shape == old_shape: + new_param = param.clone() + old_param = sd[name] + if len(new_shape) == 1: + for i in range(new_param.shape[0]): + new_param[i] = old_param[i % old_shape[0]] + elif len(new_shape) >= 2: + for i in range(new_param.shape[0]): + for j in range(new_param.shape[1]): + new_param[i, j] = old_param[i % old_shape[0], j % old_shape[1]] + + n_used_old = torch.ones(old_shape[1]) + for j in range(new_param.shape[1]): + n_used_old[j % old_shape[1]] += 1 + n_used_new = torch.zeros(new_shape[1]) + for j in range(new_param.shape[1]): + n_used_new[j] = n_used_old[j % old_shape[1]] + + n_used_new = n_used_new[None, :] + while len(n_used_new.shape) < len(new_shape): + n_used_new = n_used_new.unsqueeze(-1) + new_param /= n_used_new + + sd[name] = new_param + + missing, unexpected = self.load_state_dict(sd, strict=False) if not only_model else self.model.load_state_dict( + sd, strict=False) + print(f"Restored from {path} with {len(missing)} missing and {len(unexpected)} unexpected keys") + if len(missing) > 0: + print(f"Missing Keys:\n {missing}") + if len(unexpected) > 0: + print(f"\nUnexpected Keys:\n {unexpected}") + + def q_mean_variance(self, x_start, t): + """ + Get the distribution q(x_t | x_0). + :param x_start: the [N x C x ...] tensor of noiseless inputs. + :param t: the number of diffusion steps (minus 1). Here, 0 means one step. + :return: A tuple (mean, variance, log_variance), all of x_start's shape. + """ + mean = (extract_into_tensor(self.sqrt_alphas_cumprod, t, x_start.shape) * x_start) + variance = extract_into_tensor(1.0 - self.alphas_cumprod, t, x_start.shape) + log_variance = extract_into_tensor(self.log_one_minus_alphas_cumprod, t, x_start.shape) + return mean, variance, log_variance + + def predict_start_from_noise(self, x_t, t, noise): + return ( + extract_into_tensor(self.sqrt_recip_alphas_cumprod, t, x_t.shape) * x_t - + extract_into_tensor(self.sqrt_recipm1_alphas_cumprod, t, x_t.shape) * noise + ) + + def predict_start_from_z_and_v(self, x_t, t, v): + # self.register_buffer('sqrt_alphas_cumprod', to_torch(np.sqrt(alphas_cumprod))) + # self.register_buffer('sqrt_one_minus_alphas_cumprod', to_torch(np.sqrt(1. - alphas_cumprod))) + return ( + extract_into_tensor(self.sqrt_alphas_cumprod, t, x_t.shape) * x_t - + extract_into_tensor(self.sqrt_one_minus_alphas_cumprod, t, x_t.shape) * v + ) + + def predict_eps_from_z_and_v(self, x_t, t, v): + return ( + extract_into_tensor(self.sqrt_alphas_cumprod, t, x_t.shape) * v + + extract_into_tensor(self.sqrt_one_minus_alphas_cumprod, t, x_t.shape) * x_t + ) + + def q_posterior(self, x_start, x_t, t): + posterior_mean = ( + extract_into_tensor(self.posterior_mean_coef1, t, x_t.shape) * x_start + + extract_into_tensor(self.posterior_mean_coef2, t, x_t.shape) * x_t + ) + posterior_variance = extract_into_tensor(self.posterior_variance, t, x_t.shape) + posterior_log_variance_clipped = extract_into_tensor(self.posterior_log_variance_clipped, t, x_t.shape) + return posterior_mean, posterior_variance, posterior_log_variance_clipped + + def p_mean_variance(self, x, t, clip_denoised: bool): + model_out = self.model(x, t) + if self.parameterization == "eps": + x_recon = self.predict_start_from_noise(x, t=t, noise=model_out) + elif self.parameterization == "x0": + x_recon = model_out + if clip_denoised: + x_recon.clamp_(-1., 1.) + + model_mean, posterior_variance, posterior_log_variance = self.q_posterior(x_start=x_recon, x_t=x, t=t) + return model_mean, posterior_variance, posterior_log_variance + + @torch.no_grad() + def p_sample(self, x, t, clip_denoised=True, repeat_noise=False): + b, *_, device = *x.shape, x.device + model_mean, _, model_log_variance = self.p_mean_variance(x=x, t=t, clip_denoised=clip_denoised) + noise = noise_like(x.shape, device, repeat_noise) + # no noise when t == 0 + nonzero_mask = (1 - (t == 0).float()).reshape(b, *((1,) * (len(x.shape) - 1))) + return model_mean + nonzero_mask * (0.5 * model_log_variance).exp() * noise + + @torch.no_grad() + def p_sample_loop(self, shape, return_intermediates=False): + device = self.betas.device + b = shape[0] + img = torch.randn(shape, device=device) + intermediates = [img] + for i in tqdm(reversed(range(0, self.num_timesteps)), desc='Sampling t', total=self.num_timesteps): + img = self.p_sample(img, torch.full((b,), i, device=device, dtype=torch.long), + clip_denoised=self.clip_denoised) + if i % self.log_every_t == 0 or i == self.num_timesteps - 1: + intermediates.append(img) + if return_intermediates: + return img, intermediates + return img + + @torch.no_grad() + def sample(self, batch_size=16, return_intermediates=False): + image_size = self.image_size + channels = self.channels + return self.p_sample_loop((batch_size, channels, image_size, image_size), + return_intermediates=return_intermediates) + + def q_sample(self, x_start, t, noise=None): + noise = default(noise, lambda: torch.randn_like(x_start)) + return (extract_into_tensor(self.sqrt_alphas_cumprod, t, x_start.shape) * x_start + + extract_into_tensor(self.sqrt_one_minus_alphas_cumprod, t, x_start.shape) * noise) + + def get_v(self, x, noise, t): + return ( + extract_into_tensor(self.sqrt_alphas_cumprod, t, x.shape) * noise - + extract_into_tensor(self.sqrt_one_minus_alphas_cumprod, t, x.shape) * x + ) + + def get_loss(self, pred, target, mean=True): + if self.loss_type == 'l1': + loss = (target - pred).abs() + if mean: + loss = loss.mean() + elif self.loss_type == 'l2': + if mean: + loss = torch.nn.functional.mse_loss(target, pred) + else: + loss = torch.nn.functional.mse_loss(target, pred, reduction='none') + else: + raise NotImplementedError("unknown loss type '{loss_type}'") + + return loss + + def p_losses(self, x_start, t, noise=None): + noise = default(noise, lambda: torch.randn_like(x_start)) + x_noisy = self.q_sample(x_start=x_start, t=t, noise=noise) + model_out = self.model(x_noisy, t) + + loss_dict = {} + if self.parameterization == "eps": + target = noise + elif self.parameterization == "x0": + target = x_start + elif self.parameterization == "v": + target = self.get_v(x_start, noise, t) + else: + raise NotImplementedError(f"Parameterization {self.parameterization} not yet supported") + + loss = self.get_loss(model_out, target, mean=False).mean(dim=[1, 2, 3]) + + log_prefix = 'train' if self.training else 'val' + + loss_dict.update({f'{log_prefix}/loss_simple': loss.mean()}) + loss_simple = loss.mean() * self.l_simple_weight + + loss_vlb = (self.lvlb_weights[t] * loss).mean() + loss_dict.update({f'{log_prefix}/loss_vlb': loss_vlb}) + + loss = loss_simple + self.original_elbo_weight * loss_vlb + + loss_dict.update({f'{log_prefix}/loss': loss}) + + return loss, loss_dict + + def forward(self, x, *args, **kwargs): + # b, c, h, w, device, img_size, = *x.shape, x.device, self.image_size + # assert h == img_size and w == img_size, f'height and width of image must be {img_size}' + t = torch.randint(0, self.num_timesteps, (x.shape[0],), device=self.device).long() + return self.p_losses(x, t, *args, **kwargs) + + def get_input(self, batch, k): + x = batch[k] + if len(x.shape) == 3: + x = x[..., None] + x = rearrange(x, 'b h w c -> b c h w') + x = x.to(memory_format=torch.contiguous_format).float() + return x + + def shared_step(self, batch): + x = self.get_input(batch, self.first_stage_key) + loss, loss_dict = self(x) + return loss, loss_dict + + def training_step(self, batch, batch_idx): + for k in self.ucg_training: + p = self.ucg_training[k]["p"] + val = self.ucg_training[k]["val"] + if val is None: + val = "" + for i in range(len(batch[k])): + if self.ucg_prng.choice(2, p=[1 - p, p]): + batch[k][i] = val + + loss, loss_dict = self.shared_step(batch) + + self.log_dict(loss_dict, prog_bar=True, + logger=True, on_step=True, on_epoch=True) + + self.log("global_step", self.global_step, + prog_bar=True, logger=True, on_step=True, on_epoch=False) + + if self.use_scheduler: + lr = self.optimizers().param_groups[0]['lr'] + self.log('lr_abs', lr, prog_bar=True, logger=True, on_step=True, on_epoch=False) + + return loss + + @torch.no_grad() + def validation_step(self, batch, batch_idx): + _, loss_dict_no_ema = self.shared_step(batch) + with self.ema_scope(): + _, loss_dict_ema = self.shared_step(batch) + loss_dict_ema = {key + '_ema': loss_dict_ema[key] for key in loss_dict_ema} + self.log_dict(loss_dict_no_ema, prog_bar=False, logger=True, on_step=False, on_epoch=True) + self.log_dict(loss_dict_ema, prog_bar=False, logger=True, on_step=False, on_epoch=True) + + def on_train_batch_end(self, *args, **kwargs): + if self.use_ema: + self.model_ema(self.model) + + def _get_rows_from_list(self, samples): + n_imgs_per_row = len(samples) + denoise_grid = rearrange(samples, 'n b c h w -> b n c h w') + denoise_grid = rearrange(denoise_grid, 'b n c h w -> (b n) c h w') + denoise_grid = make_grid(denoise_grid, nrow=n_imgs_per_row) + return denoise_grid + + @torch.no_grad() + def log_images(self, batch, N=8, n_row=2, sample=True, return_keys=None, **kwargs): + log = dict() + x = self.get_input(batch, self.first_stage_key) + N = min(x.shape[0], N) + n_row = min(x.shape[0], n_row) + x = x.to(self.device)[:N] + log["inputs"] = x + + # get diffusion row + diffusion_row = list() + x_start = x[:n_row] + + for t in range(self.num_timesteps): + if t % self.log_every_t == 0 or t == self.num_timesteps - 1: + t = repeat(torch.tensor([t]), '1 -> b', b=n_row) + t = t.to(self.device).long() + noise = torch.randn_like(x_start) + x_noisy = self.q_sample(x_start=x_start, t=t, noise=noise) + diffusion_row.append(x_noisy) + + log["diffusion_row"] = self._get_rows_from_list(diffusion_row) + + if sample: + # get denoise row + with self.ema_scope("Plotting"): + samples, denoise_row = self.sample(batch_size=N, return_intermediates=True) + + log["samples"] = samples + log["denoise_row"] = self._get_rows_from_list(denoise_row) + + if return_keys: + if np.intersect1d(list(log.keys()), return_keys).shape[0] == 0: + return log + else: + return {key: log[key] for key in return_keys} + return log + + def configure_optimizers(self): + lr = self.learning_rate + params = list(self.model.parameters()) + if self.learn_logvar: + params = params + [self.logvar] + opt = torch.optim.AdamW(params, lr=lr) + return opt + + +class LatentDiffusion(DDPM): + """main class""" + + def __init__(self, + first_stage_config, + cond_stage_config, + num_timesteps_cond=None, + cond_stage_key="image", + cond_stage_trainable=False, + concat_mode=True, + cond_stage_forward=None, + conditioning_key=None, + scale_factor=1.0, + scale_by_std=False, + force_null_conditioning=False, + *args, **kwargs): + self.force_null_conditioning = force_null_conditioning + self.num_timesteps_cond = default(num_timesteps_cond, 1) + self.scale_by_std = scale_by_std + assert self.num_timesteps_cond <= kwargs['timesteps'] + # for backwards compatibility after implementation of DiffusionWrapper + if conditioning_key is None: + conditioning_key = 'concat' if concat_mode else 'crossattn' + if cond_stage_config == '__is_unconditional__' and not self.force_null_conditioning: + conditioning_key = None + ckpt_path = kwargs.pop("ckpt_path", None) + reset_ema = kwargs.pop("reset_ema", False) + reset_num_ema_updates = kwargs.pop("reset_num_ema_updates", False) + ignore_keys = kwargs.pop("ignore_keys", []) + super().__init__(conditioning_key=conditioning_key, *args, **kwargs) + self.concat_mode = concat_mode + self.cond_stage_trainable = cond_stage_trainable + self.cond_stage_key = cond_stage_key + try: + self.num_downs = len(first_stage_config.params.ddconfig.ch_mult) - 1 + except: + self.num_downs = 0 + if not scale_by_std: + self.scale_factor = scale_factor + else: + self.register_buffer('scale_factor', torch.tensor(scale_factor)) + self.instantiate_first_stage(first_stage_config) # AutoencoderKL + self.instantiate_cond_stage(cond_stage_config) # FrozenOpenCLIPEmbedder + self.cond_stage_forward = cond_stage_forward + self.clip_denoised = False + self.bbox_tokenizer = None + + self.restarted_from_ckpt = False + if ckpt_path is not None: + self.init_from_ckpt(ckpt_path, ignore_keys) + self.restarted_from_ckpt = True + if reset_ema: + assert self.use_ema + print( + f"Resetting ema to pure model weights. This is useful when restoring from an ema-only checkpoint.") + self.model_ema = LitEma(self.model) + if reset_num_ema_updates: + print(" +++++++++++ WARNING: RESETTING NUM_EMA UPDATES TO ZERO +++++++++++ ") + assert self.use_ema + self.model_ema.reset_num_updates() + + def make_cond_schedule(self, ): + self.cond_ids = torch.full(size=(self.num_timesteps,), fill_value=self.num_timesteps - 1, dtype=torch.long) + ids = torch.round(torch.linspace(0, self.num_timesteps - 1, self.num_timesteps_cond)).long() + self.cond_ids[:self.num_timesteps_cond] = ids + + @rank_zero_only + @torch.no_grad() + def on_train_batch_start(self, batch, batch_idx, dataloader_idx): + # only for very first batch + if self.scale_by_std and self.current_epoch == 0 and self.global_step == 0 and batch_idx == 0 and not self.restarted_from_ckpt: + assert self.scale_factor == 1., 'rather not use custom rescaling and std-rescaling simultaneously' + # set rescale weight to 1./std of encodings + print("### USING STD-RESCALING ###") + x = super().get_input(batch, self.first_stage_key) + x = x.to(self.device) + encoder_posterior = self.encode_first_stage(x) + z = self.get_first_stage_encoding(encoder_posterior).detach() + del self.scale_factor + self.register_buffer('scale_factor', 1. / z.flatten().std()) + print(f"setting self.scale_factor to {self.scale_factor}") + print("### USING STD-RESCALING ###") + + def register_schedule(self, + given_betas=None, beta_schedule="linear", timesteps=1000, + linear_start=1e-4, linear_end=2e-2, cosine_s=8e-3): + super().register_schedule(given_betas, beta_schedule, timesteps, linear_start, linear_end, cosine_s) + + self.shorten_cond_schedule = self.num_timesteps_cond > 1 + if self.shorten_cond_schedule: + self.make_cond_schedule() + + def instantiate_first_stage(self, config): + model = instantiate_from_config(config) + self.first_stage_model = model + # self.first_stage_model = model.eval() + # self.first_stage_model.train = disabled_train + for param in self.first_stage_model.parameters(): + param.requires_grad = False + + def instantiate_cond_stage(self, config): + if not self.cond_stage_trainable: + if config == "__is_first_stage__": + print("Using first stage also as cond stage.") + self.cond_stage_model = self.first_stage_model + elif config == "__is_unconditional__": + print(f"Training {self.__class__.__name__} as an unconditional model.") + self.cond_stage_model = None + # self.be_unconditional = True + else: + model = instantiate_from_config(config) + self.cond_stage_model = model + # self.cond_stage_model = model.eval() + # self.cond_stage_model.train = disabled_train + for param in self.cond_stage_model.parameters(): + param.requires_grad = False + else: + assert config != '__is_first_stage__' + assert config != '__is_unconditional__' + model = instantiate_from_config(config) + self.cond_stage_model = model + + def _get_denoise_row_from_list(self, samples, desc='', force_no_decoder_quantization=False): + denoise_row = [] + for zd in tqdm(samples, desc=desc): + denoise_row.append(self.decode_first_stage(zd.to(self.device), + force_not_quantize=force_no_decoder_quantization)) + n_imgs_per_row = len(denoise_row) + denoise_row = torch.stack(denoise_row) # n_log_step, n_row, C, H, W + denoise_grid = rearrange(denoise_row, 'n b c h w -> b n c h w') + denoise_grid = rearrange(denoise_grid, 'b n c h w -> (b n) c h w') + denoise_grid = make_grid(denoise_grid, nrow=n_imgs_per_row) + return denoise_grid + + def get_first_stage_encoding(self, encoder_posterior): + if isinstance(encoder_posterior, DiagonalGaussianDistribution): + z = encoder_posterior.sample() + elif isinstance(encoder_posterior, torch.Tensor): + z = encoder_posterior + else: + raise NotImplementedError(f"encoder_posterior of type '{type(encoder_posterior)}' not yet implemented") + return self.scale_factor * z + + def get_learned_conditioning(self, c): + if self.cond_stage_forward is None: + if hasattr(self.cond_stage_model, 'encode') and callable(self.cond_stage_model.encode): + c = self.cond_stage_model.encode(c) + if isinstance(c, DiagonalGaussianDistribution): + c = c.mode() + else: + c = self.cond_stage_model(c) + else: + assert hasattr(self.cond_stage_model, self.cond_stage_forward) + c = getattr(self.cond_stage_model, self.cond_stage_forward)(c) + return c + + def meshgrid(self, h, w): + y = torch.arange(0, h).view(h, 1, 1).repeat(1, w, 1) + x = torch.arange(0, w).view(1, w, 1).repeat(h, 1, 1) + + arr = torch.cat([y, x], dim=-1) + return arr + + def delta_border(self, h, w): + """ + :param h: height + :param w: width + :return: normalized distance to image border, + wtith min distance = 0 at border and max dist = 0.5 at image center + """ + lower_right_corner = torch.tensor([h - 1, w - 1]).view(1, 1, 2) + arr = self.meshgrid(h, w) / lower_right_corner + dist_left_up = torch.min(arr, dim=-1, keepdims=True)[0] + dist_right_down = torch.min(1 - arr, dim=-1, keepdims=True)[0] + edge_dist = torch.min(torch.cat([dist_left_up, dist_right_down], dim=-1), dim=-1)[0] + return edge_dist + + def get_weighting(self, h, w, Ly, Lx, device): + weighting = self.delta_border(h, w) + weighting = torch.clip(weighting, self.split_input_params["clip_min_weight"], + self.split_input_params["clip_max_weight"], ) + weighting = weighting.view(1, h * w, 1).repeat(1, 1, Ly * Lx).to(device) + + if self.split_input_params["tie_braker"]: + L_weighting = self.delta_border(Ly, Lx) + L_weighting = torch.clip(L_weighting, + self.split_input_params["clip_min_tie_weight"], + self.split_input_params["clip_max_tie_weight"]) + + L_weighting = L_weighting.view(1, 1, Ly * Lx).to(device) + weighting = weighting * L_weighting + return weighting + + def get_fold_unfold(self, x, kernel_size, stride, uf=1, df=1): # todo load once not every time, shorten code + """ + :param x: img of size (bs, c, h, w) + :return: n img crops of size (n, bs, c, kernel_size[0], kernel_size[1]) + """ + bs, nc, h, w = x.shape + + # number of crops in image + Ly = (h - kernel_size[0]) // stride[0] + 1 + Lx = (w - kernel_size[1]) // stride[1] + 1 + + if uf == 1 and df == 1: + fold_params = dict(kernel_size=kernel_size, dilation=1, padding=0, stride=stride) + unfold = torch.nn.Unfold(**fold_params) + + fold = torch.nn.Fold(output_size=x.shape[2:], **fold_params) + + weighting = self.get_weighting(kernel_size[0], kernel_size[1], Ly, Lx, x.device).to(x.dtype) + normalization = fold(weighting).view(1, 1, h, w) # normalizes the overlap + weighting = weighting.view((1, 1, kernel_size[0], kernel_size[1], Ly * Lx)) + + elif uf > 1 and df == 1: + fold_params = dict(kernel_size=kernel_size, dilation=1, padding=0, stride=stride) + unfold = torch.nn.Unfold(**fold_params) + + fold_params2 = dict(kernel_size=(kernel_size[0] * uf, kernel_size[0] * uf), + dilation=1, padding=0, + stride=(stride[0] * uf, stride[1] * uf)) + fold = torch.nn.Fold(output_size=(x.shape[2] * uf, x.shape[3] * uf), **fold_params2) + + weighting = self.get_weighting(kernel_size[0] * uf, kernel_size[1] * uf, Ly, Lx, x.device).to(x.dtype) + normalization = fold(weighting).view(1, 1, h * uf, w * uf) # normalizes the overlap + weighting = weighting.view((1, 1, kernel_size[0] * uf, kernel_size[1] * uf, Ly * Lx)) + + elif df > 1 and uf == 1: + fold_params = dict(kernel_size=kernel_size, dilation=1, padding=0, stride=stride) + unfold = torch.nn.Unfold(**fold_params) + + fold_params2 = dict(kernel_size=(kernel_size[0] // df, kernel_size[0] // df), + dilation=1, padding=0, + stride=(stride[0] // df, stride[1] // df)) + fold = torch.nn.Fold(output_size=(x.shape[2] // df, x.shape[3] // df), **fold_params2) + + weighting = self.get_weighting(kernel_size[0] // df, kernel_size[1] // df, Ly, Lx, x.device).to(x.dtype) + normalization = fold(weighting).view(1, 1, h // df, w // df) # normalizes the overlap + weighting = weighting.view((1, 1, kernel_size[0] // df, kernel_size[1] // df, Ly * Lx)) + + else: + raise NotImplementedError + + return fold, unfold, normalization, weighting + + @torch.no_grad() + def get_input(self, batch, k, return_first_stage_outputs=False, force_c_encode=False, + cond_key=None, return_original_cond=False, bs=None, return_x=False): + x = super().get_input(batch, k) + if bs is not None: + x = x[:bs] + x = x.to(self.device) + encoder_posterior = self.encode_first_stage(x) + z = self.get_first_stage_encoding(encoder_posterior).detach() + + if self.model.conditioning_key is not None and not self.force_null_conditioning: + if cond_key is None: + cond_key = self.cond_stage_key + if cond_key != self.first_stage_key: + if cond_key in ['caption', 'coordinates_bbox', "txt"]: + xc = batch[cond_key] + elif cond_key in ['class_label', 'cls']: + xc = batch + else: + xc = super().get_input(batch, cond_key).to(self.device) + else: + xc = x + if not self.cond_stage_trainable or force_c_encode: + if isinstance(xc, dict) or isinstance(xc, list): + c = self.get_learned_conditioning(xc) + else: + c = self.get_learned_conditioning(xc.to(self.device)) + else: + c = xc + if bs is not None: + c = c[:bs] + + if self.use_positional_encodings: + pos_x, pos_y = self.compute_latent_shifts(batch) + ckey = __conditioning_keys__[self.model.conditioning_key] + c = {ckey: c, 'pos_x': pos_x, 'pos_y': pos_y} + + else: + c = None + xc = None + if self.use_positional_encodings: + pos_x, pos_y = self.compute_latent_shifts(batch) + c = {'pos_x': pos_x, 'pos_y': pos_y} + out = [z, c] + if return_first_stage_outputs: + xrec = self.decode_first_stage(z) + out.extend([x, xrec]) + if return_x: + out.extend([x]) + if return_original_cond: + out.append(xc) + return out + + @torch.no_grad() + def decode_first_stage(self, z, predict_cids=False, force_not_quantize=False): + if predict_cids: + if z.dim() == 4: + z = torch.argmax(z.exp(), dim=1).long() + z = self.first_stage_model.quantize.get_codebook_entry(z, shape=None) + z = rearrange(z, 'b h w c -> b c h w').contiguous() + + z = 1. / self.scale_factor * z + return self.first_stage_model.decode(z) + + @torch.no_grad() + def encode_first_stage(self, x): + return self.first_stage_model.encode(x) + + def shared_step(self, batch, **kwargs): + x, c = self.get_input(batch, self.first_stage_key) + loss = self(x, c) + return loss + + def forward(self, x, c, *args, **kwargs): + t = torch.randint(0, self.num_timesteps, (x.shape[0],), device=self.device).long() + if self.model.conditioning_key is not None: + assert c is not None + if self.cond_stage_trainable: + c = self.get_learned_conditioning(c) + if self.shorten_cond_schedule: # TODO: drop this option + tc = self.cond_ids[t].to(self.device) + c = self.q_sample(x_start=c, t=tc, noise=torch.randn_like(c.float())) + return self.p_losses(x, c, t, *args, **kwargs) + + def apply_model(self, x_noisy, t, cond, return_ids=False): + if isinstance(cond, dict): + # hybrid case, cond is expected to be a dict + pass + else: + if not isinstance(cond, list): + cond = [cond] + key = 'c_concat' if self.model.conditioning_key == 'concat' else 'c_crossattn' + cond = {key: cond} + + x_recon = self.model(x_noisy, t, **cond) + + if isinstance(x_recon, tuple) and not return_ids: + return x_recon[0] + else: + return x_recon + + def _predict_eps_from_xstart(self, x_t, t, pred_xstart): + return (extract_into_tensor(self.sqrt_recip_alphas_cumprod, t, x_t.shape) * x_t - pred_xstart) / \ + extract_into_tensor(self.sqrt_recipm1_alphas_cumprod, t, x_t.shape) + + def _prior_bpd(self, x_start): + """ + Get the prior KL term for the variational lower-bound, measured in + bits-per-dim. + This term can't be optimized, as it only depends on the encoder. + :param x_start: the [N x C x ...] tensor of inputs. + :return: a batch of [N] KL values (in bits), one per batch element. + """ + batch_size = x_start.shape[0] + t = torch.tensor([self.num_timesteps - 1] * batch_size, device=x_start.device) + qt_mean, _, qt_log_variance = self.q_mean_variance(x_start, t) + kl_prior = normal_kl(mean1=qt_mean, logvar1=qt_log_variance, mean2=0.0, logvar2=0.0) + return mean_flat(kl_prior) / np.log(2.0) + + def p_losses(self, x_start, cond, t, noise=None): + noise = default(noise, lambda: torch.randn_like(x_start)) + x_noisy = self.q_sample(x_start=x_start, t=t, noise=noise) + model_output = self.apply_model(x_noisy, t, cond) + + loss_dict = {} + prefix = 'train' if self.training else 'val' + + if self.parameterization == "x0": + target = x_start + elif self.parameterization == "eps": + target = noise + elif self.parameterization == "v": + target = self.get_v(x_start, noise, t) + else: + raise NotImplementedError() + + loss_simple = self.get_loss(model_output, target, mean=False).mean([1, 2, 3]) + loss_dict.update({f'{prefix}/loss_simple': loss_simple.mean()}) + + logvar_t = self.logvar[t].to(self.device) + loss = loss_simple / torch.exp(logvar_t) + logvar_t + # loss = loss_simple / torch.exp(self.logvar) + self.logvar + if self.learn_logvar: + loss_dict.update({f'{prefix}/loss_gamma': loss.mean()}) + loss_dict.update({'logvar': self.logvar.data.mean()}) + + loss = self.l_simple_weight * loss.mean() + + loss_vlb = self.get_loss(model_output, target, mean=False).mean(dim=(1, 2, 3)) + loss_vlb = (self.lvlb_weights[t] * loss_vlb).mean() + loss_dict.update({f'{prefix}/loss_vlb': loss_vlb}) + loss += (self.original_elbo_weight * loss_vlb) + loss_dict.update({f'{prefix}/loss': loss}) + + return loss, loss_dict + + def p_mean_variance(self, x, c, t, clip_denoised: bool, return_codebook_ids=False, quantize_denoised=False, + return_x0=False, score_corrector=None, corrector_kwargs=None): + t_in = t + model_out = self.apply_model(x, t_in, c, return_ids=return_codebook_ids) + + if score_corrector is not None: + assert self.parameterization == "eps" + model_out = score_corrector.modify_score(self, model_out, x, t, c, **corrector_kwargs) + + if return_codebook_ids: + model_out, logits = model_out + + if self.parameterization == "eps": + x_recon = self.predict_start_from_noise(x, t=t, noise=model_out) + elif self.parameterization == "x0": + x_recon = model_out + else: + raise NotImplementedError() + + if clip_denoised: + x_recon.clamp_(-1., 1.) + if quantize_denoised: + x_recon, _, [_, _, indices] = self.first_stage_model.quantize(x_recon) + model_mean, posterior_variance, posterior_log_variance = self.q_posterior(x_start=x_recon, x_t=x, t=t) + if return_codebook_ids: + return model_mean, posterior_variance, posterior_log_variance, logits + elif return_x0: + return model_mean, posterior_variance, posterior_log_variance, x_recon + else: + return model_mean, posterior_variance, posterior_log_variance + + @torch.no_grad() + def p_sample(self, x, c, t, clip_denoised=False, repeat_noise=False, + return_codebook_ids=False, quantize_denoised=False, return_x0=False, + temperature=1., noise_dropout=0., score_corrector=None, corrector_kwargs=None): + b, *_, device = *x.shape, x.device + outputs = self.p_mean_variance(x=x, c=c, t=t, clip_denoised=clip_denoised, + return_codebook_ids=return_codebook_ids, + quantize_denoised=quantize_denoised, + return_x0=return_x0, + score_corrector=score_corrector, corrector_kwargs=corrector_kwargs) + if return_codebook_ids: + raise DeprecationWarning("Support dropped.") + model_mean, _, model_log_variance, logits = outputs + elif return_x0: + model_mean, _, model_log_variance, x0 = outputs + else: + model_mean, _, model_log_variance = outputs + + noise = noise_like(x.shape, device, repeat_noise) * temperature + if noise_dropout > 0.: + noise = torch.nn.functional.dropout(noise, p=noise_dropout) + # no noise when t == 0 + nonzero_mask = (1 - (t == 0).float()).reshape(b, *((1,) * (len(x.shape) - 1))) + + if return_codebook_ids: + return model_mean + nonzero_mask * (0.5 * model_log_variance).exp() * noise, logits.argmax(dim=1) + if return_x0: + return model_mean + nonzero_mask * (0.5 * model_log_variance).exp() * noise, x0 + else: + return model_mean + nonzero_mask * (0.5 * model_log_variance).exp() * noise + + @torch.no_grad() + def progressive_denoising(self, cond, shape, verbose=True, callback=None, quantize_denoised=False, + img_callback=None, mask=None, x0=None, temperature=1., noise_dropout=0., + score_corrector=None, corrector_kwargs=None, batch_size=None, x_T=None, start_T=None, + log_every_t=None): + if not log_every_t: + log_every_t = self.log_every_t + timesteps = self.num_timesteps + if batch_size is not None: + b = batch_size if batch_size is not None else shape[0] + shape = [batch_size] + list(shape) + else: + b = batch_size = shape[0] + if x_T is None: + img = torch.randn(shape, device=self.device) + else: + img = x_T + intermediates = [] + if cond is not None: + if isinstance(cond, dict): + cond = {key: cond[key][:batch_size] if not isinstance(cond[key], list) else + list(map(lambda x: x[:batch_size], cond[key])) for key in cond} + else: + cond = [c[:batch_size] for c in cond] if isinstance(cond, list) else cond[:batch_size] + + if start_T is not None: + timesteps = min(timesteps, start_T) + iterator = tqdm(reversed(range(0, timesteps)), desc='Progressive Generation', + total=timesteps) if verbose else reversed( + range(0, timesteps)) + if type(temperature) == float: + temperature = [temperature] * timesteps + + for i in iterator: + ts = torch.full((b,), i, device=self.device, dtype=torch.long) + if self.shorten_cond_schedule: + assert self.model.conditioning_key != 'hybrid' + tc = self.cond_ids[ts].to(cond.device) + cond = self.q_sample(x_start=cond, t=tc, noise=torch.randn_like(cond)) + + img, x0_partial = self.p_sample(img, cond, ts, + clip_denoised=self.clip_denoised, + quantize_denoised=quantize_denoised, return_x0=True, + temperature=temperature[i], noise_dropout=noise_dropout, + score_corrector=score_corrector, corrector_kwargs=corrector_kwargs) + if mask is not None: + assert x0 is not None + img_orig = self.q_sample(x0, ts) + img = img_orig * mask + (1. - mask) * img + + if i % log_every_t == 0 or i == timesteps - 1: + intermediates.append(x0_partial) + if callback: callback(i) + if img_callback: img_callback(img, i) + return img, intermediates + + @torch.no_grad() + def p_sample_loop(self, cond, shape, return_intermediates=False, + x_T=None, verbose=True, callback=None, timesteps=None, quantize_denoised=False, + mask=None, x0=None, img_callback=None, start_T=None, + log_every_t=None): + + if not log_every_t: + log_every_t = self.log_every_t + device = self.betas.device + b = shape[0] + if x_T is None: + img = torch.randn(shape, device=device) + else: + img = x_T + + intermediates = [img] + if timesteps is None: + timesteps = self.num_timesteps + + if start_T is not None: + timesteps = min(timesteps, start_T) + iterator = tqdm(reversed(range(0, timesteps)), desc='Sampling t', total=timesteps) if verbose else reversed( + range(0, timesteps)) + + if mask is not None: + assert x0 is not None + assert x0.shape[2:3] == mask.shape[2:3] # spatial size has to match + + for i in iterator: + ts = torch.full((b,), i, device=device, dtype=torch.long) + if self.shorten_cond_schedule: + assert self.model.conditioning_key != 'hybrid' + tc = self.cond_ids[ts].to(cond.device) + cond = self.q_sample(x_start=cond, t=tc, noise=torch.randn_like(cond)) + + img = self.p_sample(img, cond, ts, + clip_denoised=self.clip_denoised, + quantize_denoised=quantize_denoised) + if mask is not None: + img_orig = self.q_sample(x0, ts) + img = img_orig * mask + (1. - mask) * img + + if i % log_every_t == 0 or i == timesteps - 1: + intermediates.append(img) + if callback: callback(i) + if img_callback: img_callback(img, i) + + if return_intermediates: + return img, intermediates + return img + + @torch.no_grad() + def sample(self, cond, batch_size=16, return_intermediates=False, x_T=None, + verbose=True, timesteps=None, quantize_denoised=False, + mask=None, x0=None, shape=None, **kwargs): + if shape is None: + shape = (batch_size, self.channels, self.image_size, self.image_size) + if cond is not None: + if isinstance(cond, dict): + cond = {key: cond[key][:batch_size] if not isinstance(cond[key], list) else + list(map(lambda x: x[:batch_size], cond[key])) for key in cond} + else: + cond = [c[:batch_size] for c in cond] if isinstance(cond, list) else cond[:batch_size] + return self.p_sample_loop(cond, + shape, + return_intermediates=return_intermediates, x_T=x_T, + verbose=verbose, timesteps=timesteps, quantize_denoised=quantize_denoised, + mask=mask, x0=x0) + + @torch.no_grad() + def sample_log(self, cond, batch_size, ddim, ddim_steps, **kwargs): + if ddim: + ddim_sampler = DDIMSampler(self) + shape = (self.channels, self.image_size, self.image_size) + samples, intermediates = ddim_sampler.sample(ddim_steps, batch_size, + shape, cond, verbose=False, **kwargs) + + else: + samples, intermediates = self.sample(cond=cond, batch_size=batch_size, + return_intermediates=True, **kwargs) + + return samples, intermediates + + @torch.no_grad() + def get_unconditional_conditioning(self, batch_size, null_label=None): + if null_label is not None: + xc = null_label + if isinstance(xc, ListConfig): + xc = list(xc) + if isinstance(xc, dict) or isinstance(xc, list): + c = self.get_learned_conditioning(xc) + else: + if hasattr(xc, "to"): + xc = xc.to(self.device) + c = self.get_learned_conditioning(xc) + else: + if self.cond_stage_key in ["class_label", "cls"]: + xc = self.cond_stage_model.get_unconditional_conditioning(batch_size, device=self.device) + return self.get_learned_conditioning(xc) + else: + raise NotImplementedError("todo") + if isinstance(c, list): # in case the encoder gives us a list + for i in range(len(c)): + c[i] = repeat(c[i], '1 ... -> b ...', b=batch_size).to(self.device) + else: + c = repeat(c, '1 ... -> b ...', b=batch_size).to(self.device) + return c + + @torch.no_grad() + def log_images(self, batch, N=8, n_row=4, sample=True, ddim_steps=50, ddim_eta=0., return_keys=None, + quantize_denoised=True, inpaint=True, plot_denoise_rows=False, plot_progressive_rows=True, + plot_diffusion_rows=True, unconditional_guidance_scale=1., unconditional_guidance_label=None, + use_ema_scope=True, + **kwargs): + ema_scope = self.ema_scope if use_ema_scope else nullcontext + use_ddim = ddim_steps is not None + + log = dict() + z, c, x, xrec, xc = self.get_input(batch, self.first_stage_key, + return_first_stage_outputs=True, + force_c_encode=True, + return_original_cond=True, + bs=N) + N = min(x.shape[0], N) + n_row = min(x.shape[0], n_row) + log["inputs"] = x + log["reconstruction"] = xrec + if self.model.conditioning_key is not None: + if hasattr(self.cond_stage_model, "decode"): + xc = self.cond_stage_model.decode(c) + log["conditioning"] = xc + elif self.cond_stage_key in ["caption", "txt"]: + xc = log_txt_as_img((x.shape[2], x.shape[3]), batch[self.cond_stage_key], size=x.shape[2] // 25) + log["conditioning"] = xc + elif self.cond_stage_key in ['class_label', "cls"]: + try: + xc = log_txt_as_img((x.shape[2], x.shape[3]), batch["human_label"], size=x.shape[2] // 25) + log['conditioning'] = xc + except KeyError: + # probably no "human_label" in batch + pass + elif isimage(xc): + log["conditioning"] = xc + if ismap(xc): + log["original_conditioning"] = self.to_rgb(xc) + + if plot_diffusion_rows: + # get diffusion row + diffusion_row = list() + z_start = z[:n_row] + for t in range(self.num_timesteps): + if t % self.log_every_t == 0 or t == self.num_timesteps - 1: + t = repeat(torch.tensor([t]), '1 -> b', b=n_row) + t = t.to(self.device).long() + noise = torch.randn_like(z_start) + z_noisy = self.q_sample(x_start=z_start, t=t, noise=noise) + diffusion_row.append(self.decode_first_stage(z_noisy)) + + diffusion_row = torch.stack(diffusion_row) # n_log_step, n_row, C, H, W + diffusion_grid = rearrange(diffusion_row, 'n b c h w -> b n c h w') + diffusion_grid = rearrange(diffusion_grid, 'b n c h w -> (b n) c h w') + diffusion_grid = make_grid(diffusion_grid, nrow=diffusion_row.shape[0]) + log["diffusion_row"] = diffusion_grid + + if sample: + # get denoise row + with ema_scope("Sampling"): + samples, z_denoise_row = self.sample_log(cond=c, batch_size=N, ddim=use_ddim, + ddim_steps=ddim_steps, eta=ddim_eta) + # samples, z_denoise_row = self.sample(cond=c, batch_size=N, return_intermediates=True) + x_samples = self.decode_first_stage(samples) + log["samples"] = x_samples + if plot_denoise_rows: + denoise_grid = self._get_denoise_row_from_list(z_denoise_row) + log["denoise_row"] = denoise_grid + + if quantize_denoised and not isinstance(self.first_stage_model, AutoencoderKL) and not isinstance( + self.first_stage_model, IdentityFirstStage): + # also display when quantizing x0 while sampling + with ema_scope("Plotting Quantized Denoised"): + samples, z_denoise_row = self.sample_log(cond=c, batch_size=N, ddim=use_ddim, + ddim_steps=ddim_steps, eta=ddim_eta, + quantize_denoised=True) + # samples, z_denoise_row = self.sample(cond=c, batch_size=N, return_intermediates=True, + # quantize_denoised=True) + x_samples = self.decode_first_stage(samples.to(self.device)) + log["samples_x0_quantized"] = x_samples + + if unconditional_guidance_scale > 1.0: + uc = self.get_unconditional_conditioning(N, unconditional_guidance_label) + if self.model.conditioning_key == "crossattn-adm": + uc = {"c_crossattn": [uc], "c_adm": c["c_adm"]} + with ema_scope("Sampling with classifier-free guidance"): + samples_cfg, _ = self.sample_log(cond=c, batch_size=N, ddim=use_ddim, + ddim_steps=ddim_steps, eta=ddim_eta, + unconditional_guidance_scale=unconditional_guidance_scale, + unconditional_conditioning=uc, + ) + x_samples_cfg = self.decode_first_stage(samples_cfg) + log[f"samples_cfg_scale_{unconditional_guidance_scale:.2f}"] = x_samples_cfg + + if inpaint: + # make a simple center square + b, h, w = z.shape[0], z.shape[2], z.shape[3] + mask = torch.ones(N, h, w).to(self.device) + # zeros will be filled in + mask[:, h // 4:3 * h // 4, w // 4:3 * w // 4] = 0. + mask = mask[:, None, ...] + with ema_scope("Plotting Inpaint"): + samples, _ = self.sample_log(cond=c, batch_size=N, ddim=use_ddim, eta=ddim_eta, + ddim_steps=ddim_steps, x0=z[:N], mask=mask) + x_samples = self.decode_first_stage(samples.to(self.device)) + log["samples_inpainting"] = x_samples + log["mask"] = mask + + # outpaint + mask = 1. - mask + with ema_scope("Plotting Outpaint"): + samples, _ = self.sample_log(cond=c, batch_size=N, ddim=use_ddim, eta=ddim_eta, + ddim_steps=ddim_steps, x0=z[:N], mask=mask) + x_samples = self.decode_first_stage(samples.to(self.device)) + log["samples_outpainting"] = x_samples + + if plot_progressive_rows: + with ema_scope("Plotting Progressives"): + img, progressives = self.progressive_denoising(c, + shape=(self.channels, self.image_size, self.image_size), + batch_size=N) + prog_row = self._get_denoise_row_from_list(progressives, desc="Progressive Generation") + log["progressive_row"] = prog_row + + if return_keys: + if np.intersect1d(list(log.keys()), return_keys).shape[0] == 0: + return log + else: + return {key: log[key] for key in return_keys} + return log + + def configure_optimizers(self): + lr = self.learning_rate + params = list(self.model.parameters()) + if self.cond_stage_trainable: + print(f"{self.__class__.__name__}: Also optimizing conditioner params!") + params = params + list(self.cond_stage_model.parameters()) + if self.learn_logvar: + print('Diffusion model optimizing logvar') + params.append(self.logvar) + opt = torch.optim.AdamW(params, lr=lr) + if self.use_scheduler: + assert 'target' in self.scheduler_config + scheduler = instantiate_from_config(self.scheduler_config) + + print("Setting up LambdaLR scheduler...") + scheduler = [ + { + 'scheduler': LambdaLR(opt, lr_lambda=scheduler.schedule), + 'interval': 'step', + 'frequency': 1 + }] + return [opt], scheduler + return opt + + @torch.no_grad() + def to_rgb(self, x): + x = x.float() + if not hasattr(self, "colorize"): + self.colorize = torch.randn(3, x.shape[1], 1, 1).to(x) + x = nn.functional.conv2d(x, weight=self.colorize) + x = 2. * (x - x.min()) / (x.max() - x.min()) - 1. + return x + + +class DiffusionWrapper(pl.LightningModule): + def __init__(self, diff_model_config, conditioning_key): + super().__init__() + self.sequential_cross_attn = diff_model_config.pop("sequential_crossattn", False) + self.diffusion_model = instantiate_from_config(diff_model_config) + self.conditioning_key = conditioning_key + assert self.conditioning_key in [None, 'concat', 'crossattn', 'hybrid', 'adm', 'hybrid-adm', 'crossattn-adm'] + + def forward(self, x, t, c_concat: list = None, c_crossattn: list = None, c_adm=None): + if self.conditioning_key is None: + out = self.diffusion_model(x, t) + elif self.conditioning_key == 'concat': + xc = torch.cat([x] + c_concat, dim=1) + out = self.diffusion_model(xc, t) + elif self.conditioning_key == 'crossattn': # default + if not self.sequential_cross_attn: + cc = torch.cat(c_crossattn, 1) + else: + cc = c_crossattn + if hasattr(self, "scripted_diffusion_model"): + # TorchScript changes names of the arguments + # with argument cc defined as context=cc scripted model will produce + # an error: RuntimeError: forward() is missing value for argument 'argument_3'. + out = self.scripted_diffusion_model(x, t, cc) + else: + out = self.diffusion_model(x, t, context=cc) + elif self.conditioning_key == 'hybrid': + xc = torch.cat([x] + c_concat, dim=1) + cc = torch.cat(c_crossattn, 1) + out = self.diffusion_model(xc, t, context=cc) + elif self.conditioning_key == 'hybrid-adm': + assert c_adm is not None + xc = torch.cat([x] + c_concat, dim=1) + cc = torch.cat(c_crossattn, 1) + out = self.diffusion_model(xc, t, context=cc, y=c_adm) + elif self.conditioning_key == 'crossattn-adm': + assert c_adm is not None + cc = torch.cat(c_crossattn, 1) + out = self.diffusion_model(x, t, context=cc, y=c_adm) + elif self.conditioning_key == 'adm': + cc = c_crossattn[0] + out = self.diffusion_model(x, t, y=cc) + else: + raise NotImplementedError() + + return out + + +class LatentUpscaleDiffusion(LatentDiffusion): + def __init__(self, *args, low_scale_config, low_scale_key="LR", noise_level_key=None, **kwargs): + super().__init__(*args, **kwargs) + # assumes that neither the cond_stage nor the low_scale_model contain trainable params + assert not self.cond_stage_trainable + self.instantiate_low_stage(low_scale_config) + self.low_scale_key = low_scale_key + self.noise_level_key = noise_level_key + + def instantiate_low_stage(self, config): + model = instantiate_from_config(config) + self.low_scale_model = model.eval() + self.low_scale_model.train = disabled_train + for param in self.low_scale_model.parameters(): + param.requires_grad = False + + @torch.no_grad() + def get_input(self, batch, k, cond_key=None, bs=None, log_mode=False): + if not log_mode: + z, c = super().get_input(batch, k, force_c_encode=True, bs=bs) + else: + z, c, x, xrec, xc = super().get_input(batch, self.first_stage_key, return_first_stage_outputs=True, + force_c_encode=True, return_original_cond=True, bs=bs) + x_low = batch[self.low_scale_key][:bs] + x_low = rearrange(x_low, 'b h w c -> b c h w') + x_low = x_low.to(memory_format=torch.contiguous_format).float() + zx, noise_level = self.low_scale_model(x_low) + if self.noise_level_key is not None: + # get noise level from batch instead, e.g. when extracting a custom noise level for bsr + raise NotImplementedError('TODO') + + all_conds = {"c_concat": [zx], "c_crossattn": [c], "c_adm": noise_level} + if log_mode: + # TODO: maybe disable if too expensive + x_low_rec = self.low_scale_model.decode(zx) + return z, all_conds, x, xrec, xc, x_low, x_low_rec, noise_level + return z, all_conds + + @torch.no_grad() + def log_images(self, batch, N=8, n_row=4, sample=True, ddim_steps=200, ddim_eta=1., return_keys=None, + plot_denoise_rows=False, plot_progressive_rows=True, plot_diffusion_rows=True, + unconditional_guidance_scale=1., unconditional_guidance_label=None, use_ema_scope=True, + **kwargs): + ema_scope = self.ema_scope if use_ema_scope else nullcontext + use_ddim = ddim_steps is not None + + log = dict() + z, c, x, xrec, xc, x_low, x_low_rec, noise_level = self.get_input(batch, self.first_stage_key, bs=N, + log_mode=True) + N = min(x.shape[0], N) + n_row = min(x.shape[0], n_row) + log["inputs"] = x + log["reconstruction"] = xrec + log["x_lr"] = x_low + log[f"x_lr_rec_@noise_levels{'-'.join(map(lambda x: str(x), list(noise_level.cpu().numpy())))}"] = x_low_rec + if self.model.conditioning_key is not None: + if hasattr(self.cond_stage_model, "decode"): + xc = self.cond_stage_model.decode(c) + log["conditioning"] = xc + elif self.cond_stage_key in ["caption", "txt"]: + xc = log_txt_as_img((x.shape[2], x.shape[3]), batch[self.cond_stage_key], size=x.shape[2] // 25) + log["conditioning"] = xc + elif self.cond_stage_key in ['class_label', 'cls']: + xc = log_txt_as_img((x.shape[2], x.shape[3]), batch["human_label"], size=x.shape[2] // 25) + log['conditioning'] = xc + elif isimage(xc): + log["conditioning"] = xc + if ismap(xc): + log["original_conditioning"] = self.to_rgb(xc) + + if plot_diffusion_rows: + # get diffusion row + diffusion_row = list() + z_start = z[:n_row] + for t in range(self.num_timesteps): + if t % self.log_every_t == 0 or t == self.num_timesteps - 1: + t = repeat(torch.tensor([t]), '1 -> b', b=n_row) + t = t.to(self.device).long() + noise = torch.randn_like(z_start) + z_noisy = self.q_sample(x_start=z_start, t=t, noise=noise) + diffusion_row.append(self.decode_first_stage(z_noisy)) + + diffusion_row = torch.stack(diffusion_row) # n_log_step, n_row, C, H, W + diffusion_grid = rearrange(diffusion_row, 'n b c h w -> b n c h w') + diffusion_grid = rearrange(diffusion_grid, 'b n c h w -> (b n) c h w') + diffusion_grid = make_grid(diffusion_grid, nrow=diffusion_row.shape[0]) + log["diffusion_row"] = diffusion_grid + + if sample: + # get denoise row + with ema_scope("Sampling"): + samples, z_denoise_row = self.sample_log(cond=c, batch_size=N, ddim=use_ddim, + ddim_steps=ddim_steps, eta=ddim_eta) + # samples, z_denoise_row = self.sample(cond=c, batch_size=N, return_intermediates=True) + x_samples = self.decode_first_stage(samples) + log["samples"] = x_samples + if plot_denoise_rows: + denoise_grid = self._get_denoise_row_from_list(z_denoise_row) + log["denoise_row"] = denoise_grid + + if unconditional_guidance_scale > 1.0: + uc_tmp = self.get_unconditional_conditioning(N, unconditional_guidance_label) + # TODO explore better "unconditional" choices for the other keys + # maybe guide away from empty text label and highest noise level and maximally degraded zx? + uc = dict() + for k in c: + if k == "c_crossattn": + assert isinstance(c[k], list) and len(c[k]) == 1 + uc[k] = [uc_tmp] + elif k == "c_adm": # todo: only run with text-based guidance? + assert isinstance(c[k], torch.Tensor) + #uc[k] = torch.ones_like(c[k]) * self.low_scale_model.max_noise_level + uc[k] = c[k] + elif isinstance(c[k], list): + uc[k] = [c[k][i] for i in range(len(c[k]))] + else: + uc[k] = c[k] + + with ema_scope("Sampling with classifier-free guidance"): + samples_cfg, _ = self.sample_log(cond=c, batch_size=N, ddim=use_ddim, + ddim_steps=ddim_steps, eta=ddim_eta, + unconditional_guidance_scale=unconditional_guidance_scale, + unconditional_conditioning=uc, + ) + x_samples_cfg = self.decode_first_stage(samples_cfg) + log[f"samples_cfg_scale_{unconditional_guidance_scale:.2f}"] = x_samples_cfg + + if plot_progressive_rows: + with ema_scope("Plotting Progressives"): + img, progressives = self.progressive_denoising(c, + shape=(self.channels, self.image_size, self.image_size), + batch_size=N) + prog_row = self._get_denoise_row_from_list(progressives, desc="Progressive Generation") + log["progressive_row"] = prog_row + + return log + + +class LatentFinetuneDiffusion(LatentDiffusion): + """ + Basis for different finetunas, such as inpainting or depth2image + To disable finetuning mode, set finetune_keys to None + """ + + def __init__(self, + concat_keys: tuple, + finetune_keys=("model.diffusion_model.input_blocks.0.0.weight", + "model_ema.diffusion_modelinput_blocks00weight" + ), + keep_finetune_dims=4, + # if model was trained without concat mode before and we would like to keep these channels + c_concat_log_start=None, # to log reconstruction of c_concat codes + c_concat_log_end=None, + *args, **kwargs + ): + ckpt_path = kwargs.pop("ckpt_path", None) + ignore_keys = kwargs.pop("ignore_keys", list()) + super().__init__(*args, **kwargs) + self.finetune_keys = finetune_keys + self.concat_keys = concat_keys + self.keep_dims = keep_finetune_dims + self.c_concat_log_start = c_concat_log_start + self.c_concat_log_end = c_concat_log_end + if exists(self.finetune_keys): assert exists(ckpt_path), 'can only finetune from a given checkpoint' + if exists(ckpt_path): + self.init_from_ckpt(ckpt_path, ignore_keys) + + def init_from_ckpt(self, path, ignore_keys=list(), only_model=False): + sd = torch.load(path, map_location="cpu") + if "state_dict" in list(sd.keys()): + sd = sd["state_dict"] + keys = list(sd.keys()) + for k in keys: + for ik in ignore_keys: + if k.startswith(ik): + print("Deleting key {} from state_dict.".format(k)) + del sd[k] + + # make it explicit, finetune by including extra input channels + if exists(self.finetune_keys) and k in self.finetune_keys: + new_entry = None + for name, param in self.named_parameters(): + if name in self.finetune_keys: + print( + f"modifying key '{name}' and keeping its original {self.keep_dims} (channels) dimensions only") + new_entry = torch.zeros_like(param) # zero init + assert exists(new_entry), 'did not find matching parameter to modify' + new_entry[:, :self.keep_dims, ...] = sd[k] + sd[k] = new_entry + + missing, unexpected = self.load_state_dict(sd, strict=False) if not only_model else self.model.load_state_dict( + sd, strict=False) + print(f"Restored from {path} with {len(missing)} missing and {len(unexpected)} unexpected keys") + if len(missing) > 0: + print(f"Missing Keys: {missing}") + if len(unexpected) > 0: + print(f"Unexpected Keys: {unexpected}") + + @torch.no_grad() + def log_images(self, batch, N=8, n_row=4, sample=True, ddim_steps=200, ddim_eta=1., return_keys=None, + quantize_denoised=True, inpaint=True, plot_denoise_rows=False, plot_progressive_rows=True, + plot_diffusion_rows=True, unconditional_guidance_scale=1., unconditional_guidance_label=None, + use_ema_scope=True, + **kwargs): + ema_scope = self.ema_scope if use_ema_scope else nullcontext + use_ddim = ddim_steps is not None + + log = dict() + z, c, x, xrec, xc = self.get_input(batch, self.first_stage_key, bs=N, return_first_stage_outputs=True) + c_cat, c = c["c_concat"][0], c["c_crossattn"][0] + N = min(x.shape[0], N) + n_row = min(x.shape[0], n_row) + log["inputs"] = x + log["reconstruction"] = xrec + if self.model.conditioning_key is not None: + if hasattr(self.cond_stage_model, "decode"): + xc = self.cond_stage_model.decode(c) + log["conditioning"] = xc + elif self.cond_stage_key in ["caption", "txt"]: + xc = log_txt_as_img((x.shape[2], x.shape[3]), batch[self.cond_stage_key], size=x.shape[2] // 25) + log["conditioning"] = xc + elif self.cond_stage_key in ['class_label', 'cls']: + xc = log_txt_as_img((x.shape[2], x.shape[3]), batch["human_label"], size=x.shape[2] // 25) + log['conditioning'] = xc + elif isimage(xc): + log["conditioning"] = xc + if ismap(xc): + log["original_conditioning"] = self.to_rgb(xc) + + if not (self.c_concat_log_start is None and self.c_concat_log_end is None): + log["c_concat_decoded"] = self.decode_first_stage(c_cat[:, self.c_concat_log_start:self.c_concat_log_end]) + + if plot_diffusion_rows: + # get diffusion row + diffusion_row = list() + z_start = z[:n_row] + for t in range(self.num_timesteps): + if t % self.log_every_t == 0 or t == self.num_timesteps - 1: + t = repeat(torch.tensor([t]), '1 -> b', b=n_row) + t = t.to(self.device).long() + noise = torch.randn_like(z_start) + z_noisy = self.q_sample(x_start=z_start, t=t, noise=noise) + diffusion_row.append(self.decode_first_stage(z_noisy)) + + diffusion_row = torch.stack(diffusion_row) # n_log_step, n_row, C, H, W + diffusion_grid = rearrange(diffusion_row, 'n b c h w -> b n c h w') + diffusion_grid = rearrange(diffusion_grid, 'b n c h w -> (b n) c h w') + diffusion_grid = make_grid(diffusion_grid, nrow=diffusion_row.shape[0]) + log["diffusion_row"] = diffusion_grid + + if sample: + # get denoise row + with ema_scope("Sampling"): + samples, z_denoise_row = self.sample_log(cond={"c_concat": [c_cat], "c_crossattn": [c]}, + batch_size=N, ddim=use_ddim, + ddim_steps=ddim_steps, eta=ddim_eta) + # samples, z_denoise_row = self.sample(cond=c, batch_size=N, return_intermediates=True) + x_samples = self.decode_first_stage(samples) + log["samples"] = x_samples + if plot_denoise_rows: + denoise_grid = self._get_denoise_row_from_list(z_denoise_row) + log["denoise_row"] = denoise_grid + + if unconditional_guidance_scale > 1.0: + uc_cross = self.get_unconditional_conditioning(N, unconditional_guidance_label) + uc_cat = c_cat + uc_full = {"c_concat": [uc_cat], "c_crossattn": [uc_cross]} + with ema_scope("Sampling with classifier-free guidance"): + samples_cfg, _ = self.sample_log(cond={"c_concat": [c_cat], "c_crossattn": [c]}, + batch_size=N, ddim=use_ddim, + ddim_steps=ddim_steps, eta=ddim_eta, + unconditional_guidance_scale=unconditional_guidance_scale, + unconditional_conditioning=uc_full, + ) + x_samples_cfg = self.decode_first_stage(samples_cfg) + log[f"samples_cfg_scale_{unconditional_guidance_scale:.2f}"] = x_samples_cfg + + return log + + +class LatentInpaintDiffusion(LatentFinetuneDiffusion): + """ + can either run as pure inpainting model (only concat mode) or with mixed conditionings, + e.g. mask as concat and text via cross-attn. + To disable finetuning mode, set finetune_keys to None + """ + + def __init__(self, + concat_keys=("mask", "masked_image"), + masked_image_key="masked_image", + *args, **kwargs + ): + super().__init__(concat_keys, *args, **kwargs) + self.masked_image_key = masked_image_key + assert self.masked_image_key in concat_keys + + @torch.no_grad() + def get_input(self, batch, k, cond_key=None, bs=None, return_first_stage_outputs=False): + # note: restricted to non-trainable encoders currently + assert not self.cond_stage_trainable, 'trainable cond stages not yet supported for inpainting' + z, c, x, xrec, xc = super().get_input(batch, self.first_stage_key, return_first_stage_outputs=True, + force_c_encode=True, return_original_cond=True, bs=bs) + + assert exists(self.concat_keys) + c_cat = list() + for ck in self.concat_keys: + cc = rearrange(batch[ck], 'b h w c -> b c h w').to(memory_format=torch.contiguous_format).float() + if bs is not None: + cc = cc[:bs] + cc = cc.to(self.device) + bchw = z.shape + if ck != self.masked_image_key: + cc = torch.nn.functional.interpolate(cc, size=bchw[-2:]) + else: + cc = self.get_first_stage_encoding(self.encode_first_stage(cc)) + c_cat.append(cc) + c_cat = torch.cat(c_cat, dim=1) + all_conds = {"c_concat": [c_cat], "c_crossattn": [c]} + if return_first_stage_outputs: + return z, all_conds, x, xrec, xc + return z, all_conds + + @torch.no_grad() + def log_images(self, *args, **kwargs): + log = super(LatentInpaintDiffusion, self).log_images(*args, **kwargs) + log["masked_image"] = rearrange(args[0]["masked_image"], + 'b h w c -> b c h w').to(memory_format=torch.contiguous_format).float() + return log + + +class LatentDepth2ImageDiffusion(LatentFinetuneDiffusion): + """ + condition on monocular depth estimation + """ + + def __init__(self, depth_stage_config, concat_keys=("midas_in",), *args, **kwargs): + super().__init__(concat_keys=concat_keys, *args, **kwargs) + self.depth_model = instantiate_from_config(depth_stage_config) + self.depth_stage_key = concat_keys[0] + + @torch.no_grad() + def get_input(self, batch, k, cond_key=None, bs=None, return_first_stage_outputs=False): + # note: restricted to non-trainable encoders currently + assert not self.cond_stage_trainable, 'trainable cond stages not yet supported for depth2img' + z, c, x, xrec, xc = super().get_input(batch, self.first_stage_key, return_first_stage_outputs=True, + force_c_encode=True, return_original_cond=True, bs=bs) + + assert exists(self.concat_keys) + assert len(self.concat_keys) == 1 + c_cat = list() + for ck in self.concat_keys: + cc = batch[ck] + if bs is not None: + cc = cc[:bs] + cc = cc.to(self.device) + cc = self.depth_model(cc) + cc = torch.nn.functional.interpolate( + cc, + size=z.shape[2:], + mode="bicubic", + align_corners=False, + ) + + depth_min, depth_max = torch.amin(cc, dim=[1, 2, 3], keepdim=True), torch.amax(cc, dim=[1, 2, 3], + keepdim=True) + cc = 2. * (cc - depth_min) / (depth_max - depth_min + 0.001) - 1. + c_cat.append(cc) + c_cat = torch.cat(c_cat, dim=1) + all_conds = {"c_concat": [c_cat], "c_crossattn": [c]} + if return_first_stage_outputs: + return z, all_conds, x, xrec, xc + return z, all_conds + + @torch.no_grad() + def log_images(self, *args, **kwargs): + log = super().log_images(*args, **kwargs) + depth = self.depth_model(args[0][self.depth_stage_key]) + depth_min, depth_max = torch.amin(depth, dim=[1, 2, 3], keepdim=True), \ + torch.amax(depth, dim=[1, 2, 3], keepdim=True) + log["depth"] = 2. * (depth - depth_min) / (depth_max - depth_min) - 1. + return log + + +class LatentUpscaleFinetuneDiffusion(LatentFinetuneDiffusion): + """ + condition on low-res image (and optionally on some spatial noise augmentation) + """ + def __init__(self, concat_keys=("lr",), reshuffle_patch_size=None, + low_scale_config=None, low_scale_key=None, *args, **kwargs): + super().__init__(concat_keys=concat_keys, *args, **kwargs) + self.reshuffle_patch_size = reshuffle_patch_size + self.low_scale_model = None + if low_scale_config is not None: + print("Initializing a low-scale model") + assert exists(low_scale_key) + self.instantiate_low_stage(low_scale_config) + self.low_scale_key = low_scale_key + + def instantiate_low_stage(self, config): + model = instantiate_from_config(config) + self.low_scale_model = model.eval() + self.low_scale_model.train = disabled_train + for param in self.low_scale_model.parameters(): + param.requires_grad = False + + @torch.no_grad() + def get_input(self, batch, k, cond_key=None, bs=None, return_first_stage_outputs=False): + # note: restricted to non-trainable encoders currently + assert not self.cond_stage_trainable, 'trainable cond stages not yet supported for upscaling-ft' + z, c, x, xrec, xc = super().get_input(batch, self.first_stage_key, return_first_stage_outputs=True, + force_c_encode=True, return_original_cond=True, bs=bs) + + assert exists(self.concat_keys) + assert len(self.concat_keys) == 1 + # optionally make spatial noise_level here + c_cat = list() + noise_level = None + for ck in self.concat_keys: + cc = batch[ck] + cc = rearrange(cc, 'b h w c -> b c h w') + if exists(self.reshuffle_patch_size): + assert isinstance(self.reshuffle_patch_size, int) + cc = rearrange(cc, 'b c (p1 h) (p2 w) -> b (p1 p2 c) h w', + p1=self.reshuffle_patch_size, p2=self.reshuffle_patch_size) + if bs is not None: + cc = cc[:bs] + cc = cc.to(self.device) + if exists(self.low_scale_model) and ck == self.low_scale_key: + cc, noise_level = self.low_scale_model(cc) + c_cat.append(cc) + c_cat = torch.cat(c_cat, dim=1) + if exists(noise_level): + all_conds = {"c_concat": [c_cat], "c_crossattn": [c], "c_adm": noise_level} + else: + all_conds = {"c_concat": [c_cat], "c_crossattn": [c]} + if return_first_stage_outputs: + return z, all_conds, x, xrec, xc + return z, all_conds + + @torch.no_grad() + def log_images(self, *args, **kwargs): + log = super().log_images(*args, **kwargs) + log["lr"] = rearrange(args[0]["lr"], 'b h w c -> b c h w') + return log + + +class ImageEmbeddingConditionedLatentDiffusion(LatentDiffusion): + def __init__(self, embedder_config, embedding_key="jpg", embedding_dropout=0.5, + freeze_embedder=True, noise_aug_config=None, *args, **kwargs): + super().__init__(*args, **kwargs) + self.embed_key = embedding_key + self.embedding_dropout = embedding_dropout + self._init_embedder(embedder_config, freeze_embedder) + self._init_noise_aug(noise_aug_config) + + def _init_embedder(self, config, freeze=True): + embedder = instantiate_from_config(config) + if freeze: + self.embedder = embedder.eval() + self.embedder.train = disabled_train + for param in self.embedder.parameters(): + param.requires_grad = False + + def _init_noise_aug(self, config): + if config is not None: + # use the KARLO schedule for noise augmentation on CLIP image embeddings + noise_augmentor = instantiate_from_config(config) + assert isinstance(noise_augmentor, nn.Module) + noise_augmentor = noise_augmentor.eval() + noise_augmentor.train = disabled_train + self.noise_augmentor = noise_augmentor + else: + self.noise_augmentor = None + + def get_input(self, batch, k, cond_key=None, bs=None, **kwargs): + outputs = LatentDiffusion.get_input(self, batch, k, bs=bs, **kwargs) + z, c = outputs[0], outputs[1] + img = batch[self.embed_key][:bs] + img = rearrange(img, 'b h w c -> b c h w') + c_adm = self.embedder(img) + if self.noise_augmentor is not None: + c_adm, noise_level_emb = self.noise_augmentor(c_adm) + # assume this gives embeddings of noise levels + c_adm = torch.cat((c_adm, noise_level_emb), 1) + if self.training: + c_adm = torch.bernoulli((1. - self.embedding_dropout) * torch.ones(c_adm.shape[0], + device=c_adm.device)[:, None]) * c_adm + all_conds = {"c_crossattn": [c], "c_adm": c_adm} + noutputs = [z, all_conds] + noutputs.extend(outputs[2:]) + return noutputs + + @torch.no_grad() + def log_images(self, batch, N=8, n_row=4, **kwargs): + log = dict() + z, c, x, xrec, xc = self.get_input(batch, self.first_stage_key, bs=N, return_first_stage_outputs=True, + return_original_cond=True) + log["inputs"] = x + log["reconstruction"] = xrec + assert self.model.conditioning_key is not None + assert self.cond_stage_key in ["caption", "txt"] + xc = log_txt_as_img((x.shape[2], x.shape[3]), batch[self.cond_stage_key], size=x.shape[2] // 25) + log["conditioning"] = xc + uc = self.get_unconditional_conditioning(N, kwargs.get('unconditional_guidance_label', '')) + unconditional_guidance_scale = kwargs.get('unconditional_guidance_scale', 5.) + + uc_ = {"c_crossattn": [uc], "c_adm": c["c_adm"]} + ema_scope = self.ema_scope if kwargs.get('use_ema_scope', True) else nullcontext + with ema_scope(f"Sampling"): + samples_cfg, _ = self.sample_log(cond=c, batch_size=N, ddim=True, + ddim_steps=kwargs.get('ddim_steps', 50), eta=kwargs.get('ddim_eta', 0.), + unconditional_guidance_scale=unconditional_guidance_scale, + unconditional_conditioning=uc_, ) + x_samples_cfg = self.decode_first_stage(samples_cfg) + log[f"samplescfg_scale_{unconditional_guidance_scale:.2f}"] = x_samples_cfg + return log diff --git a/ldm/models/diffusion/dpm_solver/__init__.py b/ldm/models/diffusion/dpm_solver/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..7427f38c07530afbab79154ea8aaf88c4bf70a08 --- /dev/null +++ b/ldm/models/diffusion/dpm_solver/__init__.py @@ -0,0 +1 @@ +from .sampler import DPMSolverSampler \ No newline at end of file diff --git a/ldm/models/diffusion/dpm_solver/dpm_solver.py b/ldm/models/diffusion/dpm_solver/dpm_solver.py new file mode 100644 index 0000000000000000000000000000000000000000..da8d41f9c5e93d2f9e07a22aeef9aeb06d0b7dd3 --- /dev/null +++ b/ldm/models/diffusion/dpm_solver/dpm_solver.py @@ -0,0 +1,1163 @@ +import torch +import torch.nn.functional as F +import math +from tqdm import tqdm + + +class NoiseScheduleVP: + def __init__( + self, + schedule='discrete', + betas=None, + alphas_cumprod=None, + continuous_beta_0=0.1, + continuous_beta_1=20., + ): + """Create a wrapper class for the forward SDE (VP type). + *** + Update: We support discrete-time diffusion models by implementing a picewise linear interpolation for log_alpha_t. + We recommend to use schedule='discrete' for the discrete-time diffusion models, especially for high-resolution images. + *** + The forward SDE ensures that the condition distribution q_{t|0}(x_t | x_0) = N ( alpha_t * x_0, sigma_t^2 * I ). + We further define lambda_t = log(alpha_t) - log(sigma_t), which is the half-logSNR (described in the DPM-Solver paper). + Therefore, we implement the functions for computing alpha_t, sigma_t and lambda_t. For t in [0, T], we have: + log_alpha_t = self.marginal_log_mean_coeff(t) + sigma_t = self.marginal_std(t) + lambda_t = self.marginal_lambda(t) + Moreover, as lambda(t) is an invertible function, we also support its inverse function: + t = self.inverse_lambda(lambda_t) + =============================================================== + We support both discrete-time DPMs (trained on n = 0, 1, ..., N-1) and continuous-time DPMs (trained on t in [t_0, T]). + 1. For discrete-time DPMs: + For discrete-time DPMs trained on n = 0, 1, ..., N-1, we convert the discrete steps to continuous time steps by: + t_i = (i + 1) / N + e.g. for N = 1000, we have t_0 = 1e-3 and T = t_{N-1} = 1. + We solve the corresponding diffusion ODE from time T = 1 to time t_0 = 1e-3. + Args: + betas: A `torch.Tensor`. The beta array for the discrete-time DPM. (See the original DDPM paper for details) + alphas_cumprod: A `torch.Tensor`. The cumprod alphas for the discrete-time DPM. (See the original DDPM paper for details) + Note that we always have alphas_cumprod = cumprod(betas). Therefore, we only need to set one of `betas` and `alphas_cumprod`. + **Important**: Please pay special attention for the args for `alphas_cumprod`: + The `alphas_cumprod` is the \hat{alpha_n} arrays in the notations of DDPM. Specifically, DDPMs assume that + q_{t_n | 0}(x_{t_n} | x_0) = N ( \sqrt{\hat{alpha_n}} * x_0, (1 - \hat{alpha_n}) * I ). + Therefore, the notation \hat{alpha_n} is different from the notation alpha_t in DPM-Solver. In fact, we have + alpha_{t_n} = \sqrt{\hat{alpha_n}}, + and + log(alpha_{t_n}) = 0.5 * log(\hat{alpha_n}). + 2. For continuous-time DPMs: + We support two types of VPSDEs: linear (DDPM) and cosine (improved-DDPM). The hyperparameters for the noise + schedule are the default settings in DDPM and improved-DDPM: + Args: + beta_min: A `float` number. The smallest beta for the linear schedule. + beta_max: A `float` number. The largest beta for the linear schedule. + cosine_s: A `float` number. The hyperparameter in the cosine schedule. + cosine_beta_max: A `float` number. The hyperparameter in the cosine schedule. + T: A `float` number. The ending time of the forward process. + =============================================================== + Args: + schedule: A `str`. The noise schedule of the forward SDE. 'discrete' for discrete-time DPMs, + 'linear' or 'cosine' for continuous-time DPMs. + Returns: + A wrapper object of the forward SDE (VP type). + + =============================================================== + Example: + # For discrete-time DPMs, given betas (the beta array for n = 0, 1, ..., N - 1): + >>> ns = NoiseScheduleVP('discrete', betas=betas) + # For discrete-time DPMs, given alphas_cumprod (the \hat{alpha_n} array for n = 0, 1, ..., N - 1): + >>> ns = NoiseScheduleVP('discrete', alphas_cumprod=alphas_cumprod) + # For continuous-time DPMs (VPSDE), linear schedule: + >>> ns = NoiseScheduleVP('linear', continuous_beta_0=0.1, continuous_beta_1=20.) + """ + + if schedule not in ['discrete', 'linear', 'cosine']: + raise ValueError( + "Unsupported noise schedule {}. The schedule needs to be 'discrete' or 'linear' or 'cosine'".format( + schedule)) + + self.schedule = schedule + if schedule == 'discrete': + if betas is not None: + log_alphas = 0.5 * torch.log(1 - betas).cumsum(dim=0) + else: + assert alphas_cumprod is not None + log_alphas = 0.5 * torch.log(alphas_cumprod) + self.total_N = len(log_alphas) + self.T = 1. + self.t_array = torch.linspace(0., 1., self.total_N + 1)[1:].reshape((1, -1)) + self.log_alpha_array = log_alphas.reshape((1, -1,)) + else: + self.total_N = 1000 + self.beta_0 = continuous_beta_0 + self.beta_1 = continuous_beta_1 + self.cosine_s = 0.008 + self.cosine_beta_max = 999. + self.cosine_t_max = math.atan(self.cosine_beta_max * (1. + self.cosine_s) / math.pi) * 2. * ( + 1. + self.cosine_s) / math.pi - self.cosine_s + self.cosine_log_alpha_0 = math.log(math.cos(self.cosine_s / (1. + self.cosine_s) * math.pi / 2.)) + self.schedule = schedule + if schedule == 'cosine': + # For the cosine schedule, T = 1 will have numerical issues. So we manually set the ending time T. + # Note that T = 0.9946 may be not the optimal setting. However, we find it works well. + self.T = 0.9946 + else: + self.T = 1. + + def marginal_log_mean_coeff(self, t): + """ + Compute log(alpha_t) of a given continuous-time label t in [0, T]. + """ + if self.schedule == 'discrete': + return interpolate_fn(t.reshape((-1, 1)), self.t_array.to(t.device), + self.log_alpha_array.to(t.device)).reshape((-1)) + elif self.schedule == 'linear': + return -0.25 * t ** 2 * (self.beta_1 - self.beta_0) - 0.5 * t * self.beta_0 + elif self.schedule == 'cosine': + log_alpha_fn = lambda s: torch.log(torch.cos((s + self.cosine_s) / (1. + self.cosine_s) * math.pi / 2.)) + log_alpha_t = log_alpha_fn(t) - self.cosine_log_alpha_0 + return log_alpha_t + + def marginal_alpha(self, t): + """ + Compute alpha_t of a given continuous-time label t in [0, T]. + """ + return torch.exp(self.marginal_log_mean_coeff(t)) + + def marginal_std(self, t): + """ + Compute sigma_t of a given continuous-time label t in [0, T]. + """ + return torch.sqrt(1. - torch.exp(2. * self.marginal_log_mean_coeff(t))) + + def marginal_lambda(self, t): + """ + Compute lambda_t = log(alpha_t) - log(sigma_t) of a given continuous-time label t in [0, T]. + """ + log_mean_coeff = self.marginal_log_mean_coeff(t) + log_std = 0.5 * torch.log(1. - torch.exp(2. * log_mean_coeff)) + return log_mean_coeff - log_std + + def inverse_lambda(self, lamb): + """ + Compute the continuous-time label t in [0, T] of a given half-logSNR lambda_t. + """ + if self.schedule == 'linear': + tmp = 2. * (self.beta_1 - self.beta_0) * torch.logaddexp(-2. * lamb, torch.zeros((1,)).to(lamb)) + Delta = self.beta_0 ** 2 + tmp + return tmp / (torch.sqrt(Delta) + self.beta_0) / (self.beta_1 - self.beta_0) + elif self.schedule == 'discrete': + log_alpha = -0.5 * torch.logaddexp(torch.zeros((1,)).to(lamb.device), -2. * lamb) + t = interpolate_fn(log_alpha.reshape((-1, 1)), torch.flip(self.log_alpha_array.to(lamb.device), [1]), + torch.flip(self.t_array.to(lamb.device), [1])) + return t.reshape((-1,)) + else: + log_alpha = -0.5 * torch.logaddexp(-2. * lamb, torch.zeros((1,)).to(lamb)) + t_fn = lambda log_alpha_t: torch.arccos(torch.exp(log_alpha_t + self.cosine_log_alpha_0)) * 2. * ( + 1. + self.cosine_s) / math.pi - self.cosine_s + t = t_fn(log_alpha) + return t + + +def model_wrapper( + model, + noise_schedule, + model_type="noise", + model_kwargs={}, + guidance_type="uncond", + condition=None, + unconditional_condition=None, + guidance_scale=1., + classifier_fn=None, + classifier_kwargs={}, +): + """Create a wrapper function for the noise prediction model. + DPM-Solver needs to solve the continuous-time diffusion ODEs. For DPMs trained on discrete-time labels, we need to + firstly wrap the model function to a noise prediction model that accepts the continuous time as the input. + We support four types of the diffusion model by setting `model_type`: + 1. "noise": noise prediction model. (Trained by predicting noise). + 2. "x_start": data prediction model. (Trained by predicting the data x_0 at time 0). + 3. "v": velocity prediction model. (Trained by predicting the velocity). + The "v" prediction is derivation detailed in Appendix D of [1], and is used in Imagen-Video [2]. + [1] Salimans, Tim, and Jonathan Ho. "Progressive distillation for fast sampling of diffusion models." + arXiv preprint arXiv:2202.00512 (2022). + [2] Ho, Jonathan, et al. "Imagen Video: High Definition Video Generation with Diffusion Models." + arXiv preprint arXiv:2210.02303 (2022). + + 4. "score": marginal score function. (Trained by denoising score matching). + Note that the score function and the noise prediction model follows a simple relationship: + ``` + noise(x_t, t) = -sigma_t * score(x_t, t) + ``` + We support three types of guided sampling by DPMs by setting `guidance_type`: + 1. "uncond": unconditional sampling by DPMs. + The input `model` has the following format: + `` + model(x, t_input, **model_kwargs) -> noise | x_start | v | score + `` + 2. "classifier": classifier guidance sampling [3] by DPMs and another classifier. + The input `model` has the following format: + `` + model(x, t_input, **model_kwargs) -> noise | x_start | v | score + `` + The input `classifier_fn` has the following format: + `` + classifier_fn(x, t_input, cond, **classifier_kwargs) -> logits(x, t_input, cond) + `` + [3] P. Dhariwal and A. Q. Nichol, "Diffusion models beat GANs on image synthesis," + in Advances in Neural Information Processing Systems, vol. 34, 2021, pp. 8780-8794. + 3. "classifier-free": classifier-free guidance sampling by conditional DPMs. + The input `model` has the following format: + `` + model(x, t_input, cond, **model_kwargs) -> noise | x_start | v | score + `` + And if cond == `unconditional_condition`, the model output is the unconditional DPM output. + [4] Ho, Jonathan, and Tim Salimans. "Classifier-free diffusion guidance." + arXiv preprint arXiv:2207.12598 (2022). + + The `t_input` is the time label of the model, which may be discrete-time labels (i.e. 0 to 999) + or continuous-time labels (i.e. epsilon to T). + We wrap the model function to accept only `x` and `t_continuous` as inputs, and outputs the predicted noise: + `` + def model_fn(x, t_continuous) -> noise: + t_input = get_model_input_time(t_continuous) + return noise_pred(model, x, t_input, **model_kwargs) + `` + where `t_continuous` is the continuous time labels (i.e. epsilon to T). And we use `model_fn` for DPM-Solver. + =============================================================== + Args: + model: A diffusion model with the corresponding format described above. + noise_schedule: A noise schedule object, such as NoiseScheduleVP. + model_type: A `str`. The parameterization type of the diffusion model. + "noise" or "x_start" or "v" or "score". + model_kwargs: A `dict`. A dict for the other inputs of the model function. + guidance_type: A `str`. The type of the guidance for sampling. + "uncond" or "classifier" or "classifier-free". + condition: A pytorch tensor. The condition for the guided sampling. + Only used for "classifier" or "classifier-free" guidance type. + unconditional_condition: A pytorch tensor. The condition for the unconditional sampling. + Only used for "classifier-free" guidance type. + guidance_scale: A `float`. The scale for the guided sampling. + classifier_fn: A classifier function. Only used for the classifier guidance. + classifier_kwargs: A `dict`. A dict for the other inputs of the classifier function. + Returns: + A noise prediction model that accepts the noised data and the continuous time as the inputs. + """ + + def get_model_input_time(t_continuous): + """ + Convert the continuous-time `t_continuous` (in [epsilon, T]) to the model input time. + For discrete-time DPMs, we convert `t_continuous` in [1 / N, 1] to `t_input` in [0, 1000 * (N - 1) / N]. + For continuous-time DPMs, we just use `t_continuous`. + """ + if noise_schedule.schedule == 'discrete': + return (t_continuous - 1. / noise_schedule.total_N) * 1000. + else: + return t_continuous + + def noise_pred_fn(x, t_continuous, cond=None): + if t_continuous.reshape((-1,)).shape[0] == 1: + t_continuous = t_continuous.expand((x.shape[0])) + t_input = get_model_input_time(t_continuous) + if cond is None: + output = model(x, t_input, **model_kwargs) + else: + output = model(x, t_input, cond, **model_kwargs) + if model_type == "noise": + return output + elif model_type == "x_start": + alpha_t, sigma_t = noise_schedule.marginal_alpha(t_continuous), noise_schedule.marginal_std(t_continuous) + dims = x.dim() + return (x - expand_dims(alpha_t, dims) * output) / expand_dims(sigma_t, dims) + elif model_type == "v": + alpha_t, sigma_t = noise_schedule.marginal_alpha(t_continuous), noise_schedule.marginal_std(t_continuous) + dims = x.dim() + return expand_dims(alpha_t, dims) * output + expand_dims(sigma_t, dims) * x + elif model_type == "score": + sigma_t = noise_schedule.marginal_std(t_continuous) + dims = x.dim() + return -expand_dims(sigma_t, dims) * output + + def cond_grad_fn(x, t_input): + """ + Compute the gradient of the classifier, i.e. nabla_{x} log p_t(cond | x_t). + """ + with torch.enable_grad(): + x_in = x.detach().requires_grad_(True) + log_prob = classifier_fn(x_in, t_input, condition, **classifier_kwargs) + return torch.autograd.grad(log_prob.sum(), x_in)[0] + + def model_fn(x, t_continuous): + """ + The noise predicition model function that is used for DPM-Solver. + """ + if t_continuous.reshape((-1,)).shape[0] == 1: + t_continuous = t_continuous.expand((x.shape[0])) + if guidance_type == "uncond": + return noise_pred_fn(x, t_continuous) + elif guidance_type == "classifier": + assert classifier_fn is not None + t_input = get_model_input_time(t_continuous) + cond_grad = cond_grad_fn(x, t_input) + sigma_t = noise_schedule.marginal_std(t_continuous) + noise = noise_pred_fn(x, t_continuous) + return noise - guidance_scale * expand_dims(sigma_t, dims=cond_grad.dim()) * cond_grad + elif guidance_type == "classifier-free": + if guidance_scale == 1. or unconditional_condition is None: + return noise_pred_fn(x, t_continuous, cond=condition) + else: + x_in = torch.cat([x] * 2) + t_in = torch.cat([t_continuous] * 2) + if isinstance(condition, dict): + assert isinstance(unconditional_condition, dict) + c_in = dict() + for k in condition: + if isinstance(condition[k], list): + c_in[k] = [torch.cat([unconditional_condition[k][i], condition[k][i]]) for i in range(len(condition[k]))] + else: + c_in[k] = torch.cat([unconditional_condition[k], condition[k]]) + else: + c_in = torch.cat([unconditional_condition, condition]) + noise_uncond, noise = noise_pred_fn(x_in, t_in, cond=c_in).chunk(2) + return noise_uncond + guidance_scale * (noise - noise_uncond) + + assert model_type in ["noise", "x_start", "v"] + assert guidance_type in ["uncond", "classifier", "classifier-free"] + return model_fn + + +class DPM_Solver: + def __init__(self, model_fn, noise_schedule, predict_x0=False, thresholding=False, max_val=1.): + """Construct a DPM-Solver. + We support both the noise prediction model ("predicting epsilon") and the data prediction model ("predicting x0"). + If `predict_x0` is False, we use the solver for the noise prediction model (DPM-Solver). + If `predict_x0` is True, we use the solver for the data prediction model (DPM-Solver++). + In such case, we further support the "dynamic thresholding" in [1] when `thresholding` is True. + The "dynamic thresholding" can greatly improve the sample quality for pixel-space DPMs with large guidance scales. + Args: + model_fn: A noise prediction model function which accepts the continuous-time input (t in [epsilon, T]): + `` + def model_fn(x, t_continuous): + return noise + `` + noise_schedule: A noise schedule object, such as NoiseScheduleVP. + predict_x0: A `bool`. If true, use the data prediction model; else, use the noise prediction model. + thresholding: A `bool`. Valid when `predict_x0` is True. Whether to use the "dynamic thresholding" in [1]. + max_val: A `float`. Valid when both `predict_x0` and `thresholding` are True. The max value for thresholding. + + [1] Chitwan Saharia, William Chan, Saurabh Saxena, Lala Li, Jay Whang, Emily Denton, Seyed Kamyar Seyed Ghasemipour, Burcu Karagol Ayan, S Sara Mahdavi, Rapha Gontijo Lopes, et al. Photorealistic text-to-image diffusion models with deep language understanding. arXiv preprint arXiv:2205.11487, 2022b. + """ + self.model = model_fn + self.noise_schedule = noise_schedule + self.predict_x0 = predict_x0 + self.thresholding = thresholding + self.max_val = max_val + + def noise_prediction_fn(self, x, t): + """ + Return the noise prediction model. + """ + return self.model(x, t) + + def data_prediction_fn(self, x, t): + """ + Return the data prediction model (with thresholding). + """ + noise = self.noise_prediction_fn(x, t) + dims = x.dim() + alpha_t, sigma_t = self.noise_schedule.marginal_alpha(t), self.noise_schedule.marginal_std(t) + x0 = (x - expand_dims(sigma_t, dims) * noise) / expand_dims(alpha_t, dims) + if self.thresholding: + p = 0.995 # A hyperparameter in the paper of "Imagen" [1]. + s = torch.quantile(torch.abs(x0).reshape((x0.shape[0], -1)), p, dim=1) + s = expand_dims(torch.maximum(s, self.max_val * torch.ones_like(s).to(s.device)), dims) + x0 = torch.clamp(x0, -s, s) / s + return x0 + + def model_fn(self, x, t): + """ + Convert the model to the noise prediction model or the data prediction model. + """ + if self.predict_x0: + return self.data_prediction_fn(x, t) + else: + return self.noise_prediction_fn(x, t) + + def get_time_steps(self, skip_type, t_T, t_0, N, device): + """Compute the intermediate time steps for sampling. + Args: + skip_type: A `str`. The type for the spacing of the time steps. We support three types: + - 'logSNR': uniform logSNR for the time steps. + - 'time_uniform': uniform time for the time steps. (**Recommended for high-resolutional data**.) + - 'time_quadratic': quadratic time for the time steps. (Used in DDIM for low-resolutional data.) + t_T: A `float`. The starting time of the sampling (default is T). + t_0: A `float`. The ending time of the sampling (default is epsilon). + N: A `int`. The total number of the spacing of the time steps. + device: A torch device. + Returns: + A pytorch tensor of the time steps, with the shape (N + 1,). + """ + if skip_type == 'logSNR': + lambda_T = self.noise_schedule.marginal_lambda(torch.tensor(t_T).to(device)) + lambda_0 = self.noise_schedule.marginal_lambda(torch.tensor(t_0).to(device)) + logSNR_steps = torch.linspace(lambda_T.cpu().item(), lambda_0.cpu().item(), N + 1).to(device) + return self.noise_schedule.inverse_lambda(logSNR_steps) + elif skip_type == 'time_uniform': + return torch.linspace(t_T, t_0, N + 1).to(device) + elif skip_type == 'time_quadratic': + t_order = 2 + t = torch.linspace(t_T ** (1. / t_order), t_0 ** (1. / t_order), N + 1).pow(t_order).to(device) + return t + else: + raise ValueError( + "Unsupported skip_type {}, need to be 'logSNR' or 'time_uniform' or 'time_quadratic'".format(skip_type)) + + def get_orders_and_timesteps_for_singlestep_solver(self, steps, order, skip_type, t_T, t_0, device): + """ + Get the order of each step for sampling by the singlestep DPM-Solver. + We combine both DPM-Solver-1,2,3 to use all the function evaluations, which is named as "DPM-Solver-fast". + Given a fixed number of function evaluations by `steps`, the sampling procedure by DPM-Solver-fast is: + - If order == 1: + We take `steps` of DPM-Solver-1 (i.e. DDIM). + - If order == 2: + - Denote K = (steps // 2). We take K or (K + 1) intermediate time steps for sampling. + - If steps % 2 == 0, we use K steps of DPM-Solver-2. + - If steps % 2 == 1, we use K steps of DPM-Solver-2 and 1 step of DPM-Solver-1. + - If order == 3: + - Denote K = (steps // 3 + 1). We take K intermediate time steps for sampling. + - If steps % 3 == 0, we use (K - 2) steps of DPM-Solver-3, and 1 step of DPM-Solver-2 and 1 step of DPM-Solver-1. + - If steps % 3 == 1, we use (K - 1) steps of DPM-Solver-3 and 1 step of DPM-Solver-1. + - If steps % 3 == 2, we use (K - 1) steps of DPM-Solver-3 and 1 step of DPM-Solver-2. + ============================================ + Args: + order: A `int`. The max order for the solver (2 or 3). + steps: A `int`. The total number of function evaluations (NFE). + skip_type: A `str`. The type for the spacing of the time steps. We support three types: + - 'logSNR': uniform logSNR for the time steps. + - 'time_uniform': uniform time for the time steps. (**Recommended for high-resolutional data**.) + - 'time_quadratic': quadratic time for the time steps. (Used in DDIM for low-resolutional data.) + t_T: A `float`. The starting time of the sampling (default is T). + t_0: A `float`. The ending time of the sampling (default is epsilon). + device: A torch device. + Returns: + orders: A list of the solver order of each step. + """ + if order == 3: + K = steps // 3 + 1 + if steps % 3 == 0: + orders = [3, ] * (K - 2) + [2, 1] + elif steps % 3 == 1: + orders = [3, ] * (K - 1) + [1] + else: + orders = [3, ] * (K - 1) + [2] + elif order == 2: + if steps % 2 == 0: + K = steps // 2 + orders = [2, ] * K + else: + K = steps // 2 + 1 + orders = [2, ] * (K - 1) + [1] + elif order == 1: + K = 1 + orders = [1, ] * steps + else: + raise ValueError("'order' must be '1' or '2' or '3'.") + if skip_type == 'logSNR': + # To reproduce the results in DPM-Solver paper + timesteps_outer = self.get_time_steps(skip_type, t_T, t_0, K, device) + else: + timesteps_outer = self.get_time_steps(skip_type, t_T, t_0, steps, device)[ + torch.cumsum(torch.tensor([0, ] + orders)).to(device)] + return timesteps_outer, orders + + def denoise_to_zero_fn(self, x, s): + """ + Denoise at the final step, which is equivalent to solve the ODE from lambda_s to infty by first-order discretization. + """ + return self.data_prediction_fn(x, s) + + def dpm_solver_first_update(self, x, s, t, model_s=None, return_intermediate=False): + """ + DPM-Solver-1 (equivalent to DDIM) from time `s` to time `t`. + Args: + x: A pytorch tensor. The initial value at time `s`. + s: A pytorch tensor. The starting time, with the shape (x.shape[0],). + t: A pytorch tensor. The ending time, with the shape (x.shape[0],). + model_s: A pytorch tensor. The model function evaluated at time `s`. + If `model_s` is None, we evaluate the model by `x` and `s`; otherwise we directly use it. + return_intermediate: A `bool`. If true, also return the model value at time `s`. + Returns: + x_t: A pytorch tensor. The approximated solution at time `t`. + """ + ns = self.noise_schedule + dims = x.dim() + lambda_s, lambda_t = ns.marginal_lambda(s), ns.marginal_lambda(t) + h = lambda_t - lambda_s + log_alpha_s, log_alpha_t = ns.marginal_log_mean_coeff(s), ns.marginal_log_mean_coeff(t) + sigma_s, sigma_t = ns.marginal_std(s), ns.marginal_std(t) + alpha_t = torch.exp(log_alpha_t) + + if self.predict_x0: + phi_1 = torch.expm1(-h) + if model_s is None: + model_s = self.model_fn(x, s) + x_t = ( + expand_dims(sigma_t / sigma_s, dims) * x + - expand_dims(alpha_t * phi_1, dims) * model_s + ) + if return_intermediate: + return x_t, {'model_s': model_s} + else: + return x_t + else: + phi_1 = torch.expm1(h) + if model_s is None: + model_s = self.model_fn(x, s) + x_t = ( + expand_dims(torch.exp(log_alpha_t - log_alpha_s), dims) * x + - expand_dims(sigma_t * phi_1, dims) * model_s + ) + if return_intermediate: + return x_t, {'model_s': model_s} + else: + return x_t + + def singlestep_dpm_solver_second_update(self, x, s, t, r1=0.5, model_s=None, return_intermediate=False, + solver_type='dpm_solver'): + """ + Singlestep solver DPM-Solver-2 from time `s` to time `t`. + Args: + x: A pytorch tensor. The initial value at time `s`. + s: A pytorch tensor. The starting time, with the shape (x.shape[0],). + t: A pytorch tensor. The ending time, with the shape (x.shape[0],). + r1: A `float`. The hyperparameter of the second-order solver. + model_s: A pytorch tensor. The model function evaluated at time `s`. + If `model_s` is None, we evaluate the model by `x` and `s`; otherwise we directly use it. + return_intermediate: A `bool`. If true, also return the model value at time `s` and `s1` (the intermediate time). + solver_type: either 'dpm_solver' or 'taylor'. The type for the high-order solvers. + The type slightly impacts the performance. We recommend to use 'dpm_solver' type. + Returns: + x_t: A pytorch tensor. The approximated solution at time `t`. + """ + if solver_type not in ['dpm_solver', 'taylor']: + raise ValueError("'solver_type' must be either 'dpm_solver' or 'taylor', got {}".format(solver_type)) + if r1 is None: + r1 = 0.5 + ns = self.noise_schedule + dims = x.dim() + lambda_s, lambda_t = ns.marginal_lambda(s), ns.marginal_lambda(t) + h = lambda_t - lambda_s + lambda_s1 = lambda_s + r1 * h + s1 = ns.inverse_lambda(lambda_s1) + log_alpha_s, log_alpha_s1, log_alpha_t = ns.marginal_log_mean_coeff(s), ns.marginal_log_mean_coeff( + s1), ns.marginal_log_mean_coeff(t) + sigma_s, sigma_s1, sigma_t = ns.marginal_std(s), ns.marginal_std(s1), ns.marginal_std(t) + alpha_s1, alpha_t = torch.exp(log_alpha_s1), torch.exp(log_alpha_t) + + if self.predict_x0: + phi_11 = torch.expm1(-r1 * h) + phi_1 = torch.expm1(-h) + + if model_s is None: + model_s = self.model_fn(x, s) + x_s1 = ( + expand_dims(sigma_s1 / sigma_s, dims) * x + - expand_dims(alpha_s1 * phi_11, dims) * model_s + ) + model_s1 = self.model_fn(x_s1, s1) + if solver_type == 'dpm_solver': + x_t = ( + expand_dims(sigma_t / sigma_s, dims) * x + - expand_dims(alpha_t * phi_1, dims) * model_s + - (0.5 / r1) * expand_dims(alpha_t * phi_1, dims) * (model_s1 - model_s) + ) + elif solver_type == 'taylor': + x_t = ( + expand_dims(sigma_t / sigma_s, dims) * x + - expand_dims(alpha_t * phi_1, dims) * model_s + + (1. / r1) * expand_dims(alpha_t * ((torch.exp(-h) - 1.) / h + 1.), dims) * ( + model_s1 - model_s) + ) + else: + phi_11 = torch.expm1(r1 * h) + phi_1 = torch.expm1(h) + + if model_s is None: + model_s = self.model_fn(x, s) + x_s1 = ( + expand_dims(torch.exp(log_alpha_s1 - log_alpha_s), dims) * x + - expand_dims(sigma_s1 * phi_11, dims) * model_s + ) + model_s1 = self.model_fn(x_s1, s1) + if solver_type == 'dpm_solver': + x_t = ( + expand_dims(torch.exp(log_alpha_t - log_alpha_s), dims) * x + - expand_dims(sigma_t * phi_1, dims) * model_s + - (0.5 / r1) * expand_dims(sigma_t * phi_1, dims) * (model_s1 - model_s) + ) + elif solver_type == 'taylor': + x_t = ( + expand_dims(torch.exp(log_alpha_t - log_alpha_s), dims) * x + - expand_dims(sigma_t * phi_1, dims) * model_s + - (1. / r1) * expand_dims(sigma_t * ((torch.exp(h) - 1.) / h - 1.), dims) * (model_s1 - model_s) + ) + if return_intermediate: + return x_t, {'model_s': model_s, 'model_s1': model_s1} + else: + return x_t + + def singlestep_dpm_solver_third_update(self, x, s, t, r1=1. / 3., r2=2. / 3., model_s=None, model_s1=None, + return_intermediate=False, solver_type='dpm_solver'): + """ + Singlestep solver DPM-Solver-3 from time `s` to time `t`. + Args: + x: A pytorch tensor. The initial value at time `s`. + s: A pytorch tensor. The starting time, with the shape (x.shape[0],). + t: A pytorch tensor. The ending time, with the shape (x.shape[0],). + r1: A `float`. The hyperparameter of the third-order solver. + r2: A `float`. The hyperparameter of the third-order solver. + model_s: A pytorch tensor. The model function evaluated at time `s`. + If `model_s` is None, we evaluate the model by `x` and `s`; otherwise we directly use it. + model_s1: A pytorch tensor. The model function evaluated at time `s1` (the intermediate time given by `r1`). + If `model_s1` is None, we evaluate the model at `s1`; otherwise we directly use it. + return_intermediate: A `bool`. If true, also return the model value at time `s`, `s1` and `s2` (the intermediate times). + solver_type: either 'dpm_solver' or 'taylor'. The type for the high-order solvers. + The type slightly impacts the performance. We recommend to use 'dpm_solver' type. + Returns: + x_t: A pytorch tensor. The approximated solution at time `t`. + """ + if solver_type not in ['dpm_solver', 'taylor']: + raise ValueError("'solver_type' must be either 'dpm_solver' or 'taylor', got {}".format(solver_type)) + if r1 is None: + r1 = 1. / 3. + if r2 is None: + r2 = 2. / 3. + ns = self.noise_schedule + dims = x.dim() + lambda_s, lambda_t = ns.marginal_lambda(s), ns.marginal_lambda(t) + h = lambda_t - lambda_s + lambda_s1 = lambda_s + r1 * h + lambda_s2 = lambda_s + r2 * h + s1 = ns.inverse_lambda(lambda_s1) + s2 = ns.inverse_lambda(lambda_s2) + log_alpha_s, log_alpha_s1, log_alpha_s2, log_alpha_t = ns.marginal_log_mean_coeff( + s), ns.marginal_log_mean_coeff(s1), ns.marginal_log_mean_coeff(s2), ns.marginal_log_mean_coeff(t) + sigma_s, sigma_s1, sigma_s2, sigma_t = ns.marginal_std(s), ns.marginal_std(s1), ns.marginal_std( + s2), ns.marginal_std(t) + alpha_s1, alpha_s2, alpha_t = torch.exp(log_alpha_s1), torch.exp(log_alpha_s2), torch.exp(log_alpha_t) + + if self.predict_x0: + phi_11 = torch.expm1(-r1 * h) + phi_12 = torch.expm1(-r2 * h) + phi_1 = torch.expm1(-h) + phi_22 = torch.expm1(-r2 * h) / (r2 * h) + 1. + phi_2 = phi_1 / h + 1. + phi_3 = phi_2 / h - 0.5 + + if model_s is None: + model_s = self.model_fn(x, s) + if model_s1 is None: + x_s1 = ( + expand_dims(sigma_s1 / sigma_s, dims) * x + - expand_dims(alpha_s1 * phi_11, dims) * model_s + ) + model_s1 = self.model_fn(x_s1, s1) + x_s2 = ( + expand_dims(sigma_s2 / sigma_s, dims) * x + - expand_dims(alpha_s2 * phi_12, dims) * model_s + + r2 / r1 * expand_dims(alpha_s2 * phi_22, dims) * (model_s1 - model_s) + ) + model_s2 = self.model_fn(x_s2, s2) + if solver_type == 'dpm_solver': + x_t = ( + expand_dims(sigma_t / sigma_s, dims) * x + - expand_dims(alpha_t * phi_1, dims) * model_s + + (1. / r2) * expand_dims(alpha_t * phi_2, dims) * (model_s2 - model_s) + ) + elif solver_type == 'taylor': + D1_0 = (1. / r1) * (model_s1 - model_s) + D1_1 = (1. / r2) * (model_s2 - model_s) + D1 = (r2 * D1_0 - r1 * D1_1) / (r2 - r1) + D2 = 2. * (D1_1 - D1_0) / (r2 - r1) + x_t = ( + expand_dims(sigma_t / sigma_s, dims) * x + - expand_dims(alpha_t * phi_1, dims) * model_s + + expand_dims(alpha_t * phi_2, dims) * D1 + - expand_dims(alpha_t * phi_3, dims) * D2 + ) + else: + phi_11 = torch.expm1(r1 * h) + phi_12 = torch.expm1(r2 * h) + phi_1 = torch.expm1(h) + phi_22 = torch.expm1(r2 * h) / (r2 * h) - 1. + phi_2 = phi_1 / h - 1. + phi_3 = phi_2 / h - 0.5 + + if model_s is None: + model_s = self.model_fn(x, s) + if model_s1 is None: + x_s1 = ( + expand_dims(torch.exp(log_alpha_s1 - log_alpha_s), dims) * x + - expand_dims(sigma_s1 * phi_11, dims) * model_s + ) + model_s1 = self.model_fn(x_s1, s1) + x_s2 = ( + expand_dims(torch.exp(log_alpha_s2 - log_alpha_s), dims) * x + - expand_dims(sigma_s2 * phi_12, dims) * model_s + - r2 / r1 * expand_dims(sigma_s2 * phi_22, dims) * (model_s1 - model_s) + ) + model_s2 = self.model_fn(x_s2, s2) + if solver_type == 'dpm_solver': + x_t = ( + expand_dims(torch.exp(log_alpha_t - log_alpha_s), dims) * x + - expand_dims(sigma_t * phi_1, dims) * model_s + - (1. / r2) * expand_dims(sigma_t * phi_2, dims) * (model_s2 - model_s) + ) + elif solver_type == 'taylor': + D1_0 = (1. / r1) * (model_s1 - model_s) + D1_1 = (1. / r2) * (model_s2 - model_s) + D1 = (r2 * D1_0 - r1 * D1_1) / (r2 - r1) + D2 = 2. * (D1_1 - D1_0) / (r2 - r1) + x_t = ( + expand_dims(torch.exp(log_alpha_t - log_alpha_s), dims) * x + - expand_dims(sigma_t * phi_1, dims) * model_s + - expand_dims(sigma_t * phi_2, dims) * D1 + - expand_dims(sigma_t * phi_3, dims) * D2 + ) + + if return_intermediate: + return x_t, {'model_s': model_s, 'model_s1': model_s1, 'model_s2': model_s2} + else: + return x_t + + def multistep_dpm_solver_second_update(self, x, model_prev_list, t_prev_list, t, solver_type="dpm_solver"): + """ + Multistep solver DPM-Solver-2 from time `t_prev_list[-1]` to time `t`. + Args: + x: A pytorch tensor. The initial value at time `s`. + model_prev_list: A list of pytorch tensor. The previous computed model values. + t_prev_list: A list of pytorch tensor. The previous times, each time has the shape (x.shape[0],) + t: A pytorch tensor. The ending time, with the shape (x.shape[0],). + solver_type: either 'dpm_solver' or 'taylor'. The type for the high-order solvers. + The type slightly impacts the performance. We recommend to use 'dpm_solver' type. + Returns: + x_t: A pytorch tensor. The approximated solution at time `t`. + """ + if solver_type not in ['dpm_solver', 'taylor']: + raise ValueError("'solver_type' must be either 'dpm_solver' or 'taylor', got {}".format(solver_type)) + ns = self.noise_schedule + dims = x.dim() + model_prev_1, model_prev_0 = model_prev_list + t_prev_1, t_prev_0 = t_prev_list + lambda_prev_1, lambda_prev_0, lambda_t = ns.marginal_lambda(t_prev_1), ns.marginal_lambda( + t_prev_0), ns.marginal_lambda(t) + log_alpha_prev_0, log_alpha_t = ns.marginal_log_mean_coeff(t_prev_0), ns.marginal_log_mean_coeff(t) + sigma_prev_0, sigma_t = ns.marginal_std(t_prev_0), ns.marginal_std(t) + alpha_t = torch.exp(log_alpha_t) + + h_0 = lambda_prev_0 - lambda_prev_1 + h = lambda_t - lambda_prev_0 + r0 = h_0 / h + D1_0 = expand_dims(1. / r0, dims) * (model_prev_0 - model_prev_1) + if self.predict_x0: + if solver_type == 'dpm_solver': + x_t = ( + expand_dims(sigma_t / sigma_prev_0, dims) * x + - expand_dims(alpha_t * (torch.exp(-h) - 1.), dims) * model_prev_0 + - 0.5 * expand_dims(alpha_t * (torch.exp(-h) - 1.), dims) * D1_0 + ) + elif solver_type == 'taylor': + x_t = ( + expand_dims(sigma_t / sigma_prev_0, dims) * x + - expand_dims(alpha_t * (torch.exp(-h) - 1.), dims) * model_prev_0 + + expand_dims(alpha_t * ((torch.exp(-h) - 1.) / h + 1.), dims) * D1_0 + ) + else: + if solver_type == 'dpm_solver': + x_t = ( + expand_dims(torch.exp(log_alpha_t - log_alpha_prev_0), dims) * x + - expand_dims(sigma_t * (torch.exp(h) - 1.), dims) * model_prev_0 + - 0.5 * expand_dims(sigma_t * (torch.exp(h) - 1.), dims) * D1_0 + ) + elif solver_type == 'taylor': + x_t = ( + expand_dims(torch.exp(log_alpha_t - log_alpha_prev_0), dims) * x + - expand_dims(sigma_t * (torch.exp(h) - 1.), dims) * model_prev_0 + - expand_dims(sigma_t * ((torch.exp(h) - 1.) / h - 1.), dims) * D1_0 + ) + return x_t + + def multistep_dpm_solver_third_update(self, x, model_prev_list, t_prev_list, t, solver_type='dpm_solver'): + """ + Multistep solver DPM-Solver-3 from time `t_prev_list[-1]` to time `t`. + Args: + x: A pytorch tensor. The initial value at time `s`. + model_prev_list: A list of pytorch tensor. The previous computed model values. + t_prev_list: A list of pytorch tensor. The previous times, each time has the shape (x.shape[0],) + t: A pytorch tensor. The ending time, with the shape (x.shape[0],). + solver_type: either 'dpm_solver' or 'taylor'. The type for the high-order solvers. + The type slightly impacts the performance. We recommend to use 'dpm_solver' type. + Returns: + x_t: A pytorch tensor. The approximated solution at time `t`. + """ + ns = self.noise_schedule + dims = x.dim() + model_prev_2, model_prev_1, model_prev_0 = model_prev_list + t_prev_2, t_prev_1, t_prev_0 = t_prev_list + lambda_prev_2, lambda_prev_1, lambda_prev_0, lambda_t = ns.marginal_lambda(t_prev_2), ns.marginal_lambda( + t_prev_1), ns.marginal_lambda(t_prev_0), ns.marginal_lambda(t) + log_alpha_prev_0, log_alpha_t = ns.marginal_log_mean_coeff(t_prev_0), ns.marginal_log_mean_coeff(t) + sigma_prev_0, sigma_t = ns.marginal_std(t_prev_0), ns.marginal_std(t) + alpha_t = torch.exp(log_alpha_t) + + h_1 = lambda_prev_1 - lambda_prev_2 + h_0 = lambda_prev_0 - lambda_prev_1 + h = lambda_t - lambda_prev_0 + r0, r1 = h_0 / h, h_1 / h + D1_0 = expand_dims(1. / r0, dims) * (model_prev_0 - model_prev_1) + D1_1 = expand_dims(1. / r1, dims) * (model_prev_1 - model_prev_2) + D1 = D1_0 + expand_dims(r0 / (r0 + r1), dims) * (D1_0 - D1_1) + D2 = expand_dims(1. / (r0 + r1), dims) * (D1_0 - D1_1) + if self.predict_x0: + x_t = ( + expand_dims(sigma_t / sigma_prev_0, dims) * x + - expand_dims(alpha_t * (torch.exp(-h) - 1.), dims) * model_prev_0 + + expand_dims(alpha_t * ((torch.exp(-h) - 1.) / h + 1.), dims) * D1 + - expand_dims(alpha_t * ((torch.exp(-h) - 1. + h) / h ** 2 - 0.5), dims) * D2 + ) + else: + x_t = ( + expand_dims(torch.exp(log_alpha_t - log_alpha_prev_0), dims) * x + - expand_dims(sigma_t * (torch.exp(h) - 1.), dims) * model_prev_0 + - expand_dims(sigma_t * ((torch.exp(h) - 1.) / h - 1.), dims) * D1 + - expand_dims(sigma_t * ((torch.exp(h) - 1. - h) / h ** 2 - 0.5), dims) * D2 + ) + return x_t + + def singlestep_dpm_solver_update(self, x, s, t, order, return_intermediate=False, solver_type='dpm_solver', r1=None, + r2=None): + """ + Singlestep DPM-Solver with the order `order` from time `s` to time `t`. + Args: + x: A pytorch tensor. The initial value at time `s`. + s: A pytorch tensor. The starting time, with the shape (x.shape[0],). + t: A pytorch tensor. The ending time, with the shape (x.shape[0],). + order: A `int`. The order of DPM-Solver. We only support order == 1 or 2 or 3. + return_intermediate: A `bool`. If true, also return the model value at time `s`, `s1` and `s2` (the intermediate times). + solver_type: either 'dpm_solver' or 'taylor'. The type for the high-order solvers. + The type slightly impacts the performance. We recommend to use 'dpm_solver' type. + r1: A `float`. The hyperparameter of the second-order or third-order solver. + r2: A `float`. The hyperparameter of the third-order solver. + Returns: + x_t: A pytorch tensor. The approximated solution at time `t`. + """ + if order == 1: + return self.dpm_solver_first_update(x, s, t, return_intermediate=return_intermediate) + elif order == 2: + return self.singlestep_dpm_solver_second_update(x, s, t, return_intermediate=return_intermediate, + solver_type=solver_type, r1=r1) + elif order == 3: + return self.singlestep_dpm_solver_third_update(x, s, t, return_intermediate=return_intermediate, + solver_type=solver_type, r1=r1, r2=r2) + else: + raise ValueError("Solver order must be 1 or 2 or 3, got {}".format(order)) + + def multistep_dpm_solver_update(self, x, model_prev_list, t_prev_list, t, order, solver_type='dpm_solver'): + """ + Multistep DPM-Solver with the order `order` from time `t_prev_list[-1]` to time `t`. + Args: + x: A pytorch tensor. The initial value at time `s`. + model_prev_list: A list of pytorch tensor. The previous computed model values. + t_prev_list: A list of pytorch tensor. The previous times, each time has the shape (x.shape[0],) + t: A pytorch tensor. The ending time, with the shape (x.shape[0],). + order: A `int`. The order of DPM-Solver. We only support order == 1 or 2 or 3. + solver_type: either 'dpm_solver' or 'taylor'. The type for the high-order solvers. + The type slightly impacts the performance. We recommend to use 'dpm_solver' type. + Returns: + x_t: A pytorch tensor. The approximated solution at time `t`. + """ + if order == 1: + return self.dpm_solver_first_update(x, t_prev_list[-1], t, model_s=model_prev_list[-1]) + elif order == 2: + return self.multistep_dpm_solver_second_update(x, model_prev_list, t_prev_list, t, solver_type=solver_type) + elif order == 3: + return self.multistep_dpm_solver_third_update(x, model_prev_list, t_prev_list, t, solver_type=solver_type) + else: + raise ValueError("Solver order must be 1 or 2 or 3, got {}".format(order)) + + def dpm_solver_adaptive(self, x, order, t_T, t_0, h_init=0.05, atol=0.0078, rtol=0.05, theta=0.9, t_err=1e-5, + solver_type='dpm_solver'): + """ + The adaptive step size solver based on singlestep DPM-Solver. + Args: + x: A pytorch tensor. The initial value at time `t_T`. + order: A `int`. The (higher) order of the solver. We only support order == 2 or 3. + t_T: A `float`. The starting time of the sampling (default is T). + t_0: A `float`. The ending time of the sampling (default is epsilon). + h_init: A `float`. The initial step size (for logSNR). + atol: A `float`. The absolute tolerance of the solver. For image data, the default setting is 0.0078, followed [1]. + rtol: A `float`. The relative tolerance of the solver. The default setting is 0.05. + theta: A `float`. The safety hyperparameter for adapting the step size. The default setting is 0.9, followed [1]. + t_err: A `float`. The tolerance for the time. We solve the diffusion ODE until the absolute error between the + current time and `t_0` is less than `t_err`. The default setting is 1e-5. + solver_type: either 'dpm_solver' or 'taylor'. The type for the high-order solvers. + The type slightly impacts the performance. We recommend to use 'dpm_solver' type. + Returns: + x_0: A pytorch tensor. The approximated solution at time `t_0`. + [1] A. Jolicoeur-Martineau, K. Li, R. Piché-Taillefer, T. Kachman, and I. Mitliagkas, "Gotta go fast when generating data with score-based models," arXiv preprint arXiv:2105.14080, 2021. + """ + ns = self.noise_schedule + s = t_T * torch.ones((x.shape[0],)).to(x) + lambda_s = ns.marginal_lambda(s) + lambda_0 = ns.marginal_lambda(t_0 * torch.ones_like(s).to(x)) + h = h_init * torch.ones_like(s).to(x) + x_prev = x + nfe = 0 + if order == 2: + r1 = 0.5 + lower_update = lambda x, s, t: self.dpm_solver_first_update(x, s, t, return_intermediate=True) + higher_update = lambda x, s, t, **kwargs: self.singlestep_dpm_solver_second_update(x, s, t, r1=r1, + solver_type=solver_type, + **kwargs) + elif order == 3: + r1, r2 = 1. / 3., 2. / 3. + lower_update = lambda x, s, t: self.singlestep_dpm_solver_second_update(x, s, t, r1=r1, + return_intermediate=True, + solver_type=solver_type) + higher_update = lambda x, s, t, **kwargs: self.singlestep_dpm_solver_third_update(x, s, t, r1=r1, r2=r2, + solver_type=solver_type, + **kwargs) + else: + raise ValueError("For adaptive step size solver, order must be 2 or 3, got {}".format(order)) + while torch.abs((s - t_0)).mean() > t_err: + t = ns.inverse_lambda(lambda_s + h) + x_lower, lower_noise_kwargs = lower_update(x, s, t) + x_higher = higher_update(x, s, t, **lower_noise_kwargs) + delta = torch.max(torch.ones_like(x).to(x) * atol, rtol * torch.max(torch.abs(x_lower), torch.abs(x_prev))) + norm_fn = lambda v: torch.sqrt(torch.square(v.reshape((v.shape[0], -1))).mean(dim=-1, keepdim=True)) + E = norm_fn((x_higher - x_lower) / delta).max() + if torch.all(E <= 1.): + x = x_higher + s = t + x_prev = x_lower + lambda_s = ns.marginal_lambda(s) + h = torch.min(theta * h * torch.float_power(E, -1. / order).float(), lambda_0 - lambda_s) + nfe += order + print('adaptive solver nfe', nfe) + return x + + def sample(self, x, steps=20, t_start=None, t_end=None, order=3, skip_type='time_uniform', + method='singlestep', lower_order_final=True, denoise_to_zero=False, solver_type='dpm_solver', + atol=0.0078, rtol=0.05, + ): + """ + Compute the sample at time `t_end` by DPM-Solver, given the initial `x` at time `t_start`. + ===================================================== + We support the following algorithms for both noise prediction model and data prediction model: + - 'singlestep': + Singlestep DPM-Solver (i.e. "DPM-Solver-fast" in the paper), which combines different orders of singlestep DPM-Solver. + We combine all the singlestep solvers with order <= `order` to use up all the function evaluations (steps). + The total number of function evaluations (NFE) == `steps`. + Given a fixed NFE == `steps`, the sampling procedure is: + - If `order` == 1: + - Denote K = steps. We use K steps of DPM-Solver-1 (i.e. DDIM). + - If `order` == 2: + - Denote K = (steps // 2) + (steps % 2). We take K intermediate time steps for sampling. + - If steps % 2 == 0, we use K steps of singlestep DPM-Solver-2. + - If steps % 2 == 1, we use (K - 1) steps of singlestep DPM-Solver-2 and 1 step of DPM-Solver-1. + - If `order` == 3: + - Denote K = (steps // 3 + 1). We take K intermediate time steps for sampling. + - If steps % 3 == 0, we use (K - 2) steps of singlestep DPM-Solver-3, and 1 step of singlestep DPM-Solver-2 and 1 step of DPM-Solver-1. + - If steps % 3 == 1, we use (K - 1) steps of singlestep DPM-Solver-3 and 1 step of DPM-Solver-1. + - If steps % 3 == 2, we use (K - 1) steps of singlestep DPM-Solver-3 and 1 step of singlestep DPM-Solver-2. + - 'multistep': + Multistep DPM-Solver with the order of `order`. The total number of function evaluations (NFE) == `steps`. + We initialize the first `order` values by lower order multistep solvers. + Given a fixed NFE == `steps`, the sampling procedure is: + Denote K = steps. + - If `order` == 1: + - We use K steps of DPM-Solver-1 (i.e. DDIM). + - If `order` == 2: + - We firstly use 1 step of DPM-Solver-1, then use (K - 1) step of multistep DPM-Solver-2. + - If `order` == 3: + - We firstly use 1 step of DPM-Solver-1, then 1 step of multistep DPM-Solver-2, then (K - 2) step of multistep DPM-Solver-3. + - 'singlestep_fixed': + Fixed order singlestep DPM-Solver (i.e. DPM-Solver-1 or singlestep DPM-Solver-2 or singlestep DPM-Solver-3). + We use singlestep DPM-Solver-`order` for `order`=1 or 2 or 3, with total [`steps` // `order`] * `order` NFE. + - 'adaptive': + Adaptive step size DPM-Solver (i.e. "DPM-Solver-12" and "DPM-Solver-23" in the paper). + We ignore `steps` and use adaptive step size DPM-Solver with a higher order of `order`. + You can adjust the absolute tolerance `atol` and the relative tolerance `rtol` to balance the computatation costs + (NFE) and the sample quality. + - If `order` == 2, we use DPM-Solver-12 which combines DPM-Solver-1 and singlestep DPM-Solver-2. + - If `order` == 3, we use DPM-Solver-23 which combines singlestep DPM-Solver-2 and singlestep DPM-Solver-3. + ===================================================== + Some advices for choosing the algorithm: + - For **unconditional sampling** or **guided sampling with small guidance scale** by DPMs: + Use singlestep DPM-Solver ("DPM-Solver-fast" in the paper) with `order = 3`. + e.g. + >>> dpm_solver = DPM_Solver(model_fn, noise_schedule, predict_x0=False) + >>> x_sample = dpm_solver.sample(x, steps=steps, t_start=t_start, t_end=t_end, order=3, + skip_type='time_uniform', method='singlestep') + - For **guided sampling with large guidance scale** by DPMs: + Use multistep DPM-Solver with `predict_x0 = True` and `order = 2`. + e.g. + >>> dpm_solver = DPM_Solver(model_fn, noise_schedule, predict_x0=True) + >>> x_sample = dpm_solver.sample(x, steps=steps, t_start=t_start, t_end=t_end, order=2, + skip_type='time_uniform', method='multistep') + We support three types of `skip_type`: + - 'logSNR': uniform logSNR for the time steps. **Recommended for low-resolutional images** + - 'time_uniform': uniform time for the time steps. **Recommended for high-resolutional images**. + - 'time_quadratic': quadratic time for the time steps. + ===================================================== + Args: + x: A pytorch tensor. The initial value at time `t_start` + e.g. if `t_start` == T, then `x` is a sample from the standard normal distribution. + steps: A `int`. The total number of function evaluations (NFE). + t_start: A `float`. The starting time of the sampling. + If `T` is None, we use self.noise_schedule.T (default is 1.0). + t_end: A `float`. The ending time of the sampling. + If `t_end` is None, we use 1. / self.noise_schedule.total_N. + e.g. if total_N == 1000, we have `t_end` == 1e-3. + For discrete-time DPMs: + - We recommend `t_end` == 1. / self.noise_schedule.total_N. + For continuous-time DPMs: + - We recommend `t_end` == 1e-3 when `steps` <= 15; and `t_end` == 1e-4 when `steps` > 15. + order: A `int`. The order of DPM-Solver. + skip_type: A `str`. The type for the spacing of the time steps. 'time_uniform' or 'logSNR' or 'time_quadratic'. + method: A `str`. The method for sampling. 'singlestep' or 'multistep' or 'singlestep_fixed' or 'adaptive'. + denoise_to_zero: A `bool`. Whether to denoise to time 0 at the final step. + Default is `False`. If `denoise_to_zero` is `True`, the total NFE is (`steps` + 1). + This trick is firstly proposed by DDPM (https://arxiv.org/abs/2006.11239) and + score_sde (https://arxiv.org/abs/2011.13456). Such trick can improve the FID + for diffusion models sampling by diffusion SDEs for low-resolutional images + (such as CIFAR-10). However, we observed that such trick does not matter for + high-resolutional images. As it needs an additional NFE, we do not recommend + it for high-resolutional images. + lower_order_final: A `bool`. Whether to use lower order solvers at the final steps. + Only valid for `method=multistep` and `steps < 15`. We empirically find that + this trick is a key to stabilizing the sampling by DPM-Solver with very few steps + (especially for steps <= 10). So we recommend to set it to be `True`. + solver_type: A `str`. The taylor expansion type for the solver. `dpm_solver` or `taylor`. We recommend `dpm_solver`. + atol: A `float`. The absolute tolerance of the adaptive step size solver. Valid when `method` == 'adaptive'. + rtol: A `float`. The relative tolerance of the adaptive step size solver. Valid when `method` == 'adaptive'. + Returns: + x_end: A pytorch tensor. The approximated solution at time `t_end`. + """ + t_0 = 1. / self.noise_schedule.total_N if t_end is None else t_end + t_T = self.noise_schedule.T if t_start is None else t_start + device = x.device + if method == 'adaptive': + with torch.no_grad(): + x = self.dpm_solver_adaptive(x, order=order, t_T=t_T, t_0=t_0, atol=atol, rtol=rtol, + solver_type=solver_type) + elif method == 'multistep': + assert steps >= order + timesteps = self.get_time_steps(skip_type=skip_type, t_T=t_T, t_0=t_0, N=steps, device=device) + assert timesteps.shape[0] - 1 == steps + with torch.no_grad(): + vec_t = timesteps[0].expand((x.shape[0])) + model_prev_list = [self.model_fn(x, vec_t)] + t_prev_list = [vec_t] + # Init the first `order` values by lower order multistep DPM-Solver. + for init_order in tqdm(range(1, order), desc="DPM init order"): + vec_t = timesteps[init_order].expand(x.shape[0]) + x = self.multistep_dpm_solver_update(x, model_prev_list, t_prev_list, vec_t, init_order, + solver_type=solver_type) + model_prev_list.append(self.model_fn(x, vec_t)) + t_prev_list.append(vec_t) + # Compute the remaining values by `order`-th order multistep DPM-Solver. + for step in tqdm(range(order, steps + 1), desc="DPM multistep"): + vec_t = timesteps[step].expand(x.shape[0]) + if lower_order_final and steps < 15: + step_order = min(order, steps + 1 - step) + else: + step_order = order + x = self.multistep_dpm_solver_update(x, model_prev_list, t_prev_list, vec_t, step_order, + solver_type=solver_type) + for i in range(order - 1): + t_prev_list[i] = t_prev_list[i + 1] + model_prev_list[i] = model_prev_list[i + 1] + t_prev_list[-1] = vec_t + # We do not need to evaluate the final model value. + if step < steps: + model_prev_list[-1] = self.model_fn(x, vec_t) + elif method in ['singlestep', 'singlestep_fixed']: + if method == 'singlestep': + timesteps_outer, orders = self.get_orders_and_timesteps_for_singlestep_solver(steps=steps, order=order, + skip_type=skip_type, + t_T=t_T, t_0=t_0, + device=device) + elif method == 'singlestep_fixed': + K = steps // order + orders = [order, ] * K + timesteps_outer = self.get_time_steps(skip_type=skip_type, t_T=t_T, t_0=t_0, N=K, device=device) + for i, order in enumerate(orders): + t_T_inner, t_0_inner = timesteps_outer[i], timesteps_outer[i + 1] + timesteps_inner = self.get_time_steps(skip_type=skip_type, t_T=t_T_inner.item(), t_0=t_0_inner.item(), + N=order, device=device) + lambda_inner = self.noise_schedule.marginal_lambda(timesteps_inner) + vec_s, vec_t = t_T_inner.tile(x.shape[0]), t_0_inner.tile(x.shape[0]) + h = lambda_inner[-1] - lambda_inner[0] + r1 = None if order <= 1 else (lambda_inner[1] - lambda_inner[0]) / h + r2 = None if order <= 2 else (lambda_inner[2] - lambda_inner[0]) / h + x = self.singlestep_dpm_solver_update(x, vec_s, vec_t, order, solver_type=solver_type, r1=r1, r2=r2) + if denoise_to_zero: + x = self.denoise_to_zero_fn(x, torch.ones((x.shape[0],)).to(device) * t_0) + return x + + +############################################################# +# other utility functions +############################################################# + +def interpolate_fn(x, xp, yp): + """ + A piecewise linear function y = f(x), using xp and yp as keypoints. + We implement f(x) in a differentiable way (i.e. applicable for autograd). + The function f(x) is well-defined for all x-axis. (For x beyond the bounds of xp, we use the outmost points of xp to define the linear function.) + Args: + x: PyTorch tensor with shape [N, C], where N is the batch size, C is the number of channels (we use C = 1 for DPM-Solver). + xp: PyTorch tensor with shape [C, K], where K is the number of keypoints. + yp: PyTorch tensor with shape [C, K]. + Returns: + The function values f(x), with shape [N, C]. + """ + N, K = x.shape[0], xp.shape[1] + all_x = torch.cat([x.unsqueeze(2), xp.unsqueeze(0).repeat((N, 1, 1))], dim=2) + sorted_all_x, x_indices = torch.sort(all_x, dim=2) + x_idx = torch.argmin(x_indices, dim=2) + cand_start_idx = x_idx - 1 + start_idx = torch.where( + torch.eq(x_idx, 0), + torch.tensor(1, device=x.device), + torch.where( + torch.eq(x_idx, K), torch.tensor(K - 2, device=x.device), cand_start_idx, + ), + ) + end_idx = torch.where(torch.eq(start_idx, cand_start_idx), start_idx + 2, start_idx + 1) + start_x = torch.gather(sorted_all_x, dim=2, index=start_idx.unsqueeze(2)).squeeze(2) + end_x = torch.gather(sorted_all_x, dim=2, index=end_idx.unsqueeze(2)).squeeze(2) + start_idx2 = torch.where( + torch.eq(x_idx, 0), + torch.tensor(0, device=x.device), + torch.where( + torch.eq(x_idx, K), torch.tensor(K - 2, device=x.device), cand_start_idx, + ), + ) + y_positions_expanded = yp.unsqueeze(0).expand(N, -1, -1) + start_y = torch.gather(y_positions_expanded, dim=2, index=start_idx2.unsqueeze(2)).squeeze(2) + end_y = torch.gather(y_positions_expanded, dim=2, index=(start_idx2 + 1).unsqueeze(2)).squeeze(2) + cand = start_y + (x - start_x) * (end_y - start_y) / (end_x - start_x) + return cand + + +def expand_dims(v, dims): + """ + Expand the tensor `v` to the dim `dims`. + Args: + `v`: a PyTorch tensor with shape [N]. + `dim`: a `int`. + Returns: + a PyTorch tensor with shape [N, 1, 1, ..., 1] and the total dimension is `dims`. + """ + return v[(...,) + (None,) * (dims - 1)] \ No newline at end of file diff --git a/ldm/models/diffusion/dpm_solver/sampler.py b/ldm/models/diffusion/dpm_solver/sampler.py new file mode 100644 index 0000000000000000000000000000000000000000..e4d0d0a387548a280d872b60344d0a74dac5e1f0 --- /dev/null +++ b/ldm/models/diffusion/dpm_solver/sampler.py @@ -0,0 +1,96 @@ +"""SAMPLING ONLY.""" +import torch + +from .dpm_solver import NoiseScheduleVP, model_wrapper, DPM_Solver + +MODEL_TYPES = { + "eps": "noise", + "v": "v" +} + + +class DPMSolverSampler(object): + def __init__(self, model, device=torch.device("cuda"), **kwargs): + super().__init__() + self.model = model + self.device = device + to_torch = lambda x: x.clone().detach().to(torch.float32).to(model.device) + self.register_buffer('alphas_cumprod', to_torch(model.alphas_cumprod)) + + def register_buffer(self, name, attr): + if type(attr) == torch.Tensor: + if attr.device != self.device: + attr = attr.to(self.device) + setattr(self, name, attr) + + @torch.no_grad() + def sample(self, + S, + batch_size, + shape, + conditioning=None, + callback=None, + normals_sequence=None, + img_callback=None, + quantize_x0=False, + eta=0., + mask=None, + x0=None, + temperature=1., + noise_dropout=0., + score_corrector=None, + corrector_kwargs=None, + verbose=True, + x_T=None, + log_every_t=100, + unconditional_guidance_scale=1., + unconditional_conditioning=None, + # this has to come in the same format as the conditioning, # e.g. as encoded tokens, ... + **kwargs + ): + if conditioning is not None: + if isinstance(conditioning, dict): + ctmp = conditioning[list(conditioning.keys())[0]] + while isinstance(ctmp, list): ctmp = ctmp[0] + if isinstance(ctmp, torch.Tensor): + cbs = ctmp.shape[0] + if cbs != batch_size: + print(f"Warning: Got {cbs} conditionings but batch-size is {batch_size}") + elif isinstance(conditioning, list): + for ctmp in conditioning: + if ctmp.shape[0] != batch_size: + print(f"Warning: Got {ctmp.shape[0]} conditionings but batch-size is {batch_size}") + else: + if isinstance(conditioning, torch.Tensor): + if conditioning.shape[0] != batch_size: + print(f"Warning: Got {conditioning.shape[0]} conditionings but batch-size is {batch_size}") + + # sampling + C, H, W = shape + size = (batch_size, C, H, W) + + print(f'Data shape for DPM-Solver sampling is {size}, sampling steps {S}') + + device = self.model.betas.device + if x_T is None: + img = torch.randn(size, device=device) + else: + img = x_T + + ns = NoiseScheduleVP('discrete', alphas_cumprod=self.alphas_cumprod) + + model_fn = model_wrapper( + lambda x, t, c: self.model.apply_model(x, t, c), + ns, + model_type=MODEL_TYPES[self.model.parameterization], + guidance_type="classifier-free", + condition=conditioning, + unconditional_condition=unconditional_conditioning, + guidance_scale=unconditional_guidance_scale, + ) + + dpm_solver = DPM_Solver(model_fn, ns, predict_x0=True, thresholding=False) + x = dpm_solver.sample(img, steps=S, skip_type="time_uniform", method="multistep", order=2, + lower_order_final=True) + + return x.to(device), None diff --git a/ldm/models/diffusion/plms.py b/ldm/models/diffusion/plms.py new file mode 100644 index 0000000000000000000000000000000000000000..9d31b3994ed283e9d97ed0ae275d89046442cc89 --- /dev/null +++ b/ldm/models/diffusion/plms.py @@ -0,0 +1,245 @@ +"""SAMPLING ONLY.""" + +import torch +import numpy as np +from tqdm import tqdm +from functools import partial + +from ldm.modules.diffusionmodules.util import make_ddim_sampling_parameters, make_ddim_timesteps, noise_like +from ldm.models.diffusion.sampling_util import norm_thresholding + + +class PLMSSampler(object): + def __init__(self, model, schedule="linear", device=torch.device("cuda"), **kwargs): + super().__init__() + self.model = model + self.ddpm_num_timesteps = model.num_timesteps + self.schedule = schedule + self.device = device + + def register_buffer(self, name, attr): + if type(attr) == torch.Tensor: + if attr.device != self.device: + attr = attr.to(self.device) + setattr(self, name, attr) + + def make_schedule(self, ddim_num_steps, ddim_discretize="uniform", ddim_eta=0., verbose=True): + if ddim_eta != 0: + raise ValueError('ddim_eta must be 0 for PLMS') + self.ddim_timesteps = make_ddim_timesteps(ddim_discr_method=ddim_discretize, num_ddim_timesteps=ddim_num_steps, + num_ddpm_timesteps=self.ddpm_num_timesteps,verbose=verbose) + alphas_cumprod = self.model.alphas_cumprod + assert alphas_cumprod.shape[0] == self.ddpm_num_timesteps, 'alphas have to be defined for each timestep' + to_torch = lambda x: x.clone().detach().to(torch.float32).to(self.model.device) + + self.register_buffer('betas', to_torch(self.model.betas)) + self.register_buffer('alphas_cumprod', to_torch(alphas_cumprod)) + self.register_buffer('alphas_cumprod_prev', to_torch(self.model.alphas_cumprod_prev)) + + # calculations for diffusion q(x_t | x_{t-1}) and others + self.register_buffer('sqrt_alphas_cumprod', to_torch(np.sqrt(alphas_cumprod.cpu()))) + self.register_buffer('sqrt_one_minus_alphas_cumprod', to_torch(np.sqrt(1. - alphas_cumprod.cpu()))) + self.register_buffer('log_one_minus_alphas_cumprod', to_torch(np.log(1. - alphas_cumprod.cpu()))) + self.register_buffer('sqrt_recip_alphas_cumprod', to_torch(np.sqrt(1. / alphas_cumprod.cpu()))) + self.register_buffer('sqrt_recipm1_alphas_cumprod', to_torch(np.sqrt(1. / alphas_cumprod.cpu() - 1))) + + # ddim sampling parameters + ddim_sigmas, ddim_alphas, ddim_alphas_prev = make_ddim_sampling_parameters(alphacums=alphas_cumprod.cpu(), + ddim_timesteps=self.ddim_timesteps, + eta=ddim_eta,verbose=verbose) + self.register_buffer('ddim_sigmas', ddim_sigmas) + self.register_buffer('ddim_alphas', ddim_alphas) + self.register_buffer('ddim_alphas_prev', ddim_alphas_prev) + self.register_buffer('ddim_sqrt_one_minus_alphas', np.sqrt(1. - ddim_alphas)) + sigmas_for_original_sampling_steps = ddim_eta * torch.sqrt( + (1 - self.alphas_cumprod_prev) / (1 - self.alphas_cumprod) * ( + 1 - self.alphas_cumprod / self.alphas_cumprod_prev)) + self.register_buffer('ddim_sigmas_for_original_num_steps', sigmas_for_original_sampling_steps) + + @torch.no_grad() + def sample(self, + S, + batch_size, + shape, + conditioning=None, + callback=None, + normals_sequence=None, + img_callback=None, + quantize_x0=False, + eta=0., + mask=None, + x0=None, + temperature=1., + noise_dropout=0., + score_corrector=None, + corrector_kwargs=None, + verbose=True, + x_T=None, + log_every_t=100, + unconditional_guidance_scale=1., + unconditional_conditioning=None, + # this has to come in the same format as the conditioning, # e.g. as encoded tokens, ... + dynamic_threshold=None, + **kwargs + ): + if conditioning is not None: + if isinstance(conditioning, dict): + cbs = conditioning[list(conditioning.keys())[0]].shape[0] + if cbs != batch_size: + print(f"Warning: Got {cbs} conditionings but batch-size is {batch_size}") + else: + if conditioning.shape[0] != batch_size: + print(f"Warning: Got {conditioning.shape[0]} conditionings but batch-size is {batch_size}") + + self.make_schedule(ddim_num_steps=S, ddim_eta=eta, verbose=verbose) + # sampling + C, H, W = shape + size = (batch_size, C, H, W) + print(f'Data shape for PLMS sampling is {size}') + + samples, intermediates = self.plms_sampling(conditioning, size, + callback=callback, + img_callback=img_callback, + quantize_denoised=quantize_x0, + mask=mask, x0=x0, + ddim_use_original_steps=False, + noise_dropout=noise_dropout, + temperature=temperature, + score_corrector=score_corrector, + corrector_kwargs=corrector_kwargs, + x_T=x_T, + log_every_t=log_every_t, + unconditional_guidance_scale=unconditional_guidance_scale, + unconditional_conditioning=unconditional_conditioning, + dynamic_threshold=dynamic_threshold, + ) + return samples, intermediates + + @torch.no_grad() + def plms_sampling(self, cond, shape, + x_T=None, ddim_use_original_steps=False, + callback=None, timesteps=None, quantize_denoised=False, + mask=None, x0=None, img_callback=None, log_every_t=100, + temperature=1., noise_dropout=0., score_corrector=None, corrector_kwargs=None, + unconditional_guidance_scale=1., unconditional_conditioning=None, + dynamic_threshold=None): + device = self.model.betas.device + b = shape[0] + if x_T is None: + img = torch.randn(shape, device=device) + else: + img = x_T + + if timesteps is None: + timesteps = self.ddpm_num_timesteps if ddim_use_original_steps else self.ddim_timesteps + elif timesteps is not None and not ddim_use_original_steps: + subset_end = int(min(timesteps / self.ddim_timesteps.shape[0], 1) * self.ddim_timesteps.shape[0]) - 1 + timesteps = self.ddim_timesteps[:subset_end] + + intermediates = {'x_inter': [img], 'pred_x0': [img]} + time_range = list(reversed(range(0,timesteps))) if ddim_use_original_steps else np.flip(timesteps) + total_steps = timesteps if ddim_use_original_steps else timesteps.shape[0] + print(f"Running PLMS Sampling with {total_steps} timesteps") + + iterator = tqdm(time_range, desc='PLMS Sampler', total=total_steps) + old_eps = [] + + for i, step in enumerate(iterator): + index = total_steps - i - 1 + ts = torch.full((b,), step, device=device, dtype=torch.long) + ts_next = torch.full((b,), time_range[min(i + 1, len(time_range) - 1)], device=device, dtype=torch.long) + + if mask is not None: + assert x0 is not None + img_orig = self.model.q_sample(x0, ts) # TODO: deterministic forward pass? + img = img_orig * mask + (1. - mask) * img + + outs = self.p_sample_plms(img, cond, ts, index=index, use_original_steps=ddim_use_original_steps, + quantize_denoised=quantize_denoised, temperature=temperature, + noise_dropout=noise_dropout, score_corrector=score_corrector, + corrector_kwargs=corrector_kwargs, + unconditional_guidance_scale=unconditional_guidance_scale, + unconditional_conditioning=unconditional_conditioning, + old_eps=old_eps, t_next=ts_next, + dynamic_threshold=dynamic_threshold) + img, pred_x0, e_t = outs + old_eps.append(e_t) + if len(old_eps) >= 4: + old_eps.pop(0) + if callback: callback(i) + if img_callback: img_callback(pred_x0, i) + + if index % log_every_t == 0 or index == total_steps - 1: + intermediates['x_inter'].append(img) + intermediates['pred_x0'].append(pred_x0) + + return img, intermediates + + @torch.no_grad() + def p_sample_plms(self, x, c, t, index, repeat_noise=False, use_original_steps=False, quantize_denoised=False, + temperature=1., noise_dropout=0., score_corrector=None, corrector_kwargs=None, + unconditional_guidance_scale=1., unconditional_conditioning=None, old_eps=None, t_next=None, + dynamic_threshold=None): + b, *_, device = *x.shape, x.device + + def get_model_output(x, t): + if unconditional_conditioning is None or unconditional_guidance_scale == 1.: + e_t = self.model.apply_model(x, t, c) + else: + x_in = torch.cat([x] * 2) + t_in = torch.cat([t] * 2) + c_in = torch.cat([unconditional_conditioning, c]) + e_t_uncond, e_t = self.model.apply_model(x_in, t_in, c_in).chunk(2) + e_t = e_t_uncond + unconditional_guidance_scale * (e_t - e_t_uncond) + + if score_corrector is not None: + assert self.model.parameterization == "eps" + e_t = score_corrector.modify_score(self.model, e_t, x, t, c, **corrector_kwargs) + + return e_t + + alphas = self.model.alphas_cumprod if use_original_steps else self.ddim_alphas + alphas_prev = self.model.alphas_cumprod_prev if use_original_steps else self.ddim_alphas_prev + sqrt_one_minus_alphas = self.model.sqrt_one_minus_alphas_cumprod if use_original_steps else self.ddim_sqrt_one_minus_alphas + sigmas = self.model.ddim_sigmas_for_original_num_steps if use_original_steps else self.ddim_sigmas + + def get_x_prev_and_pred_x0(e_t, index): + # select parameters corresponding to the currently considered timestep + a_t = torch.full((b, 1, 1, 1), alphas[index], device=device) + a_prev = torch.full((b, 1, 1, 1), alphas_prev[index], device=device) + sigma_t = torch.full((b, 1, 1, 1), sigmas[index], device=device) + sqrt_one_minus_at = torch.full((b, 1, 1, 1), sqrt_one_minus_alphas[index],device=device) + + # current prediction for x_0 + pred_x0 = (x - sqrt_one_minus_at * e_t) / a_t.sqrt() + if quantize_denoised: + pred_x0, _, *_ = self.model.first_stage_model.quantize(pred_x0) + if dynamic_threshold is not None: + pred_x0 = norm_thresholding(pred_x0, dynamic_threshold) + # direction pointing to x_t + dir_xt = (1. - a_prev - sigma_t**2).sqrt() * e_t + noise = sigma_t * noise_like(x.shape, device, repeat_noise) * temperature + if noise_dropout > 0.: + noise = torch.nn.functional.dropout(noise, p=noise_dropout) + x_prev = a_prev.sqrt() * pred_x0 + dir_xt + noise + return x_prev, pred_x0 + + e_t = get_model_output(x, t) + if len(old_eps) == 0: + # Pseudo Improved Euler (2nd order) + x_prev, pred_x0 = get_x_prev_and_pred_x0(e_t, index) + e_t_next = get_model_output(x_prev, t_next) + e_t_prime = (e_t + e_t_next) / 2 + elif len(old_eps) == 1: + # 2nd order Pseudo Linear Multistep (Adams-Bashforth) + e_t_prime = (3 * e_t - old_eps[-1]) / 2 + elif len(old_eps) == 2: + # 3nd order Pseudo Linear Multistep (Adams-Bashforth) + e_t_prime = (23 * e_t - 16 * old_eps[-1] + 5 * old_eps[-2]) / 12 + elif len(old_eps) >= 3: + # 4nd order Pseudo Linear Multistep (Adams-Bashforth) + e_t_prime = (55 * e_t - 59 * old_eps[-1] + 37 * old_eps[-2] - 9 * old_eps[-3]) / 24 + + x_prev, pred_x0 = get_x_prev_and_pred_x0(e_t_prime, index) + + return x_prev, pred_x0, e_t diff --git a/ldm/models/diffusion/sampling_util.py b/ldm/models/diffusion/sampling_util.py new file mode 100644 index 0000000000000000000000000000000000000000..7eff02be6d7c54d43ee6680636ac0698dd3b3f33 --- /dev/null +++ b/ldm/models/diffusion/sampling_util.py @@ -0,0 +1,22 @@ +import torch +import numpy as np + + +def append_dims(x, target_dims): + """Appends dimensions to the end of a tensor until it has target_dims dimensions. + From https://github.com/crowsonkb/k-diffusion/blob/master/k_diffusion/utils.py""" + dims_to_append = target_dims - x.ndim + if dims_to_append < 0: + raise ValueError(f'input has {x.ndim} dims but target_dims is {target_dims}, which is less') + return x[(...,) + (None,) * dims_to_append] + + +def norm_thresholding(x0, value): + s = append_dims(x0.pow(2).flatten(1).mean(1).sqrt().clamp(min=value), x0.ndim) + return x0 * (value / s) + + +def spatial_norm_thresholding(x0, value): + # b c h w + s = x0.pow(2).mean(1, keepdim=True).sqrt().clamp(min=value) + return x0 * (value / s) \ No newline at end of file diff --git a/ldm/modules/attention.py b/ldm/modules/attention.py new file mode 100644 index 0000000000000000000000000000000000000000..509cd873768f0dd75a75ab3fcdd652822b12b59f --- /dev/null +++ b/ldm/modules/attention.py @@ -0,0 +1,341 @@ +from inspect import isfunction +import math +import torch +import torch.nn.functional as F +from torch import nn, einsum +from einops import rearrange, repeat +from typing import Optional, Any + +from ldm.modules.diffusionmodules.util import checkpoint + + +try: + import xformers + import xformers.ops + XFORMERS_IS_AVAILBLE = True +except: + XFORMERS_IS_AVAILBLE = False + +# CrossAttn precision handling +import os +_ATTN_PRECISION = os.environ.get("ATTN_PRECISION", "fp32") + +def exists(val): + return val is not None + + +def uniq(arr): + return{el: True for el in arr}.keys() + + +def default(val, d): + if exists(val): + return val + return d() if isfunction(d) else d + + +def max_neg_value(t): + return -torch.finfo(t.dtype).max + + +def init_(tensor): + dim = tensor.shape[-1] + std = 1 / math.sqrt(dim) + tensor.uniform_(-std, std) + return tensor + + +# feedforward +class GEGLU(nn.Module): + def __init__(self, dim_in, dim_out): + super().__init__() + self.proj = nn.Linear(dim_in, dim_out * 2) + + def forward(self, x): + x, gate = self.proj(x).chunk(2, dim=-1) + return x * F.gelu(gate) + + +class FeedForward(nn.Module): + def __init__(self, dim, dim_out=None, mult=4, glu=False, dropout=0.): + super().__init__() + inner_dim = int(dim * mult) + dim_out = default(dim_out, dim) + project_in = nn.Sequential( + nn.Linear(dim, inner_dim), + nn.GELU() + ) if not glu else GEGLU(dim, inner_dim) + + self.net = nn.Sequential( + project_in, + nn.Dropout(dropout), + nn.Linear(inner_dim, dim_out) + ) + + def forward(self, x): + return self.net(x) + + +def zero_module(module): + """ + Zero out the parameters of a module and return it. + """ + for p in module.parameters(): + p.detach().zero_() + return module + + +def Normalize(in_channels): + return torch.nn.GroupNorm(num_groups=32, num_channels=in_channels, eps=1e-6, affine=True) + + +class SpatialSelfAttention(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 = rearrange(q, 'b c h w -> b (h w) c') + k = rearrange(k, 'b c h w -> b c (h w)') + w_ = torch.einsum('bij,bjk->bik', q, k) + + w_ = w_ * (int(c)**(-0.5)) + w_ = torch.nn.functional.softmax(w_, dim=2) + + # attend to values + v = rearrange(v, 'b c h w -> b c (h w)') + w_ = rearrange(w_, 'b i j -> b j i') + h_ = torch.einsum('bij,bjk->bik', v, w_) + h_ = rearrange(h_, 'b c (h w) -> b c h w', h=h) + h_ = self.proj_out(h_) + + return x+h_ + + +class CrossAttention(nn.Module): + def __init__(self, query_dim, context_dim=None, heads=8, dim_head=64, dropout=0.): + super().__init__() + inner_dim = dim_head * heads + context_dim = default(context_dim, query_dim) + + self.scale = dim_head ** -0.5 + self.heads = heads + + self.to_q = nn.Linear(query_dim, inner_dim, bias=False) + self.to_k = nn.Linear(context_dim, inner_dim, bias=False) + self.to_v = nn.Linear(context_dim, inner_dim, bias=False) + + self.to_out = nn.Sequential( + nn.Linear(inner_dim, query_dim), + nn.Dropout(dropout) + ) + + def forward(self, x, context=None, mask=None): + h = self.heads + + q = self.to_q(x) + context = default(context, x) + k = self.to_k(context) + v = self.to_v(context) + + q, k, v = map(lambda t: rearrange(t, 'b n (h d) -> (b h) n d', h=h), (q, k, v)) + + # force cast to fp32 to avoid overflowing + if _ATTN_PRECISION =="fp32": + with torch.autocast(enabled=False, device_type = 'cuda'): + q, k = q.float(), k.float() + sim = einsum('b i d, b j d -> b i j', q, k) * self.scale + else: + sim = einsum('b i d, b j d -> b i j', q, k) * self.scale + + del q, k + + if exists(mask): + mask = rearrange(mask, 'b ... -> b (...)') + max_neg_value = -torch.finfo(sim.dtype).max + mask = repeat(mask, 'b j -> (b h) () j', h=h) + sim.masked_fill_(~mask, max_neg_value) + + # attention, what we cannot get enough of + sim = sim.softmax(dim=-1) + + out = einsum('b i j, b j d -> b i d', sim, v) + out = rearrange(out, '(b h) n d -> b n (h d)', h=h) + return self.to_out(out) + + +class MemoryEfficientCrossAttention(nn.Module): + # https://github.com/MatthieuTPHR/diffusers/blob/d80b531ff8060ec1ea982b65a1b8df70f73aa67c/src/diffusers/models/attention.py#L223 + def __init__(self, query_dim, context_dim=None, heads=8, dim_head=64, dropout=0.0): + super().__init__() + print(f"Setting up {self.__class__.__name__}. Query dim is {query_dim}, context_dim is {context_dim} and using " + f"{heads} heads.") + inner_dim = dim_head * heads + context_dim = default(context_dim, query_dim) + + self.heads = heads + self.dim_head = dim_head + + self.to_q = nn.Linear(query_dim, inner_dim, bias=False) + self.to_k = nn.Linear(context_dim, inner_dim, bias=False) + self.to_v = nn.Linear(context_dim, inner_dim, bias=False) + + self.to_out = nn.Sequential(nn.Linear(inner_dim, query_dim), nn.Dropout(dropout)) + self.attention_op: Optional[Any] = None + + def forward(self, x, context=None, mask=None): + q = self.to_q(x) + context = default(context, x) + k = self.to_k(context) + v = self.to_v(context) + + b, _, _ = q.shape + q, k, v = map( + lambda t: t.unsqueeze(3) + .reshape(b, t.shape[1], self.heads, self.dim_head) + .permute(0, 2, 1, 3) + .reshape(b * self.heads, t.shape[1], self.dim_head) + .contiguous(), + (q, k, v), + ) + + # actually compute the attention, what we cannot get enough of + out = xformers.ops.memory_efficient_attention(q, k, v, attn_bias=None, op=self.attention_op) + + if exists(mask): + raise NotImplementedError + out = ( + out.unsqueeze(0) + .reshape(b, self.heads, out.shape[1], self.dim_head) + .permute(0, 2, 1, 3) + .reshape(b, out.shape[1], self.heads * self.dim_head) + ) + return self.to_out(out) + + +class BasicTransformerBlock(nn.Module): + ATTENTION_MODES = { + "softmax": CrossAttention, # vanilla attention + "softmax-xformers": MemoryEfficientCrossAttention + } + def __init__(self, dim, n_heads, d_head, dropout=0., context_dim=None, gated_ff=True, checkpoint=True, + disable_self_attn=False): + super().__init__() + attn_mode = "softmax-xformers" if XFORMERS_IS_AVAILBLE else "softmax" + assert attn_mode in self.ATTENTION_MODES + attn_cls = self.ATTENTION_MODES[attn_mode] + self.disable_self_attn = disable_self_attn + self.attn1 = attn_cls(query_dim=dim, heads=n_heads, dim_head=d_head, dropout=dropout, + context_dim=context_dim if self.disable_self_attn else None) # is a self-attention if not self.disable_self_attn + self.ff = FeedForward(dim, dropout=dropout, glu=gated_ff) + self.attn2 = attn_cls(query_dim=dim, context_dim=context_dim, + heads=n_heads, dim_head=d_head, dropout=dropout) # is self-attn if context is none + self.norm1 = nn.LayerNorm(dim) + self.norm2 = nn.LayerNorm(dim) + self.norm3 = nn.LayerNorm(dim) + self.checkpoint = checkpoint + + def forward(self, x, context=None): + return checkpoint(self._forward, (x, context), self.parameters(), self.checkpoint) + + def _forward(self, x, context=None): + x = self.attn1(self.norm1(x), context=context if self.disable_self_attn else None) + x + x = self.attn2(self.norm2(x), context=context) + x + x = self.ff(self.norm3(x)) + x + return x + + +class SpatialTransformer(nn.Module): + """ + Transformer block for image-like data. + First, project the input (aka embedding) + and reshape to b, t, d. + Then apply standard transformer action. + Finally, reshape to image + NEW: use_linear for more efficiency instead of the 1x1 convs + """ + def __init__(self, in_channels, n_heads, d_head, + depth=1, dropout=0., context_dim=None, + disable_self_attn=False, use_linear=False, + use_checkpoint=True): + super().__init__() + if exists(context_dim) and not isinstance(context_dim, list): + context_dim = [context_dim] + self.in_channels = in_channels + inner_dim = n_heads * d_head + self.norm = Normalize(in_channels) + if not use_linear: + self.proj_in = nn.Conv2d(in_channels, + inner_dim, + kernel_size=1, + stride=1, + padding=0) + else: + self.proj_in = nn.Linear(in_channels, inner_dim) + + self.transformer_blocks = nn.ModuleList( + [BasicTransformerBlock(inner_dim, n_heads, d_head, dropout=dropout, context_dim=context_dim[d], + disable_self_attn=disable_self_attn, checkpoint=use_checkpoint) + for d in range(depth)] + ) + if not use_linear: + self.proj_out = zero_module(nn.Conv2d(inner_dim, + in_channels, + kernel_size=1, + stride=1, + padding=0)) + else: + self.proj_out = zero_module(nn.Linear(in_channels, inner_dim)) + self.use_linear = use_linear + + def forward(self, x, context=None): + # note: if no context is given, cross-attention defaults to self-attention + if not isinstance(context, list): + context = [context] + b, c, h, w = x.shape + x_in = x + x = self.norm(x) + if not self.use_linear: + x = self.proj_in(x) + x = rearrange(x, 'b c h w -> b (h w) c').contiguous() + if self.use_linear: + x = self.proj_in(x) + for i, block in enumerate(self.transformer_blocks): + x = block(x, context=context[i]) + if self.use_linear: + x = self.proj_out(x) + x = rearrange(x, 'b (h w) c -> b c h w', h=h, w=w).contiguous() + if not self.use_linear: + x = self.proj_out(x) + return x + x_in + diff --git a/ldm/modules/diffusionmodules/__init__.py b/ldm/modules/diffusionmodules/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/ldm/modules/diffusionmodules/model.py b/ldm/modules/diffusionmodules/model.py new file mode 100644 index 0000000000000000000000000000000000000000..b089eebbe1676d8249005bb9def002ff5180715b --- /dev/null +++ b/ldm/modules/diffusionmodules/model.py @@ -0,0 +1,852 @@ +# pytorch_diffusion + derived encoder decoder +import math +import torch +import torch.nn as nn +import numpy as np +from einops import rearrange +from typing import Optional, Any + +from ldm.modules.attention import MemoryEfficientCrossAttention + +try: + import xformers + import xformers.ops + XFORMERS_IS_AVAILBLE = True +except: + XFORMERS_IS_AVAILBLE = False + print("No module 'xformers'. Proceeding without it.") + + +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, num_groups=32): + return torch.nn.GroupNorm(num_groups=num_groups, 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) + if temb_channels > 0: + 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) + + if temb is not None: + 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 MemoryEfficientAttnBlock(nn.Module): + """ + Uses xformers efficient implementation, + see https://github.com/MatthieuTPHR/diffusers/blob/d80b531ff8060ec1ea982b65a1b8df70f73aa67c/src/diffusers/models/attention.py#L223 + Note: this is a single-head self-attention operation + """ + # + 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) + self.attention_op: Optional[Any] = None + + 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, k, v = map(lambda x: rearrange(x, 'b c h w -> b (h w) c'), (q, k, v)) + + q, k, v = map( + lambda t: t.unsqueeze(3) + .reshape(B, t.shape[1], 1, C) + .permute(0, 2, 1, 3) + .reshape(B * 1, t.shape[1], C) + .contiguous(), + (q, k, v), + ) + out = xformers.ops.memory_efficient_attention(q, k, v, attn_bias=None, op=self.attention_op) + + out = ( + out.unsqueeze(0) + .reshape(B, 1, out.shape[1], C) + .permute(0, 2, 1, 3) + .reshape(B, out.shape[1], C) + ) + out = rearrange(out, 'b (h w) c -> b c h w', b=B, h=H, w=W, c=C) + out = self.proj_out(out) + return x+out + + +class MemoryEfficientCrossAttentionWrapper(MemoryEfficientCrossAttention): + def forward(self, x, context=None, mask=None): + b, c, h, w = x.shape + x = rearrange(x, 'b c h w -> b (h w) c') + out = super().forward(x, context=context, mask=mask) + out = rearrange(out, 'b (h w) c -> b c h w', h=h, w=w, c=c) + return x + out + + +def make_attn(in_channels, attn_type="vanilla", attn_kwargs=None): + assert attn_type in ["vanilla", "vanilla-xformers", "memory-efficient-cross-attn", "linear", "none"], f'attn_type {attn_type} unknown' + if XFORMERS_IS_AVAILBLE and attn_type == "vanilla": + attn_type = "vanilla-xformers" + print(f"making attention of type '{attn_type}' with {in_channels} in_channels") + if attn_type == "vanilla": + assert attn_kwargs is None + return AttnBlock(in_channels) + elif attn_type == "vanilla-xformers": + print(f"building MemoryEfficientAttnBlock with {in_channels} in_channels...") + return MemoryEfficientAttnBlock(in_channels) + elif type == "memory-efficient-cross-attn": + attn_kwargs["query_dim"] = in_channels + return MemoryEfficientCrossAttentionWrapper(**attn_kwargs) + elif attn_type == "none": + return nn.Identity(in_channels) + else: + raise NotImplementedError() + + +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, use_timestep=True, use_linear_attn=False, attn_type="vanilla"): + super().__init__() + if use_linear_attn: attn_type = "linear" + 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 + + self.use_timestep = use_timestep + if self.use_timestep: + # 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,)+tuple(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): + 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(make_attn(block_in, attn_type=attn_type)) + 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 = make_attn(block_in, attn_type=attn_type) + 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] + 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(make_attn(block_in, attn_type=attn_type)) + 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) + + def forward(self, x, t=None, context=None): + #assert x.shape[2] == x.shape[3] == self.resolution + if context is not None: + # assume aligned context, cat along channel axis + x = torch.cat((x, context), dim=1) + if self.use_timestep: + # timestep embedding + assert t is not None + temb = get_timestep_embedding(t, self.ch) + temb = self.temb.dense[0](temb) + temb = nonlinearity(temb) + temb = self.temb.dense[1](temb) + else: + temb = None + + # downsampling + hs = [self.conv_in(x)] + for i_level in range(self.num_resolutions): + for i_block in range(self.num_res_blocks): + 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])) + + # middle + h = hs[-1] + h = self.mid.block_1(h, temb) + h = self.mid.attn_1(h) + h = self.mid.block_2(h, temb) + + # 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: + h = self.up[i_level].upsample(h) + + # end + h = self.norm_out(h) + h = nonlinearity(h) + h = self.conv_out(h) + return h + + def get_last_layer(self): + return self.conv_out.weight + + +class Encoder(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, z_channels, double_z=True, use_linear_attn=False, attn_type="vanilla", + **ignore_kwargs): + super().__init__() + if use_linear_attn: attn_type = "linear" + self.ch = ch + self.temb_ch = 0 + self.num_resolutions = len(ch_mult) + self.num_res_blocks = num_res_blocks + self.resolution = resolution + self.in_channels = in_channels + + # 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,)+tuple(ch_mult) + self.in_ch_mult = in_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): + 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(make_attn(block_in, attn_type=attn_type)) + 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 = make_attn(block_in, attn_type=attn_type) + self.mid.block_2 = ResnetBlock(in_channels=block_in, + out_channels=block_in, + temb_channels=self.temb_ch, + dropout=dropout) + + # end + self.norm_out = Normalize(block_in) + self.conv_out = torch.nn.Conv2d(block_in, + 2*z_channels if double_z else z_channels, + kernel_size=3, + stride=1, + padding=1) + + def forward(self, x): + # timestep embedding + temb = None + + # downsampling + hs = [self.conv_in(x)] + for i_level in range(self.num_resolutions): + for i_block in range(self.num_res_blocks): + 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])) + + # middle + h = hs[-1] + h = self.mid.block_1(h, temb) + h = self.mid.attn_1(h) + h = self.mid.block_2(h, temb) + + # end + h = self.norm_out(h) + h = nonlinearity(h) + h = self.conv_out(h) + return h + + +class Decoder(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, z_channels, give_pre_end=False, tanh_out=False, use_linear_attn=False, + attn_type="vanilla", **ignorekwargs): + super().__init__() + if use_linear_attn: attn_type = "linear" + self.ch = ch + self.temb_ch = 0 + self.num_resolutions = len(ch_mult) + self.num_res_blocks = num_res_blocks + self.resolution = resolution + self.in_channels = in_channels + self.give_pre_end = give_pre_end + self.tanh_out = tanh_out + + # compute in_ch_mult, block_in and curr_res at lowest res + in_ch_mult = (1,)+tuple(ch_mult) + block_in = ch*ch_mult[self.num_resolutions-1] + curr_res = resolution // 2**(self.num_resolutions-1) + self.z_shape = (1,z_channels,curr_res,curr_res) + print("Working with z of shape {} = {} dimensions.".format( + self.z_shape, np.prod(self.z_shape))) + + # z to block_in + self.conv_in = torch.nn.Conv2d(z_channels, + block_in, + kernel_size=3, + stride=1, + padding=1) + + # 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 = make_attn(block_in, attn_type=attn_type) + 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] + for i_block in range(self.num_res_blocks+1): + 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(make_attn(block_in, attn_type=attn_type)) + 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) + + def forward(self, z): + #assert z.shape[1:] == self.z_shape[1:] + self.last_z_shape = z.shape + + # timestep embedding + temb = None + + # z to block_in + h = self.conv_in(z) + + # middle + h = self.mid.block_1(h, temb) + h = self.mid.attn_1(h) + h = self.mid.block_2(h, temb) + + # 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](h, temb) + if len(self.up[i_level].attn) > 0: + h = self.up[i_level].attn[i_block](h) + if i_level != 0: + h = self.up[i_level].upsample(h) + + # end + if self.give_pre_end: + return h + + h = self.norm_out(h) + h = nonlinearity(h) + h = self.conv_out(h) + if self.tanh_out: + h = torch.tanh(h) + return h + + +class SimpleDecoder(nn.Module): + def __init__(self, in_channels, out_channels, *args, **kwargs): + super().__init__() + self.model = nn.ModuleList([nn.Conv2d(in_channels, in_channels, 1), + ResnetBlock(in_channels=in_channels, + out_channels=2 * in_channels, + temb_channels=0, dropout=0.0), + ResnetBlock(in_channels=2 * in_channels, + out_channels=4 * in_channels, + temb_channels=0, dropout=0.0), + ResnetBlock(in_channels=4 * in_channels, + out_channels=2 * in_channels, + temb_channels=0, dropout=0.0), + nn.Conv2d(2*in_channels, in_channels, 1), + Upsample(in_channels, with_conv=True)]) + # end + self.norm_out = Normalize(in_channels) + self.conv_out = torch.nn.Conv2d(in_channels, + out_channels, + kernel_size=3, + stride=1, + padding=1) + + def forward(self, x): + for i, layer in enumerate(self.model): + if i in [1,2,3]: + x = layer(x, None) + else: + x = layer(x) + + h = self.norm_out(x) + h = nonlinearity(h) + x = self.conv_out(h) + return x + + +class UpsampleDecoder(nn.Module): + def __init__(self, in_channels, out_channels, ch, num_res_blocks, resolution, + ch_mult=(2,2), dropout=0.0): + super().__init__() + # upsampling + self.temb_ch = 0 + self.num_resolutions = len(ch_mult) + self.num_res_blocks = num_res_blocks + block_in = in_channels + curr_res = resolution // 2 ** (self.num_resolutions - 1) + self.res_blocks = nn.ModuleList() + self.upsample_blocks = nn.ModuleList() + for i_level in range(self.num_resolutions): + res_block = [] + block_out = ch * ch_mult[i_level] + for i_block in range(self.num_res_blocks + 1): + res_block.append(ResnetBlock(in_channels=block_in, + out_channels=block_out, + temb_channels=self.temb_ch, + dropout=dropout)) + block_in = block_out + self.res_blocks.append(nn.ModuleList(res_block)) + if i_level != self.num_resolutions - 1: + self.upsample_blocks.append(Upsample(block_in, True)) + curr_res = curr_res * 2 + + # end + self.norm_out = Normalize(block_in) + self.conv_out = torch.nn.Conv2d(block_in, + out_channels, + kernel_size=3, + stride=1, + padding=1) + + def forward(self, x): + # upsampling + h = x + for k, i_level in enumerate(range(self.num_resolutions)): + for i_block in range(self.num_res_blocks + 1): + h = self.res_blocks[i_level][i_block](h, None) + if i_level != self.num_resolutions - 1: + h = self.upsample_blocks[k](h) + h = self.norm_out(h) + h = nonlinearity(h) + h = self.conv_out(h) + return h + + +class LatentRescaler(nn.Module): + def __init__(self, factor, in_channels, mid_channels, out_channels, depth=2): + super().__init__() + # residual block, interpolate, residual block + self.factor = factor + self.conv_in = nn.Conv2d(in_channels, + mid_channels, + kernel_size=3, + stride=1, + padding=1) + self.res_block1 = nn.ModuleList([ResnetBlock(in_channels=mid_channels, + out_channels=mid_channels, + temb_channels=0, + dropout=0.0) for _ in range(depth)]) + self.attn = AttnBlock(mid_channels) + self.res_block2 = nn.ModuleList([ResnetBlock(in_channels=mid_channels, + out_channels=mid_channels, + temb_channels=0, + dropout=0.0) for _ in range(depth)]) + + self.conv_out = nn.Conv2d(mid_channels, + out_channels, + kernel_size=1, + ) + + def forward(self, x): + x = self.conv_in(x) + for block in self.res_block1: + x = block(x, None) + x = torch.nn.functional.interpolate(x, size=(int(round(x.shape[2]*self.factor)), int(round(x.shape[3]*self.factor)))) + x = self.attn(x) + for block in self.res_block2: + x = block(x, None) + x = self.conv_out(x) + return x + + +class MergedRescaleEncoder(nn.Module): + def __init__(self, in_channels, ch, resolution, out_ch, num_res_blocks, + attn_resolutions, dropout=0.0, resamp_with_conv=True, + ch_mult=(1,2,4,8), rescale_factor=1.0, rescale_module_depth=1): + super().__init__() + intermediate_chn = ch * ch_mult[-1] + self.encoder = Encoder(in_channels=in_channels, num_res_blocks=num_res_blocks, ch=ch, ch_mult=ch_mult, + z_channels=intermediate_chn, double_z=False, resolution=resolution, + attn_resolutions=attn_resolutions, dropout=dropout, resamp_with_conv=resamp_with_conv, + out_ch=None) + self.rescaler = LatentRescaler(factor=rescale_factor, in_channels=intermediate_chn, + mid_channels=intermediate_chn, out_channels=out_ch, depth=rescale_module_depth) + + def forward(self, x): + x = self.encoder(x) + x = self.rescaler(x) + return x + + +class MergedRescaleDecoder(nn.Module): + def __init__(self, z_channels, out_ch, resolution, num_res_blocks, attn_resolutions, ch, ch_mult=(1,2,4,8), + dropout=0.0, resamp_with_conv=True, rescale_factor=1.0, rescale_module_depth=1): + super().__init__() + tmp_chn = z_channels*ch_mult[-1] + self.decoder = Decoder(out_ch=out_ch, z_channels=tmp_chn, attn_resolutions=attn_resolutions, dropout=dropout, + resamp_with_conv=resamp_with_conv, in_channels=None, num_res_blocks=num_res_blocks, + ch_mult=ch_mult, resolution=resolution, ch=ch) + self.rescaler = LatentRescaler(factor=rescale_factor, in_channels=z_channels, mid_channels=tmp_chn, + out_channels=tmp_chn, depth=rescale_module_depth) + + def forward(self, x): + x = self.rescaler(x) + x = self.decoder(x) + return x + + +class Upsampler(nn.Module): + def __init__(self, in_size, out_size, in_channels, out_channels, ch_mult=2): + super().__init__() + assert out_size >= in_size + num_blocks = int(np.log2(out_size//in_size))+1 + factor_up = 1.+ (out_size % in_size) + print(f"Building {self.__class__.__name__} with in_size: {in_size} --> out_size {out_size} and factor {factor_up}") + self.rescaler = LatentRescaler(factor=factor_up, in_channels=in_channels, mid_channels=2*in_channels, + out_channels=in_channels) + self.decoder = Decoder(out_ch=out_channels, resolution=out_size, z_channels=in_channels, num_res_blocks=2, + attn_resolutions=[], in_channels=None, ch=in_channels, + ch_mult=[ch_mult for _ in range(num_blocks)]) + + def forward(self, x): + x = self.rescaler(x) + x = self.decoder(x) + return x + + +class Resize(nn.Module): + def __init__(self, in_channels=None, learned=False, mode="bilinear"): + super().__init__() + self.with_conv = learned + self.mode = mode + if self.with_conv: + print(f"Note: {self.__class__.__name} uses learned downsampling and will ignore the fixed {mode} mode") + raise NotImplementedError() + assert in_channels is not None + # no asymmetric padding in torch conv, must do it ourselves + self.conv = torch.nn.Conv2d(in_channels, + in_channels, + kernel_size=4, + stride=2, + padding=1) + + def forward(self, x, scale_factor=1.0): + if scale_factor==1.0: + return x + else: + x = torch.nn.functional.interpolate(x, mode=self.mode, align_corners=False, scale_factor=scale_factor) + return x diff --git a/ldm/modules/diffusionmodules/openaimodel.py b/ldm/modules/diffusionmodules/openaimodel.py new file mode 100644 index 0000000000000000000000000000000000000000..cc3875c63c86fb2e33a83de70a9601cba6b39148 --- /dev/null +++ b/ldm/modules/diffusionmodules/openaimodel.py @@ -0,0 +1,807 @@ +from abc import abstractmethod +import math + +import numpy as np +import torch as th +import torch.nn as nn +import torch.nn.functional as F + +from ldm.modules.diffusionmodules.util import ( + checkpoint, + conv_nd, + linear, + avg_pool_nd, + zero_module, + normalization, + timestep_embedding, +) +from ldm.modules.attention import SpatialTransformer +from ldm.util import exists + + +# dummy replace +def convert_module_to_f16(x): + pass + +def convert_module_to_f32(x): + pass + + +## go +class AttentionPool2d(nn.Module): + """ + Adapted from CLIP: https://github.com/openai/CLIP/blob/main/clip/model.py + """ + + def __init__( + self, + spacial_dim: int, + embed_dim: int, + num_heads_channels: int, + output_dim: int = None, + ): + super().__init__() + self.positional_embedding = nn.Parameter(th.randn(embed_dim, spacial_dim ** 2 + 1) / embed_dim ** 0.5) + self.qkv_proj = conv_nd(1, embed_dim, 3 * embed_dim, 1) + self.c_proj = conv_nd(1, embed_dim, output_dim or embed_dim, 1) + self.num_heads = embed_dim // num_heads_channels + self.attention = QKVAttention(self.num_heads) + + def forward(self, x): + b, c, *_spatial = x.shape + x = x.reshape(b, c, -1) # NC(HW) + x = th.cat([x.mean(dim=-1, keepdim=True), x], dim=-1) # NC(HW+1) + x = x + self.positional_embedding[None, :, :].to(x.dtype) # NC(HW+1) + x = self.qkv_proj(x) + x = self.attention(x) + x = self.c_proj(x) + return x[:, :, 0] + + +class TimestepBlock(nn.Module): + """ + Any module where forward() takes timestep embeddings as a second argument. + """ + + @abstractmethod + def forward(self, x, emb): + """ + Apply the module to `x` given `emb` timestep embeddings. + """ + + +class TimestepEmbedSequential(nn.Sequential, TimestepBlock): + """ + A sequential module that passes timestep embeddings to the children that + support it as an extra input. + """ + + def forward(self, x, emb, context=None): + for layer in self: + if isinstance(layer, TimestepBlock): + x = layer(x, emb) + elif isinstance(layer, SpatialTransformer): + x = layer(x, context) + else: + x = layer(x) + return x + + +class Upsample(nn.Module): + """ + An upsampling layer with an optional convolution. + :param channels: channels in the inputs and outputs. + :param use_conv: a bool determining if a convolution is applied. + :param dims: determines if the signal is 1D, 2D, or 3D. If 3D, then + upsampling occurs in the inner-two dimensions. + """ + + def __init__(self, channels, use_conv, dims=2, out_channels=None, padding=1): + super().__init__() + self.channels = channels + self.out_channels = out_channels or channels + self.use_conv = use_conv + self.dims = dims + if use_conv: + self.conv = conv_nd(dims, self.channels, self.out_channels, 3, padding=padding) + + def forward(self, x): + assert x.shape[1] == self.channels + if self.dims == 3: + x = F.interpolate( + x, (x.shape[2], x.shape[3] * 2, x.shape[4] * 2), mode="nearest" + ) + else: + x = F.interpolate(x, scale_factor=2, mode="nearest") + if self.use_conv: + x = self.conv(x) + return x + +class TransposedUpsample(nn.Module): + 'Learned 2x upsampling without padding' + def __init__(self, channels, out_channels=None, ks=5): + super().__init__() + self.channels = channels + self.out_channels = out_channels or channels + + self.up = nn.ConvTranspose2d(self.channels,self.out_channels,kernel_size=ks,stride=2) + + def forward(self,x): + return self.up(x) + + +class Downsample(nn.Module): + """ + A downsampling layer with an optional convolution. + :param channels: channels in the inputs and outputs. + :param use_conv: a bool determining if a convolution is applied. + :param dims: determines if the signal is 1D, 2D, or 3D. If 3D, then + downsampling occurs in the inner-two dimensions. + """ + + def __init__(self, channels, use_conv, dims=2, out_channels=None,padding=1): + super().__init__() + self.channels = channels + self.out_channels = out_channels or channels + self.use_conv = use_conv + self.dims = dims + stride = 2 if dims != 3 else (1, 2, 2) + if use_conv: + self.op = conv_nd( + dims, self.channels, self.out_channels, 3, stride=stride, padding=padding + ) + else: + assert self.channels == self.out_channels + self.op = avg_pool_nd(dims, kernel_size=stride, stride=stride) + + def forward(self, x): + assert x.shape[1] == self.channels + return self.op(x) + + +class ResBlock(TimestepBlock): + """ + A residual block that can optionally change the number of channels. + :param channels: the number of input channels. + :param emb_channels: the number of timestep embedding channels. + :param dropout: the rate of dropout. + :param out_channels: if specified, the number of out channels. + :param use_conv: if True and out_channels is specified, use a spatial + convolution instead of a smaller 1x1 convolution to change the + channels in the skip connection. + :param dims: determines if the signal is 1D, 2D, or 3D. + :param use_checkpoint: if True, use gradient checkpointing on this module. + :param up: if True, use this block for upsampling. + :param down: if True, use this block for downsampling. + """ + + def __init__( + self, + channels, + emb_channels, + dropout, + out_channels=None, + use_conv=False, + use_scale_shift_norm=False, + dims=2, + use_checkpoint=False, + up=False, + down=False, + ): + super().__init__() + self.channels = channels + self.emb_channels = emb_channels + self.dropout = dropout + self.out_channels = out_channels or channels + self.use_conv = use_conv + self.use_checkpoint = use_checkpoint + self.use_scale_shift_norm = use_scale_shift_norm + + self.in_layers = nn.Sequential( + normalization(channels), + nn.SiLU(), + conv_nd(dims, channels, self.out_channels, 3, padding=1), + ) + + self.updown = up or down + + if up: + self.h_upd = Upsample(channels, False, dims) + self.x_upd = Upsample(channels, False, dims) + elif down: + self.h_upd = Downsample(channels, False, dims) + self.x_upd = Downsample(channels, False, dims) + else: + self.h_upd = self.x_upd = nn.Identity() + + self.emb_layers = nn.Sequential( + nn.SiLU(), + linear( + emb_channels, + 2 * self.out_channels if use_scale_shift_norm else self.out_channels, + ), + ) + self.out_layers = nn.Sequential( + normalization(self.out_channels), + nn.SiLU(), + nn.Dropout(p=dropout), + zero_module( + conv_nd(dims, self.out_channels, self.out_channels, 3, padding=1) + ), + ) + + if self.out_channels == channels: + self.skip_connection = nn.Identity() + elif use_conv: + self.skip_connection = conv_nd( + dims, channels, self.out_channels, 3, padding=1 + ) + else: + self.skip_connection = conv_nd(dims, channels, self.out_channels, 1) + + def forward(self, x, emb): + """ + Apply the block to a Tensor, conditioned on a timestep embedding. + :param x: an [N x C x ...] Tensor of features. + :param emb: an [N x emb_channels] Tensor of timestep embeddings. + :return: an [N x C x ...] Tensor of outputs. + """ + return checkpoint( + self._forward, (x, emb), self.parameters(), self.use_checkpoint + ) + + + def _forward(self, x, emb): + if self.updown: + in_rest, in_conv = self.in_layers[:-1], self.in_layers[-1] + h = in_rest(x) + h = self.h_upd(h) + x = self.x_upd(x) + h = in_conv(h) + else: + h = self.in_layers(x) + emb_out = self.emb_layers(emb).type(h.dtype) + while len(emb_out.shape) < len(h.shape): + emb_out = emb_out[..., None] + if self.use_scale_shift_norm: + out_norm, out_rest = self.out_layers[0], self.out_layers[1:] + scale, shift = th.chunk(emb_out, 2, dim=1) + h = out_norm(h) * (1 + scale) + shift + h = out_rest(h) + else: + h = h + emb_out + h = self.out_layers(h) + return self.skip_connection(x) + h + + +class AttentionBlock(nn.Module): + """ + An attention block that allows spatial positions to attend to each other. + Originally ported from here, but adapted to the N-d case. + https://github.com/hojonathanho/diffusion/blob/1e0dceb3b3495bbe19116a5e1b3596cd0706c543/diffusion_tf/models/unet.py#L66. + """ + + def __init__( + self, + channels, + num_heads=1, + num_head_channels=-1, + use_checkpoint=False, + use_new_attention_order=False, + ): + super().__init__() + self.channels = channels + if num_head_channels == -1: + self.num_heads = num_heads + else: + assert ( + channels % num_head_channels == 0 + ), f"q,k,v channels {channels} is not divisible by num_head_channels {num_head_channels}" + self.num_heads = channels // num_head_channels + self.use_checkpoint = use_checkpoint + self.norm = normalization(channels) + self.qkv = conv_nd(1, channels, channels * 3, 1) + if use_new_attention_order: + # split qkv before split heads + self.attention = QKVAttention(self.num_heads) + else: + # split heads before split qkv + self.attention = QKVAttentionLegacy(self.num_heads) + + self.proj_out = zero_module(conv_nd(1, channels, channels, 1)) + + def forward(self, x): + return checkpoint(self._forward, (x,), self.parameters(), True) # TODO: check checkpoint usage, is True # TODO: fix the .half call!!! + #return pt_checkpoint(self._forward, x) # pytorch + + def _forward(self, x): + b, c, *spatial = x.shape + x = x.reshape(b, c, -1) + qkv = self.qkv(self.norm(x)) + h = self.attention(qkv) + h = self.proj_out(h) + return (x + h).reshape(b, c, *spatial) + + +def count_flops_attn(model, _x, y): + """ + A counter for the `thop` package to count the operations in an + attention operation. + Meant to be used like: + macs, params = thop.profile( + model, + inputs=(inputs, timestamps), + custom_ops={QKVAttention: QKVAttention.count_flops}, + ) + """ + b, c, *spatial = y[0].shape + num_spatial = int(np.prod(spatial)) + # We perform two matmuls with the same number of ops. + # The first computes the weight matrix, the second computes + # the combination of the value vectors. + matmul_ops = 2 * b * (num_spatial ** 2) * c + model.total_ops += th.DoubleTensor([matmul_ops]) + + +class QKVAttentionLegacy(nn.Module): + """ + A module which performs QKV attention. Matches legacy QKVAttention + input/ouput heads shaping + """ + + def __init__(self, n_heads): + super().__init__() + self.n_heads = n_heads + + def forward(self, qkv): + """ + Apply QKV attention. + :param qkv: an [N x (H * 3 * C) x T] tensor of Qs, Ks, and Vs. + :return: an [N x (H * C) x T] tensor after attention. + """ + bs, width, length = qkv.shape + assert width % (3 * self.n_heads) == 0 + ch = width // (3 * self.n_heads) + q, k, v = qkv.reshape(bs * self.n_heads, ch * 3, length).split(ch, dim=1) + scale = 1 / math.sqrt(math.sqrt(ch)) + weight = th.einsum( + "bct,bcs->bts", q * scale, k * scale + ) # More stable with f16 than dividing afterwards + weight = th.softmax(weight.float(), dim=-1).type(weight.dtype) + a = th.einsum("bts,bcs->bct", weight, v) + return a.reshape(bs, -1, length) + + @staticmethod + def count_flops(model, _x, y): + return count_flops_attn(model, _x, y) + + +class QKVAttention(nn.Module): + """ + A module which performs QKV attention and splits in a different order. + """ + + def __init__(self, n_heads): + super().__init__() + self.n_heads = n_heads + + def forward(self, qkv): + """ + Apply QKV attention. + :param qkv: an [N x (3 * H * C) x T] tensor of Qs, Ks, and Vs. + :return: an [N x (H * C) x T] tensor after attention. + """ + bs, width, length = qkv.shape + assert width % (3 * self.n_heads) == 0 + ch = width // (3 * self.n_heads) + q, k, v = qkv.chunk(3, dim=1) + scale = 1 / math.sqrt(math.sqrt(ch)) + weight = th.einsum( + "bct,bcs->bts", + (q * scale).view(bs * self.n_heads, ch, length), + (k * scale).view(bs * self.n_heads, ch, length), + ) # More stable with f16 than dividing afterwards + weight = th.softmax(weight.float(), dim=-1).type(weight.dtype) + a = th.einsum("bts,bcs->bct", weight, v.reshape(bs * self.n_heads, ch, length)) + return a.reshape(bs, -1, length) + + @staticmethod + def count_flops(model, _x, y): + return count_flops_attn(model, _x, y) + + +class Timestep(nn.Module): + def __init__(self, dim): + super().__init__() + self.dim = dim + + def forward(self, t): + return timestep_embedding(t, self.dim) + + +class UNetModel(nn.Module): + """ + The full UNet model with attention and timestep embedding. + :param in_channels: channels in the input Tensor. + :param model_channels: base channel count for the model. + :param out_channels: channels in the output Tensor. + :param num_res_blocks: number of residual blocks per downsample. + :param attention_resolutions: a collection of downsample rates at which + attention will take place. May be a set, list, or tuple. + For example, if this contains 4, then at 4x downsampling, attention + will be used. + :param dropout: the dropout probability. + :param channel_mult: channel multiplier for each level of the UNet. + :param conv_resample: if True, use learned convolutions for upsampling and + downsampling. + :param dims: determines if the signal is 1D, 2D, or 3D. + :param num_classes: if specified (as an int), then this model will be + class-conditional with `num_classes` classes. + :param use_checkpoint: use gradient checkpointing to reduce memory usage. + :param num_heads: the number of attention heads in each attention layer. + :param num_heads_channels: if specified, ignore num_heads and instead use + a fixed channel width per attention head. + :param num_heads_upsample: works with num_heads to set a different number + of heads for upsampling. Deprecated. + :param use_scale_shift_norm: use a FiLM-like conditioning mechanism. + :param resblock_updown: use residual blocks for up/downsampling. + :param use_new_attention_order: use a different attention pattern for potentially + increased efficiency. + """ + + def __init__( + self, + image_size, + in_channels, + model_channels, + out_channels, + num_res_blocks, + attention_resolutions, + dropout=0, + channel_mult=(1, 2, 4, 8), + conv_resample=True, + dims=2, + num_classes=None, + use_checkpoint=False, + use_fp16=False, + use_bf16=False, + num_heads=-1, + num_head_channels=-1, + num_heads_upsample=-1, + use_scale_shift_norm=False, + resblock_updown=False, + use_new_attention_order=False, + use_spatial_transformer=False, # custom transformer support + transformer_depth=1, # custom transformer support + context_dim=None, # custom transformer support + n_embed=None, # custom support for prediction of discrete ids into codebook of first stage vq model + legacy=True, + disable_self_attentions=None, + num_attention_blocks=None, + disable_middle_self_attn=False, + use_linear_in_transformer=False, + adm_in_channels=None, + ): + super().__init__() + if use_spatial_transformer: + assert context_dim is not None, 'Fool!! You forgot to include the dimension of your cross-attention conditioning...' + + if context_dim is not None: + assert use_spatial_transformer, 'Fool!! You forgot to use the spatial transformer for your cross-attention conditioning...' + from omegaconf.listconfig import ListConfig + if type(context_dim) == ListConfig: + context_dim = list(context_dim) + + if num_heads_upsample == -1: + num_heads_upsample = num_heads + + if num_heads == -1: + assert num_head_channels != -1, 'Either num_heads or num_head_channels has to be set' + + if num_head_channels == -1: + assert num_heads != -1, 'Either num_heads or num_head_channels has to be set' + + self.image_size = image_size + self.in_channels = in_channels + self.model_channels = model_channels + self.out_channels = out_channels + if isinstance(num_res_blocks, int): + self.num_res_blocks = len(channel_mult) * [num_res_blocks] + else: + if len(num_res_blocks) != len(channel_mult): + raise ValueError("provide num_res_blocks either as an int (globally constant) or " + "as a list/tuple (per-level) with the same length as channel_mult") + self.num_res_blocks = num_res_blocks + if disable_self_attentions is not None: + # should be a list of booleans, indicating whether to disable self-attention in TransformerBlocks or not + assert len(disable_self_attentions) == len(channel_mult) + if num_attention_blocks is not None: + assert len(num_attention_blocks) == len(self.num_res_blocks) + assert all(map(lambda i: self.num_res_blocks[i] >= num_attention_blocks[i], range(len(num_attention_blocks)))) + print(f"Constructor of UNetModel received num_attention_blocks={num_attention_blocks}. " + f"This option has LESS priority than attention_resolutions {attention_resolutions}, " + f"i.e., in cases where num_attention_blocks[i] > 0 but 2**i not in attention_resolutions, " + f"attention will still not be set.") + + self.attention_resolutions = attention_resolutions + self.dropout = dropout + self.channel_mult = channel_mult + self.conv_resample = conv_resample + self.num_classes = num_classes + self.use_checkpoint = use_checkpoint + self.dtype = th.float16 if use_fp16 else th.float32 + self.dtype = th.bfloat16 if use_bf16 else self.dtype + self.num_heads = num_heads + self.num_head_channels = num_head_channels + self.num_heads_upsample = num_heads_upsample + self.predict_codebook_ids = n_embed is not None + + time_embed_dim = model_channels * 4 + self.time_embed = nn.Sequential( + linear(model_channels, time_embed_dim), + nn.SiLU(), + linear(time_embed_dim, time_embed_dim), + ) + + if self.num_classes is not None: + if isinstance(self.num_classes, int): + self.label_emb = nn.Embedding(num_classes, time_embed_dim) + elif self.num_classes == "continuous": + print("setting up linear c_adm embedding layer") + self.label_emb = nn.Linear(1, time_embed_dim) + elif self.num_classes == "sequential": + assert adm_in_channels is not None + self.label_emb = nn.Sequential( + nn.Sequential( + linear(adm_in_channels, time_embed_dim), + nn.SiLU(), + linear(time_embed_dim, time_embed_dim), + ) + ) + else: + raise ValueError() + + self.input_blocks = nn.ModuleList( + [ + TimestepEmbedSequential( + conv_nd(dims, in_channels, model_channels, 3, padding=1) + ) + ] + ) + self._feature_size = model_channels + input_block_chans = [model_channels] + ch = model_channels + ds = 1 + for level, mult in enumerate(channel_mult): + for nr in range(self.num_res_blocks[level]): + layers = [ + ResBlock( + ch, + time_embed_dim, + dropout, + out_channels=mult * model_channels, + dims=dims, + use_checkpoint=use_checkpoint, + use_scale_shift_norm=use_scale_shift_norm, + ) + ] + ch = mult * model_channels + if ds in attention_resolutions: + if num_head_channels == -1: + dim_head = ch // num_heads + else: + num_heads = ch // num_head_channels + dim_head = num_head_channels + if legacy: + #num_heads = 1 + dim_head = ch // num_heads if use_spatial_transformer else num_head_channels + if exists(disable_self_attentions): + disabled_sa = disable_self_attentions[level] + else: + disabled_sa = False + + if not exists(num_attention_blocks) or nr < num_attention_blocks[level]: + layers.append( + AttentionBlock( + ch, + use_checkpoint=use_checkpoint, + num_heads=num_heads, + num_head_channels=dim_head, + use_new_attention_order=use_new_attention_order, + ) if not use_spatial_transformer else SpatialTransformer( + ch, num_heads, dim_head, depth=transformer_depth, context_dim=context_dim, + disable_self_attn=disabled_sa, use_linear=use_linear_in_transformer, + use_checkpoint=use_checkpoint + ) + ) + self.input_blocks.append(TimestepEmbedSequential(*layers)) + self._feature_size += ch + input_block_chans.append(ch) + if level != len(channel_mult) - 1: + out_ch = ch + self.input_blocks.append( + TimestepEmbedSequential( + ResBlock( + ch, + time_embed_dim, + dropout, + out_channels=out_ch, + dims=dims, + use_checkpoint=use_checkpoint, + use_scale_shift_norm=use_scale_shift_norm, + down=True, + ) + if resblock_updown + else Downsample( + ch, conv_resample, dims=dims, out_channels=out_ch + ) + ) + ) + ch = out_ch + input_block_chans.append(ch) + ds *= 2 + self._feature_size += ch + + if num_head_channels == -1: + dim_head = ch // num_heads + else: + num_heads = ch // num_head_channels + dim_head = num_head_channels + if legacy: + #num_heads = 1 + dim_head = ch // num_heads if use_spatial_transformer else num_head_channels + self.middle_block = TimestepEmbedSequential( + ResBlock( + ch, + time_embed_dim, + dropout, + dims=dims, + use_checkpoint=use_checkpoint, + use_scale_shift_norm=use_scale_shift_norm, + ), + AttentionBlock( + ch, + use_checkpoint=use_checkpoint, + num_heads=num_heads, + num_head_channels=dim_head, + use_new_attention_order=use_new_attention_order, + ) if not use_spatial_transformer else SpatialTransformer( # always uses a self-attn + ch, num_heads, dim_head, depth=transformer_depth, context_dim=context_dim, + disable_self_attn=disable_middle_self_attn, use_linear=use_linear_in_transformer, + use_checkpoint=use_checkpoint + ), + ResBlock( + ch, + time_embed_dim, + dropout, + dims=dims, + use_checkpoint=use_checkpoint, + use_scale_shift_norm=use_scale_shift_norm, + ), + ) + self._feature_size += ch + + self.output_blocks = nn.ModuleList([]) + for level, mult in list(enumerate(channel_mult))[::-1]: + for i in range(self.num_res_blocks[level] + 1): + ich = input_block_chans.pop() + layers = [ + ResBlock( + ch + ich, + time_embed_dim, + dropout, + out_channels=model_channels * mult, + dims=dims, + use_checkpoint=use_checkpoint, + use_scale_shift_norm=use_scale_shift_norm, + ) + ] + ch = model_channels * mult + if ds in attention_resolutions: + if num_head_channels == -1: + dim_head = ch // num_heads + else: + num_heads = ch // num_head_channels + dim_head = num_head_channels + if legacy: + #num_heads = 1 + dim_head = ch // num_heads if use_spatial_transformer else num_head_channels + if exists(disable_self_attentions): + disabled_sa = disable_self_attentions[level] + else: + disabled_sa = False + + if not exists(num_attention_blocks) or i < num_attention_blocks[level]: + layers.append( + AttentionBlock( + ch, + use_checkpoint=use_checkpoint, + num_heads=num_heads_upsample, + num_head_channels=dim_head, + use_new_attention_order=use_new_attention_order, + ) if not use_spatial_transformer else SpatialTransformer( + ch, num_heads, dim_head, depth=transformer_depth, context_dim=context_dim, + disable_self_attn=disabled_sa, use_linear=use_linear_in_transformer, + use_checkpoint=use_checkpoint + ) + ) + if level and i == self.num_res_blocks[level]: + out_ch = ch + layers.append( + ResBlock( + ch, + time_embed_dim, + dropout, + out_channels=out_ch, + dims=dims, + use_checkpoint=use_checkpoint, + use_scale_shift_norm=use_scale_shift_norm, + up=True, + ) + if resblock_updown + else Upsample(ch, conv_resample, dims=dims, out_channels=out_ch) + ) + ds //= 2 + self.output_blocks.append(TimestepEmbedSequential(*layers)) + self._feature_size += ch + + self.out = nn.Sequential( + normalization(ch), + nn.SiLU(), + zero_module(conv_nd(dims, model_channels, out_channels, 3, padding=1)), + ) + if self.predict_codebook_ids: + self.id_predictor = nn.Sequential( + normalization(ch), + conv_nd(dims, model_channels, n_embed, 1), + #nn.LogSoftmax(dim=1) # change to cross_entropy and produce non-normalized logits + ) + + def convert_to_fp16(self): + """ + Convert the torso of the model to float16. + """ + self.input_blocks.apply(convert_module_to_f16) + self.middle_block.apply(convert_module_to_f16) + self.output_blocks.apply(convert_module_to_f16) + + def convert_to_fp32(self): + """ + Convert the torso of the model to float32. + """ + self.input_blocks.apply(convert_module_to_f32) + self.middle_block.apply(convert_module_to_f32) + self.output_blocks.apply(convert_module_to_f32) + + def forward(self, x, timesteps=None, context=None, y=None,**kwargs): + """ + Apply the model to an input batch. + :param x: an [N x C x ...] Tensor of inputs. + :param timesteps: a 1-D batch of timesteps. + :param context: conditioning plugged in via crossattn + :param y: an [N] Tensor of labels, if class-conditional. + :return: an [N x C x ...] Tensor of outputs. + """ + assert (y is not None) == ( + self.num_classes is not None + ), "must specify y if and only if the model is class-conditional" + hs = [] + t_emb = timestep_embedding(timesteps, self.model_channels, repeat_only=False) + emb = self.time_embed(t_emb) + + if self.num_classes is not None: + assert y.shape[0] == x.shape[0] + emb = emb + self.label_emb(y) + + h = x.type(self.dtype) + for module in self.input_blocks: + h = module(h, emb, context) + hs.append(h) + h = self.middle_block(h, emb, context) + for module in self.output_blocks: + h = th.cat([h, hs.pop()], dim=1) + h = module(h, emb, context) + h = h.type(x.dtype) + if self.predict_codebook_ids: + return self.id_predictor(h) + else: + return self.out(h) diff --git a/ldm/modules/diffusionmodules/upscaling.py b/ldm/modules/diffusionmodules/upscaling.py new file mode 100644 index 0000000000000000000000000000000000000000..03816662098ce1ffac79bd939b892e867ab91988 --- /dev/null +++ b/ldm/modules/diffusionmodules/upscaling.py @@ -0,0 +1,81 @@ +import torch +import torch.nn as nn +import numpy as np +from functools import partial + +from ldm.modules.diffusionmodules.util import extract_into_tensor, make_beta_schedule +from ldm.util import default + + +class AbstractLowScaleModel(nn.Module): + # for concatenating a downsampled image to the latent representation + def __init__(self, noise_schedule_config=None): + super(AbstractLowScaleModel, self).__init__() + if noise_schedule_config is not None: + self.register_schedule(**noise_schedule_config) + + def register_schedule(self, beta_schedule="linear", timesteps=1000, + linear_start=1e-4, linear_end=2e-2, cosine_s=8e-3): + betas = make_beta_schedule(beta_schedule, timesteps, linear_start=linear_start, linear_end=linear_end, + cosine_s=cosine_s) + alphas = 1. - betas + alphas_cumprod = np.cumprod(alphas, axis=0) + alphas_cumprod_prev = np.append(1., alphas_cumprod[:-1]) + + timesteps, = betas.shape + self.num_timesteps = int(timesteps) + self.linear_start = linear_start + self.linear_end = linear_end + assert alphas_cumprod.shape[0] == self.num_timesteps, 'alphas have to be defined for each timestep' + + to_torch = partial(torch.tensor, dtype=torch.float32) + + self.register_buffer('betas', to_torch(betas)) + self.register_buffer('alphas_cumprod', to_torch(alphas_cumprod)) + self.register_buffer('alphas_cumprod_prev', to_torch(alphas_cumprod_prev)) + + # calculations for diffusion q(x_t | x_{t-1}) and others + self.register_buffer('sqrt_alphas_cumprod', to_torch(np.sqrt(alphas_cumprod))) + self.register_buffer('sqrt_one_minus_alphas_cumprod', to_torch(np.sqrt(1. - alphas_cumprod))) + self.register_buffer('log_one_minus_alphas_cumprod', to_torch(np.log(1. - alphas_cumprod))) + self.register_buffer('sqrt_recip_alphas_cumprod', to_torch(np.sqrt(1. / alphas_cumprod))) + self.register_buffer('sqrt_recipm1_alphas_cumprod', to_torch(np.sqrt(1. / alphas_cumprod - 1))) + + def q_sample(self, x_start, t, noise=None): + noise = default(noise, lambda: torch.randn_like(x_start)) + return (extract_into_tensor(self.sqrt_alphas_cumprod, t, x_start.shape) * x_start + + extract_into_tensor(self.sqrt_one_minus_alphas_cumprod, t, x_start.shape) * noise) + + def forward(self, x): + return x, None + + def decode(self, x): + return x + + +class SimpleImageConcat(AbstractLowScaleModel): + # no noise level conditioning + def __init__(self): + super(SimpleImageConcat, self).__init__(noise_schedule_config=None) + self.max_noise_level = 0 + + def forward(self, x): + # fix to constant noise level + return x, torch.zeros(x.shape[0], device=x.device).long() + + +class ImageConcatWithNoiseAugmentation(AbstractLowScaleModel): + def __init__(self, noise_schedule_config, max_noise_level=1000, to_cuda=False): + super().__init__(noise_schedule_config=noise_schedule_config) + self.max_noise_level = max_noise_level + + def forward(self, x, noise_level=None): + if noise_level is None: + noise_level = torch.randint(0, self.max_noise_level, (x.shape[0],), device=x.device).long() + else: + assert isinstance(noise_level, torch.Tensor) + z = self.q_sample(x, noise_level) + return z, noise_level + + + diff --git a/ldm/modules/diffusionmodules/util.py b/ldm/modules/diffusionmodules/util.py new file mode 100644 index 0000000000000000000000000000000000000000..daf35da7bae05b9a2880dbc923b70e129e2c904d --- /dev/null +++ b/ldm/modules/diffusionmodules/util.py @@ -0,0 +1,278 @@ +# adopted from +# https://github.com/openai/improved-diffusion/blob/main/improved_diffusion/gaussian_diffusion.py +# and +# https://github.com/lucidrains/denoising-diffusion-pytorch/blob/7706bdfc6f527f58d33f84b7b522e61e6e3164b3/denoising_diffusion_pytorch/denoising_diffusion_pytorch.py +# and +# https://github.com/openai/guided-diffusion/blob/0ba878e517b276c45d1195eb29f6f5f72659a05b/guided_diffusion/nn.py +# +# thanks! + + +import os +import math +import torch +import torch.nn as nn +import numpy as np +from einops import repeat + +from ldm.util import instantiate_from_config + + +def make_beta_schedule(schedule, n_timestep, linear_start=1e-4, linear_end=2e-2, cosine_s=8e-3): + if schedule == "linear": + betas = ( + torch.linspace(linear_start ** 0.5, linear_end ** 0.5, n_timestep, dtype=torch.float64) ** 2 + ) + + elif schedule == "cosine": + timesteps = ( + torch.arange(n_timestep + 1, dtype=torch.float64) / n_timestep + cosine_s + ) + alphas = timesteps / (1 + cosine_s) * np.pi / 2 + alphas = torch.cos(alphas).pow(2) + alphas = alphas / alphas[0] + betas = 1 - alphas[1:] / alphas[:-1] + betas = np.clip(betas, a_min=0, a_max=0.999) + + elif schedule == "squaredcos_cap_v2": # used for karlo prior + # return early + return betas_for_alpha_bar( + n_timestep, + lambda t: math.cos((t + 0.008) / 1.008 * math.pi / 2) ** 2, + ) + + elif schedule == "sqrt_linear": + betas = torch.linspace(linear_start, linear_end, n_timestep, dtype=torch.float64) + elif schedule == "sqrt": + betas = torch.linspace(linear_start, linear_end, n_timestep, dtype=torch.float64) ** 0.5 + else: + raise ValueError(f"schedule '{schedule}' unknown.") + return betas.numpy() + + +def make_ddim_timesteps(ddim_discr_method, num_ddim_timesteps, num_ddpm_timesteps, verbose=True): + if ddim_discr_method == 'uniform': + c = num_ddpm_timesteps // num_ddim_timesteps + ddim_timesteps = np.asarray(list(range(0, num_ddpm_timesteps, c))) + elif ddim_discr_method == 'quad': + ddim_timesteps = ((np.linspace(0, np.sqrt(num_ddpm_timesteps * .8), num_ddim_timesteps)) ** 2).astype(int) + else: + raise NotImplementedError(f'There is no ddim discretization method called "{ddim_discr_method}"') + + # assert ddim_timesteps.shape[0] == num_ddim_timesteps + # add one to get the final alpha values right (the ones from first scale to data during sampling) + steps_out = ddim_timesteps + 1 + if verbose: + print(f'Selected timesteps for ddim sampler: {steps_out}') + return steps_out + + +def make_ddim_sampling_parameters(alphacums, ddim_timesteps, eta, verbose=True): + # select alphas for computing the variance schedule + alphas = alphacums[ddim_timesteps] + alphas_prev = np.asarray([alphacums[0]] + alphacums[ddim_timesteps[:-1]].tolist()) + + # according the the formula provided in https://arxiv.org/abs/2010.02502 + sigmas = eta * np.sqrt((1 - alphas_prev) / (1 - alphas) * (1 - alphas / alphas_prev)) + if verbose: + print(f'Selected alphas for ddim sampler: a_t: {alphas}; a_(t-1): {alphas_prev}') + print(f'For the chosen value of eta, which is {eta}, ' + f'this results in the following sigma_t schedule for ddim sampler {sigmas}') + return sigmas, alphas, alphas_prev + + +def betas_for_alpha_bar(num_diffusion_timesteps, alpha_bar, max_beta=0.999): + """ + Create a beta schedule that discretizes the given alpha_t_bar function, + which defines the cumulative product of (1-beta) over time from t = [0,1]. + :param num_diffusion_timesteps: the number of betas to produce. + :param alpha_bar: a lambda that takes an argument t from 0 to 1 and + produces the cumulative product of (1-beta) up to that + part of the diffusion process. + :param max_beta: the maximum beta to use; use values lower than 1 to + prevent singularities. + """ + betas = [] + for i in range(num_diffusion_timesteps): + t1 = i / num_diffusion_timesteps + t2 = (i + 1) / num_diffusion_timesteps + betas.append(min(1 - alpha_bar(t2) / alpha_bar(t1), max_beta)) + return np.array(betas) + + +def extract_into_tensor(a, t, x_shape): + b, *_ = t.shape + out = a.gather(-1, t) + return out.reshape(b, *((1,) * (len(x_shape) - 1))) + + +def checkpoint(func, inputs, params, flag): + """ + Evaluate a function without caching intermediate activations, allowing for + reduced memory at the expense of extra compute in the backward pass. + :param func: the function to evaluate. + :param inputs: the argument sequence to pass to `func`. + :param params: a sequence of parameters `func` depends on but does not + explicitly take as arguments. + :param flag: if False, disable gradient checkpointing. + """ + if flag: + args = tuple(inputs) + tuple(params) + return CheckpointFunction.apply(func, len(inputs), *args) + else: + return func(*inputs) + + +class CheckpointFunction(torch.autograd.Function): + @staticmethod + def forward(ctx, run_function, length, *args): + ctx.run_function = run_function + ctx.input_tensors = list(args[:length]) + ctx.input_params = list(args[length:]) + ctx.gpu_autocast_kwargs = {"enabled": torch.is_autocast_enabled(), + "dtype": torch.get_autocast_gpu_dtype(), + "cache_enabled": torch.is_autocast_cache_enabled()} + with torch.no_grad(): + output_tensors = ctx.run_function(*ctx.input_tensors) + return output_tensors + + @staticmethod + def backward(ctx, *output_grads): + ctx.input_tensors = [x.detach().requires_grad_(True) for x in ctx.input_tensors] + with torch.enable_grad(), \ + torch.cuda.amp.autocast(**ctx.gpu_autocast_kwargs): + # Fixes a bug where the first op in run_function modifies the + # Tensor storage in place, which is not allowed for detach()'d + # Tensors. + shallow_copies = [x.view_as(x) for x in ctx.input_tensors] + output_tensors = ctx.run_function(*shallow_copies) + input_grads = torch.autograd.grad( + output_tensors, + ctx.input_tensors + ctx.input_params, + output_grads, + allow_unused=True, + ) + del ctx.input_tensors + del ctx.input_params + del output_tensors + return (None, None) + input_grads + + +def timestep_embedding(timesteps, dim, max_period=10000, repeat_only=False): + """ + Create sinusoidal timestep embeddings. + :param timesteps: a 1-D Tensor of N indices, one per batch element. + These may be fractional. + :param dim: the dimension of the output. + :param max_period: controls the minimum frequency of the embeddings. + :return: an [N x dim] Tensor of positional embeddings. + """ + if not repeat_only: + half = dim // 2 + freqs = torch.exp( + -math.log(max_period) * torch.arange(start=0, end=half, dtype=torch.float32) / half + ).to(device=timesteps.device) + args = timesteps[:, None].float() * freqs[None] + embedding = torch.cat([torch.cos(args), torch.sin(args)], dim=-1) + if dim % 2: + embedding = torch.cat([embedding, torch.zeros_like(embedding[:, :1])], dim=-1) + else: + embedding = repeat(timesteps, 'b -> b d', d=dim) + return embedding + + +def zero_module(module): + """ + Zero out the parameters of a module and return it. + """ + for p in module.parameters(): + p.detach().zero_() + return module + + +def scale_module(module, scale): + """ + Scale the parameters of a module and return it. + """ + for p in module.parameters(): + p.detach().mul_(scale) + return module + + +def mean_flat(tensor): + """ + Take the mean over all non-batch dimensions. + """ + return tensor.mean(dim=list(range(1, len(tensor.shape)))) + + +def normalization(channels): + """ + Make a standard normalization layer. + :param channels: number of input channels. + :return: an nn.Module for normalization. + """ + return GroupNorm32(32, channels) + + +# PyTorch 1.7 has SiLU, but we support PyTorch 1.5. +class SiLU(nn.Module): + def forward(self, x): + return x * torch.sigmoid(x) + + +class GroupNorm32(nn.GroupNorm): + def forward(self, x): + return super().forward(x.float()).type(x.dtype) + + +def conv_nd(dims, *args, **kwargs): + """ + Create a 1D, 2D, or 3D convolution module. + """ + if dims == 1: + return nn.Conv1d(*args, **kwargs) + elif dims == 2: + return nn.Conv2d(*args, **kwargs) + elif dims == 3: + return nn.Conv3d(*args, **kwargs) + raise ValueError(f"unsupported dimensions: {dims}") + + +def linear(*args, **kwargs): + """ + Create a linear module. + """ + return nn.Linear(*args, **kwargs) + + +def avg_pool_nd(dims, *args, **kwargs): + """ + Create a 1D, 2D, or 3D average pooling module. + """ + if dims == 1: + return nn.AvgPool1d(*args, **kwargs) + elif dims == 2: + return nn.AvgPool2d(*args, **kwargs) + elif dims == 3: + return nn.AvgPool3d(*args, **kwargs) + raise ValueError(f"unsupported dimensions: {dims}") + + +class HybridConditioner(nn.Module): + + def __init__(self, c_concat_config, c_crossattn_config): + super().__init__() + self.concat_conditioner = instantiate_from_config(c_concat_config) + self.crossattn_conditioner = instantiate_from_config(c_crossattn_config) + + def forward(self, c_concat, c_crossattn): + c_concat = self.concat_conditioner(c_concat) + c_crossattn = self.crossattn_conditioner(c_crossattn) + return {'c_concat': [c_concat], 'c_crossattn': [c_crossattn]} + + +def noise_like(shape, device, repeat=False): + repeat_noise = lambda: torch.randn((1, *shape[1:]), device=device).repeat(shape[0], *((1,) * (len(shape) - 1))) + noise = lambda: torch.randn(shape, device=device) + return repeat_noise() if repeat else noise() diff --git a/ldm/modules/distributions/__init__.py b/ldm/modules/distributions/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/ldm/modules/distributions/distributions.py b/ldm/modules/distributions/distributions.py new file mode 100644 index 0000000000000000000000000000000000000000..f2b8ef901130efc171aa69742ca0244d94d3f2e9 --- /dev/null +++ b/ldm/modules/distributions/distributions.py @@ -0,0 +1,92 @@ +import torch +import numpy as np + + +class AbstractDistribution: + def sample(self): + raise NotImplementedError() + + def mode(self): + raise NotImplementedError() + + +class DiracDistribution(AbstractDistribution): + def __init__(self, value): + self.value = value + + def sample(self): + return self.value + + def mode(self): + return self.value + + +class DiagonalGaussianDistribution(object): + def __init__(self, parameters, deterministic=False): + self.parameters = parameters + self.mean, self.logvar = torch.chunk(parameters, 2, dim=1) + self.logvar = torch.clamp(self.logvar, -30.0, 20.0) + self.deterministic = deterministic + self.std = torch.exp(0.5 * self.logvar) + self.var = torch.exp(self.logvar) + if self.deterministic: + self.var = self.std = torch.zeros_like(self.mean).to(device=self.parameters.device) + + def sample(self): + x = self.mean + self.std * torch.randn(self.mean.shape).to(device=self.parameters.device) + return x + + def kl(self, other=None): + if self.deterministic: + return torch.Tensor([0.]) + else: + if other is None: + return 0.5 * torch.sum(torch.pow(self.mean, 2) + + self.var - 1.0 - self.logvar, + dim=[1, 2, 3]) + else: + return 0.5 * torch.sum( + torch.pow(self.mean - other.mean, 2) / other.var + + self.var / other.var - 1.0 - self.logvar + other.logvar, + dim=[1, 2, 3]) + + def nll(self, sample, dims=[1,2,3]): + if self.deterministic: + return torch.Tensor([0.]) + logtwopi = np.log(2.0 * np.pi) + return 0.5 * torch.sum( + logtwopi + self.logvar + torch.pow(sample - self.mean, 2) / self.var, + dim=dims) + + def mode(self): + return self.mean + + +def normal_kl(mean1, logvar1, mean2, logvar2): + """ + source: https://github.com/openai/guided-diffusion/blob/27c20a8fab9cb472df5d6bdd6c8d11c8f430b924/guided_diffusion/losses.py#L12 + Compute the KL divergence between two gaussians. + Shapes are automatically broadcasted, so batches can be compared to + scalars, among other use cases. + """ + tensor = None + for obj in (mean1, logvar1, mean2, logvar2): + if isinstance(obj, torch.Tensor): + tensor = obj + break + assert tensor is not None, "at least one argument must be a Tensor" + + # Force variances to be Tensors. Broadcasting helps convert scalars to + # Tensors, but it does not work for torch.exp(). + logvar1, logvar2 = [ + x if isinstance(x, torch.Tensor) else torch.tensor(x).to(tensor) + for x in (logvar1, logvar2) + ] + + return 0.5 * ( + -1.0 + + logvar2 + - logvar1 + + torch.exp(logvar1 - logvar2) + + ((mean1 - mean2) ** 2) * torch.exp(-logvar2) + ) diff --git a/ldm/modules/ema.py b/ldm/modules/ema.py new file mode 100644 index 0000000000000000000000000000000000000000..bded25019b9bcbcd0260f0b8185f8c7859ca58c4 --- /dev/null +++ b/ldm/modules/ema.py @@ -0,0 +1,80 @@ +import torch +from torch import nn + + +class LitEma(nn.Module): + def __init__(self, model, decay=0.9999, use_num_upates=True): + super().__init__() + if decay < 0.0 or decay > 1.0: + raise ValueError('Decay must be between 0 and 1') + + self.m_name2s_name = {} + self.register_buffer('decay', torch.tensor(decay, dtype=torch.float32)) + self.register_buffer('num_updates', torch.tensor(0, dtype=torch.int) if use_num_upates + else torch.tensor(-1, dtype=torch.int)) + + for name, p in model.named_parameters(): + if p.requires_grad: + # remove as '.'-character is not allowed in buffers + s_name = name.replace('.', '') + self.m_name2s_name.update({name: s_name}) + self.register_buffer(s_name, p.clone().detach().data) + + self.collected_params = [] + + def reset_num_updates(self): + del self.num_updates + self.register_buffer('num_updates', torch.tensor(0, dtype=torch.int)) + + def forward(self, model): + decay = self.decay + + if self.num_updates >= 0: + self.num_updates += 1 + decay = min(self.decay, (1 + self.num_updates) / (10 + self.num_updates)) + + one_minus_decay = 1.0 - decay + + with torch.no_grad(): + m_param = dict(model.named_parameters()) + shadow_params = dict(self.named_buffers()) + + for key in m_param: + if m_param[key].requires_grad: + sname = self.m_name2s_name[key] + shadow_params[sname] = shadow_params[sname].type_as(m_param[key]) + shadow_params[sname].sub_(one_minus_decay * (shadow_params[sname] - m_param[key])) + else: + assert not key in self.m_name2s_name + + def copy_to(self, model): + m_param = dict(model.named_parameters()) + shadow_params = dict(self.named_buffers()) + for key in m_param: + if m_param[key].requires_grad: + m_param[key].data.copy_(shadow_params[self.m_name2s_name[key]].data) + else: + assert not key in self.m_name2s_name + + def store(self, parameters): + """ + Save the current parameters for restoring later. + Args: + parameters: Iterable of `torch.nn.Parameter`; the parameters to be + temporarily stored. + """ + self.collected_params = [param.clone() for param in parameters] + + def restore(self, parameters): + """ + Restore the parameters stored with the `store` method. + Useful to validate the model with EMA parameters without affecting the + original optimization process. Store the parameters before the + `copy_to` method. After validation (or model saving), use this to + restore the former parameters. + Args: + parameters: Iterable of `torch.nn.Parameter`; the parameters to be + updated with the stored parameters. + """ + for c_param, param in zip(self.collected_params, parameters): + param.data.copy_(c_param.data) diff --git a/ldm/modules/encoders/__init__.py b/ldm/modules/encoders/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/ldm/modules/encoders/modules.py b/ldm/modules/encoders/modules.py new file mode 100644 index 0000000000000000000000000000000000000000..523a7d8535b7a1741bc3d8bbadf59ac63b0de8ab --- /dev/null +++ b/ldm/modules/encoders/modules.py @@ -0,0 +1,350 @@ +import torch +import torch.nn as nn +import kornia +from torch.utils.checkpoint import checkpoint + +from transformers import T5Tokenizer, T5EncoderModel, CLIPTokenizer, CLIPTextModel + +import open_clip +from ldm.util import default, count_params, autocast + + +class AbstractEncoder(nn.Module): + def __init__(self): + super().__init__() + + def encode(self, *args, **kwargs): + raise NotImplementedError + + +class IdentityEncoder(AbstractEncoder): + + def encode(self, x): + return x + + +class ClassEmbedder(nn.Module): + def __init__(self, embed_dim, n_classes=1000, key='class', ucg_rate=0.1): + super().__init__() + self.key = key + self.embedding = nn.Embedding(n_classes, embed_dim) + self.n_classes = n_classes + self.ucg_rate = ucg_rate + + def forward(self, batch, key=None, disable_dropout=False): + if key is None: + key = self.key + # this is for use in crossattn + c = batch[key][:, None] + if self.ucg_rate > 0. and not disable_dropout: + mask = 1. - torch.bernoulli(torch.ones_like(c) * self.ucg_rate) + c = mask * c + (1 - mask) * torch.ones_like(c) * (self.n_classes - 1) + c = c.long() + c = self.embedding(c) + return c + + def get_unconditional_conditioning(self, bs, device="cuda"): + uc_class = self.n_classes - 1 # 1000 classes --> 0 ... 999, one extra class for ucg (class 1000) + uc = torch.ones((bs,), device=device) * uc_class + uc = {self.key: uc} + return uc + + +def disabled_train(self, mode=True): + """Overwrite model.train with this function to make sure train/eval mode + does not change anymore.""" + return self + + +class FrozenT5Embedder(AbstractEncoder): + """Uses the T5 transformer encoder for text""" + + def __init__(self, version="google/t5-v1_1-large", device="cuda", max_length=77, + freeze=True): # others are google/t5-v1_1-xl and google/t5-v1_1-xxl + super().__init__() + self.tokenizer = T5Tokenizer.from_pretrained(version) + self.transformer = T5EncoderModel.from_pretrained(version) + self.device = device + self.max_length = max_length # TODO: typical value? + if freeze: + self.freeze() + + def freeze(self): + self.transformer = self.transformer.eval() + # self.train = disabled_train + for param in self.parameters(): + param.requires_grad = False + + def forward(self, text): + batch_encoding = self.tokenizer(text, truncation=True, max_length=self.max_length, return_length=True, + return_overflowing_tokens=False, padding="max_length", return_tensors="pt") + tokens = batch_encoding["input_ids"].to(self.device) + outputs = self.transformer(input_ids=tokens) + + z = outputs.last_hidden_state + return z + + def encode(self, text): + return self(text) + + +class FrozenCLIPEmbedder(AbstractEncoder): + """Uses the CLIP transformer encoder for text (from huggingface)""" + LAYERS = [ + "last", + "pooled", + "hidden" + ] + + def __init__(self, version="openai/clip-vit-large-patch14", device="cuda", max_length=77, + freeze=True, layer="last", layer_idx=None): # clip-vit-base-patch32 + super().__init__() + assert layer in self.LAYERS + self.tokenizer = CLIPTokenizer.from_pretrained(version) + self.transformer = CLIPTextModel.from_pretrained(version) + self.device = device + self.max_length = max_length + if freeze: + self.freeze() + self.layer = layer + self.layer_idx = layer_idx + if layer == "hidden": + assert layer_idx is not None + assert 0 <= abs(layer_idx) <= 12 + + def freeze(self): + self.transformer = self.transformer.eval() + # self.train = disabled_train + for param in self.parameters(): + param.requires_grad = False + + def forward(self, text): + batch_encoding = self.tokenizer(text, truncation=True, max_length=self.max_length, return_length=True, + return_overflowing_tokens=False, padding="max_length", return_tensors="pt") + tokens = batch_encoding["input_ids"].to(self.device) + outputs = self.transformer(input_ids=tokens, output_hidden_states=self.layer == "hidden") + if self.layer == "last": + z = outputs.last_hidden_state + elif self.layer == "pooled": + z = outputs.pooler_output[:, None, :] + else: + z = outputs.hidden_states[self.layer_idx] + return z + + def encode(self, text): + return self(text) + + +class ClipImageEmbedder(nn.Module): + def __init__( + self, + model, + jit=False, + device='cuda' if torch.cuda.is_available() else 'cpu', + antialias=True, + ucg_rate=0. + ): + super().__init__() + from clip import load as load_clip + self.model, _ = load_clip(name=model, device=device, jit=jit) + + self.antialias = antialias + + self.register_buffer('mean', torch.Tensor([0.48145466, 0.4578275, 0.40821073]), persistent=False) + self.register_buffer('std', torch.Tensor([0.26862954, 0.26130258, 0.27577711]), persistent=False) + self.ucg_rate = ucg_rate + + def preprocess(self, x): + # normalize to [0,1] + x = kornia.geometry.resize(x, (224, 224), + interpolation='bicubic', align_corners=True, + antialias=self.antialias) + x = (x + 1.) / 2. + # re-normalize according to clip + x = kornia.enhance.normalize(x, self.mean, self.std) + return x + + def forward(self, x, no_dropout=False): + # x is assumed to be in range [-1,1] + out = self.model.encode_image(self.preprocess(x)) + out = out.to(x.dtype) + if self.ucg_rate > 0. and not no_dropout: + out = torch.bernoulli((1. - self.ucg_rate) * torch.ones(out.shape[0], device=out.device))[:, None] * out + return out + + +class FrozenOpenCLIPEmbedder(AbstractEncoder): + """ + Uses the OpenCLIP transformer encoder for text + """ + LAYERS = [ + # "pooled", + "last", + "penultimate" + ] + + def __init__(self, arch="ViT-H-14", version="laion2b_s32b_b79k", device="cuda", max_length=77, + freeze=True, layer="last"): + super().__init__() + assert layer in self.LAYERS + model, _, _ = open_clip.create_model_and_transforms(arch, device=torch.device('cpu'), pretrained=version) + del model.visual + self.model = model + + self.device = device + self.max_length = max_length + if freeze: + self.freeze() + self.layer = layer + if self.layer == "last": + self.layer_idx = 0 + elif self.layer == "penultimate": + self.layer_idx = 1 + else: + raise NotImplementedError() + + def freeze(self): + self.model = self.model.eval() + for param in self.parameters(): + param.requires_grad = False + + def forward(self, text): + tokens = open_clip.tokenize(text) + z = self.encode_with_transformer(tokens.to(self.device)) + return z + + def encode_with_transformer(self, text): + x = self.model.token_embedding(text) # [batch_size, n_ctx, d_model] + x = x + self.model.positional_embedding + x = x.permute(1, 0, 2) # NLD -> LND + x = self.text_transformer_forward(x, attn_mask=self.model.attn_mask) + x = x.permute(1, 0, 2) # LND -> NLD + x = self.model.ln_final(x) + return x + + def text_transformer_forward(self, x: torch.Tensor, attn_mask=None): + for i, r in enumerate(self.model.transformer.resblocks): + if i == len(self.model.transformer.resblocks) - self.layer_idx: + break + if self.model.transformer.grad_checkpointing and not torch.jit.is_scripting(): + x = checkpoint(r, x, attn_mask) + else: + x = r(x, attn_mask=attn_mask) + return x + + def encode(self, text): + return self(text) + + +class FrozenOpenCLIPImageEmbedder(AbstractEncoder): + """ + Uses the OpenCLIP vision transformer encoder for images + """ + + def __init__(self, arch="ViT-H-14", version="laion2b_s32b_b79k", device="cuda", max_length=77, + freeze=True, layer="pooled", antialias=True, ucg_rate=0.): + super().__init__() + model, _, _ = open_clip.create_model_and_transforms(arch, device=torch.device('cpu'), + pretrained=version, ) + del model.transformer + self.model = model + + self.device = device + self.max_length = max_length + if freeze: + self.freeze() + self.layer = layer + if self.layer == "penultimate": + raise NotImplementedError() + self.layer_idx = 1 + + self.antialias = antialias + + self.register_buffer('mean', torch.Tensor([0.48145466, 0.4578275, 0.40821073]), persistent=False) + self.register_buffer('std', torch.Tensor([0.26862954, 0.26130258, 0.27577711]), persistent=False) + self.ucg_rate = ucg_rate + + def preprocess(self, x): + # normalize to [0,1] + x = kornia.geometry.resize(x, (224, 224), + interpolation='bicubic', align_corners=True, + antialias=self.antialias) + x = (x + 1.) / 2. + # renormalize according to clip + x = kornia.enhance.normalize(x, self.mean, self.std) + return x + + def freeze(self): + self.model = self.model.eval() + for param in self.parameters(): + param.requires_grad = False + + @autocast + def forward(self, image, no_dropout=False): + z = self.encode_with_vision_transformer(image) + if self.ucg_rate > 0. and not no_dropout: + z = torch.bernoulli((1. - self.ucg_rate) * torch.ones(z.shape[0], device=z.device))[:, None] * z + return z + + def encode_with_vision_transformer(self, img): + img = self.preprocess(img) + x = self.model.visual(img) + return x + + def encode(self, text): + return self(text) + + +class FrozenCLIPT5Encoder(AbstractEncoder): + def __init__(self, clip_version="openai/clip-vit-large-patch14", t5_version="google/t5-v1_1-xl", device="cuda", + clip_max_length=77, t5_max_length=77): + super().__init__() + self.clip_encoder = FrozenCLIPEmbedder(clip_version, device, max_length=clip_max_length) + self.t5_encoder = FrozenT5Embedder(t5_version, device, max_length=t5_max_length) + print(f"{self.clip_encoder.__class__.__name__} has {count_params(self.clip_encoder) * 1.e-6:.2f} M parameters, " + f"{self.t5_encoder.__class__.__name__} comes with {count_params(self.t5_encoder) * 1.e-6:.2f} M params.") + + def encode(self, text): + return self(text) + + def forward(self, text): + clip_z = self.clip_encoder.encode(text) + t5_z = self.t5_encoder.encode(text) + return [clip_z, t5_z] + + +from ldm.modules.diffusionmodules.upscaling import ImageConcatWithNoiseAugmentation +from ldm.modules.diffusionmodules.openaimodel import Timestep + + +class CLIPEmbeddingNoiseAugmentation(ImageConcatWithNoiseAugmentation): + def __init__(self, *args, clip_stats_path=None, timestep_dim=256, **kwargs): + super().__init__(*args, **kwargs) + if clip_stats_path is None: + clip_mean, clip_std = torch.zeros(timestep_dim), torch.ones(timestep_dim) + else: + clip_mean, clip_std = torch.load(clip_stats_path, map_location="cpu") + self.register_buffer("data_mean", clip_mean[None, :], persistent=False) + self.register_buffer("data_std", clip_std[None, :], persistent=False) + self.time_embed = Timestep(timestep_dim) + + def scale(self, x): + # re-normalize to centered mean and unit variance + x = (x - self.data_mean) * 1. / self.data_std + return x + + def unscale(self, x): + # back to original data stats + x = (x * self.data_std) + self.data_mean + return x + + def forward(self, x, noise_level=None): + if noise_level is None: + noise_level = torch.randint(0, self.max_noise_level, (x.shape[0],), device=x.device).long() + else: + assert isinstance(noise_level, torch.Tensor) + x = self.scale(x) + z = self.q_sample(x, noise_level) + z = self.unscale(z) + noise_level = self.time_embed(noise_level) + return z, noise_level diff --git a/ldm/modules/image_degradation/__init__.py b/ldm/modules/image_degradation/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..7836cada81f90ded99c58d5942eea4c3477f58fc --- /dev/null +++ b/ldm/modules/image_degradation/__init__.py @@ -0,0 +1,2 @@ +from ldm.modules.image_degradation.bsrgan import degradation_bsrgan_variant as degradation_fn_bsr +from ldm.modules.image_degradation.bsrgan_light import degradation_bsrgan_variant as degradation_fn_bsr_light diff --git a/ldm/modules/image_degradation/bsrgan.py b/ldm/modules/image_degradation/bsrgan.py new file mode 100644 index 0000000000000000000000000000000000000000..32ef56169978e550090261cddbcf5eb611a6173b --- /dev/null +++ b/ldm/modules/image_degradation/bsrgan.py @@ -0,0 +1,730 @@ +# -*- coding: utf-8 -*- +""" +# -------------------------------------------- +# Super-Resolution +# -------------------------------------------- +# +# Kai Zhang (cskaizhang@gmail.com) +# https://github.com/cszn +# From 2019/03--2021/08 +# -------------------------------------------- +""" + +import numpy as np +import cv2 +import torch + +from functools import partial +import random +from scipy import ndimage +import scipy +import scipy.stats as ss +from scipy.interpolate import interp2d +from scipy.linalg import orth +import albumentations + +import ldm.modules.image_degradation.utils_image as util + + +def modcrop_np(img, sf): + ''' + Args: + img: numpy image, WxH or WxHxC + sf: scale factor + Return: + cropped image + ''' + w, h = img.shape[:2] + im = np.copy(img) + return im[:w - w % sf, :h - h % sf, ...] + + +""" +# -------------------------------------------- +# anisotropic Gaussian kernels +# -------------------------------------------- +""" + + +def analytic_kernel(k): + """Calculate the X4 kernel from the X2 kernel (for proof see appendix in paper)""" + k_size = k.shape[0] + # Calculate the big kernels size + big_k = np.zeros((3 * k_size - 2, 3 * k_size - 2)) + # Loop over the small kernel to fill the big one + for r in range(k_size): + for c in range(k_size): + big_k[2 * r:2 * r + k_size, 2 * c:2 * c + k_size] += k[r, c] * k + # Crop the edges of the big kernel to ignore very small values and increase run time of SR + crop = k_size // 2 + cropped_big_k = big_k[crop:-crop, crop:-crop] + # Normalize to 1 + return cropped_big_k / cropped_big_k.sum() + + +def anisotropic_Gaussian(ksize=15, theta=np.pi, l1=6, l2=6): + """ generate an anisotropic Gaussian kernel + Args: + ksize : e.g., 15, kernel size + theta : [0, pi], rotation angle range + l1 : [0.1,50], scaling of eigenvalues + l2 : [0.1,l1], scaling of eigenvalues + If l1 = l2, will get an isotropic Gaussian kernel. + Returns: + k : kernel + """ + + v = np.dot(np.array([[np.cos(theta), -np.sin(theta)], [np.sin(theta), np.cos(theta)]]), np.array([1., 0.])) + V = np.array([[v[0], v[1]], [v[1], -v[0]]]) + D = np.array([[l1, 0], [0, l2]]) + Sigma = np.dot(np.dot(V, D), np.linalg.inv(V)) + k = gm_blur_kernel(mean=[0, 0], cov=Sigma, size=ksize) + + return k + + +def gm_blur_kernel(mean, cov, size=15): + center = size / 2.0 + 0.5 + k = np.zeros([size, size]) + for y in range(size): + for x in range(size): + cy = y - center + 1 + cx = x - center + 1 + k[y, x] = ss.multivariate_normal.pdf([cx, cy], mean=mean, cov=cov) + + k = k / np.sum(k) + return k + + +def shift_pixel(x, sf, upper_left=True): + """shift pixel for super-resolution with different scale factors + Args: + x: WxHxC or WxH + sf: scale factor + upper_left: shift direction + """ + h, w = x.shape[:2] + shift = (sf - 1) * 0.5 + xv, yv = np.arange(0, w, 1.0), np.arange(0, h, 1.0) + if upper_left: + x1 = xv + shift + y1 = yv + shift + else: + x1 = xv - shift + y1 = yv - shift + + x1 = np.clip(x1, 0, w - 1) + y1 = np.clip(y1, 0, h - 1) + + if x.ndim == 2: + x = interp2d(xv, yv, x)(x1, y1) + if x.ndim == 3: + for i in range(x.shape[-1]): + x[:, :, i] = interp2d(xv, yv, x[:, :, i])(x1, y1) + + return x + + +def blur(x, k): + ''' + x: image, NxcxHxW + k: kernel, Nx1xhxw + ''' + n, c = x.shape[:2] + p1, p2 = (k.shape[-2] - 1) // 2, (k.shape[-1] - 1) // 2 + x = torch.nn.functional.pad(x, pad=(p1, p2, p1, p2), mode='replicate') + k = k.repeat(1, c, 1, 1) + k = k.view(-1, 1, k.shape[2], k.shape[3]) + x = x.view(1, -1, x.shape[2], x.shape[3]) + x = torch.nn.functional.conv2d(x, k, bias=None, stride=1, padding=0, groups=n * c) + x = x.view(n, c, x.shape[2], x.shape[3]) + + return x + + +def gen_kernel(k_size=np.array([15, 15]), scale_factor=np.array([4, 4]), min_var=0.6, max_var=10., noise_level=0): + """" + # modified version of https://github.com/assafshocher/BlindSR_dataset_generator + # Kai Zhang + # min_var = 0.175 * sf # variance of the gaussian kernel will be sampled between min_var and max_var + # max_var = 2.5 * sf + """ + # Set random eigen-vals (lambdas) and angle (theta) for COV matrix + lambda_1 = min_var + np.random.rand() * (max_var - min_var) + lambda_2 = min_var + np.random.rand() * (max_var - min_var) + theta = np.random.rand() * np.pi # random theta + noise = -noise_level + np.random.rand(*k_size) * noise_level * 2 + + # Set COV matrix using Lambdas and Theta + LAMBDA = np.diag([lambda_1, lambda_2]) + Q = np.array([[np.cos(theta), -np.sin(theta)], + [np.sin(theta), np.cos(theta)]]) + SIGMA = Q @ LAMBDA @ Q.T + INV_SIGMA = np.linalg.inv(SIGMA)[None, None, :, :] + + # Set expectation position (shifting kernel for aligned image) + MU = k_size // 2 - 0.5 * (scale_factor - 1) # - 0.5 * (scale_factor - k_size % 2) + MU = MU[None, None, :, None] + + # Create meshgrid for Gaussian + [X, Y] = np.meshgrid(range(k_size[0]), range(k_size[1])) + Z = np.stack([X, Y], 2)[:, :, :, None] + + # Calcualte Gaussian for every pixel of the kernel + ZZ = Z - MU + ZZ_t = ZZ.transpose(0, 1, 3, 2) + raw_kernel = np.exp(-0.5 * np.squeeze(ZZ_t @ INV_SIGMA @ ZZ)) * (1 + noise) + + # shift the kernel so it will be centered + # raw_kernel_centered = kernel_shift(raw_kernel, scale_factor) + + # Normalize the kernel and return + # kernel = raw_kernel_centered / np.sum(raw_kernel_centered) + kernel = raw_kernel / np.sum(raw_kernel) + return kernel + + +def fspecial_gaussian(hsize, sigma): + hsize = [hsize, hsize] + siz = [(hsize[0] - 1.0) / 2.0, (hsize[1] - 1.0) / 2.0] + std = sigma + [x, y] = np.meshgrid(np.arange(-siz[1], siz[1] + 1), np.arange(-siz[0], siz[0] + 1)) + arg = -(x * x + y * y) / (2 * std * std) + h = np.exp(arg) + h[h < scipy.finfo(float).eps * h.max()] = 0 + sumh = h.sum() + if sumh != 0: + h = h / sumh + return h + + +def fspecial_laplacian(alpha): + alpha = max([0, min([alpha, 1])]) + h1 = alpha / (alpha + 1) + h2 = (1 - alpha) / (alpha + 1) + h = [[h1, h2, h1], [h2, -4 / (alpha + 1), h2], [h1, h2, h1]] + h = np.array(h) + return h + + +def fspecial(filter_type, *args, **kwargs): + ''' + python code from: + https://github.com/ronaldosena/imagens-medicas-2/blob/40171a6c259edec7827a6693a93955de2bd39e76/Aulas/aula_2_-_uniform_filter/matlab_fspecial.py + ''' + if filter_type == 'gaussian': + return fspecial_gaussian(*args, **kwargs) + if filter_type == 'laplacian': + return fspecial_laplacian(*args, **kwargs) + + +""" +# -------------------------------------------- +# degradation models +# -------------------------------------------- +""" + + +def bicubic_degradation(x, sf=3): + ''' + Args: + x: HxWxC image, [0, 1] + sf: down-scale factor + Return: + bicubicly downsampled LR image + ''' + x = util.imresize_np(x, scale=1 / sf) + return x + + +def srmd_degradation(x, k, sf=3): + ''' blur + bicubic downsampling + Args: + x: HxWxC image, [0, 1] + k: hxw, double + sf: down-scale factor + Return: + downsampled LR image + Reference: + @inproceedings{zhang2018learning, + title={Learning a single convolutional super-resolution network for multiple degradations}, + author={Zhang, Kai and Zuo, Wangmeng and Zhang, Lei}, + booktitle={IEEE Conference on Computer Vision and Pattern Recognition}, + pages={3262--3271}, + year={2018} + } + ''' + x = ndimage.filters.convolve(x, np.expand_dims(k, axis=2), mode='wrap') # 'nearest' | 'mirror' + x = bicubic_degradation(x, sf=sf) + return x + + +def dpsr_degradation(x, k, sf=3): + ''' bicubic downsampling + blur + Args: + x: HxWxC image, [0, 1] + k: hxw, double + sf: down-scale factor + Return: + downsampled LR image + Reference: + @inproceedings{zhang2019deep, + title={Deep Plug-and-Play Super-Resolution for Arbitrary Blur Kernels}, + author={Zhang, Kai and Zuo, Wangmeng and Zhang, Lei}, + booktitle={IEEE Conference on Computer Vision and Pattern Recognition}, + pages={1671--1681}, + year={2019} + } + ''' + x = bicubic_degradation(x, sf=sf) + x = ndimage.filters.convolve(x, np.expand_dims(k, axis=2), mode='wrap') + return x + + +def classical_degradation(x, k, sf=3): + ''' blur + downsampling + Args: + x: HxWxC image, [0, 1]/[0, 255] + k: hxw, double + sf: down-scale factor + Return: + downsampled LR image + ''' + x = ndimage.filters.convolve(x, np.expand_dims(k, axis=2), mode='wrap') + # x = filters.correlate(x, np.expand_dims(np.flip(k), axis=2)) + st = 0 + return x[st::sf, st::sf, ...] + + +def add_sharpening(img, weight=0.5, radius=50, threshold=10): + """USM sharpening. borrowed from real-ESRGAN + Input image: I; Blurry image: B. + 1. K = I + weight * (I - B) + 2. Mask = 1 if abs(I - B) > threshold, else: 0 + 3. Blur mask: + 4. Out = Mask * K + (1 - Mask) * I + Args: + img (Numpy array): Input image, HWC, BGR; float32, [0, 1]. + weight (float): Sharp weight. Default: 1. + radius (float): Kernel size of Gaussian blur. Default: 50. + threshold (int): + """ + if radius % 2 == 0: + radius += 1 + blur = cv2.GaussianBlur(img, (radius, radius), 0) + residual = img - blur + mask = np.abs(residual) * 255 > threshold + mask = mask.astype('float32') + soft_mask = cv2.GaussianBlur(mask, (radius, radius), 0) + + K = img + weight * residual + K = np.clip(K, 0, 1) + return soft_mask * K + (1 - soft_mask) * img + + +def add_blur(img, sf=4): + wd2 = 4.0 + sf + wd = 2.0 + 0.2 * sf + if random.random() < 0.5: + l1 = wd2 * random.random() + l2 = wd2 * random.random() + k = anisotropic_Gaussian(ksize=2 * random.randint(2, 11) + 3, theta=random.random() * np.pi, l1=l1, l2=l2) + else: + k = fspecial('gaussian', 2 * random.randint(2, 11) + 3, wd * random.random()) + img = ndimage.filters.convolve(img, np.expand_dims(k, axis=2), mode='mirror') + + return img + + +def add_resize(img, sf=4): + rnum = np.random.rand() + if rnum > 0.8: # up + sf1 = random.uniform(1, 2) + elif rnum < 0.7: # down + sf1 = random.uniform(0.5 / sf, 1) + else: + sf1 = 1.0 + img = cv2.resize(img, (int(sf1 * img.shape[1]), int(sf1 * img.shape[0])), interpolation=random.choice([1, 2, 3])) + img = np.clip(img, 0.0, 1.0) + + return img + + +# def add_Gaussian_noise(img, noise_level1=2, noise_level2=25): +# noise_level = random.randint(noise_level1, noise_level2) +# rnum = np.random.rand() +# if rnum > 0.6: # add color Gaussian noise +# img += np.random.normal(0, noise_level / 255.0, img.shape).astype(np.float32) +# elif rnum < 0.4: # add grayscale Gaussian noise +# img += np.random.normal(0, noise_level / 255.0, (*img.shape[:2], 1)).astype(np.float32) +# else: # add noise +# L = noise_level2 / 255. +# D = np.diag(np.random.rand(3)) +# U = orth(np.random.rand(3, 3)) +# conv = np.dot(np.dot(np.transpose(U), D), U) +# img += np.random.multivariate_normal([0, 0, 0], np.abs(L ** 2 * conv), img.shape[:2]).astype(np.float32) +# img = np.clip(img, 0.0, 1.0) +# return img + +def add_Gaussian_noise(img, noise_level1=2, noise_level2=25): + noise_level = random.randint(noise_level1, noise_level2) + rnum = np.random.rand() + if rnum > 0.6: # add color Gaussian noise + img = img + np.random.normal(0, noise_level / 255.0, img.shape).astype(np.float32) + elif rnum < 0.4: # add grayscale Gaussian noise + img = img + np.random.normal(0, noise_level / 255.0, (*img.shape[:2], 1)).astype(np.float32) + else: # add noise + L = noise_level2 / 255. + D = np.diag(np.random.rand(3)) + U = orth(np.random.rand(3, 3)) + conv = np.dot(np.dot(np.transpose(U), D), U) + img = img + np.random.multivariate_normal([0, 0, 0], np.abs(L ** 2 * conv), img.shape[:2]).astype(np.float32) + img = np.clip(img, 0.0, 1.0) + return img + + +def add_speckle_noise(img, noise_level1=2, noise_level2=25): + noise_level = random.randint(noise_level1, noise_level2) + img = np.clip(img, 0.0, 1.0) + rnum = random.random() + if rnum > 0.6: + img += img * np.random.normal(0, noise_level / 255.0, img.shape).astype(np.float32) + elif rnum < 0.4: + img += img * np.random.normal(0, noise_level / 255.0, (*img.shape[:2], 1)).astype(np.float32) + else: + L = noise_level2 / 255. + D = np.diag(np.random.rand(3)) + U = orth(np.random.rand(3, 3)) + conv = np.dot(np.dot(np.transpose(U), D), U) + img += img * np.random.multivariate_normal([0, 0, 0], np.abs(L ** 2 * conv), img.shape[:2]).astype(np.float32) + img = np.clip(img, 0.0, 1.0) + return img + + +def add_Poisson_noise(img): + img = np.clip((img * 255.0).round(), 0, 255) / 255. + vals = 10 ** (2 * random.random() + 2.0) # [2, 4] + if random.random() < 0.5: + img = np.random.poisson(img * vals).astype(np.float32) / vals + else: + img_gray = np.dot(img[..., :3], [0.299, 0.587, 0.114]) + img_gray = np.clip((img_gray * 255.0).round(), 0, 255) / 255. + noise_gray = np.random.poisson(img_gray * vals).astype(np.float32) / vals - img_gray + img += noise_gray[:, :, np.newaxis] + img = np.clip(img, 0.0, 1.0) + return img + + +def add_JPEG_noise(img): + quality_factor = random.randint(30, 95) + img = cv2.cvtColor(util.single2uint(img), cv2.COLOR_RGB2BGR) + result, encimg = cv2.imencode('.jpg', img, [int(cv2.IMWRITE_JPEG_QUALITY), quality_factor]) + img = cv2.imdecode(encimg, 1) + img = cv2.cvtColor(util.uint2single(img), cv2.COLOR_BGR2RGB) + return img + + +def random_crop(lq, hq, sf=4, lq_patchsize=64): + h, w = lq.shape[:2] + rnd_h = random.randint(0, h - lq_patchsize) + rnd_w = random.randint(0, w - lq_patchsize) + lq = lq[rnd_h:rnd_h + lq_patchsize, rnd_w:rnd_w + lq_patchsize, :] + + rnd_h_H, rnd_w_H = int(rnd_h * sf), int(rnd_w * sf) + hq = hq[rnd_h_H:rnd_h_H + lq_patchsize * sf, rnd_w_H:rnd_w_H + lq_patchsize * sf, :] + return lq, hq + + +def degradation_bsrgan(img, sf=4, lq_patchsize=72, isp_model=None): + """ + This is the degradation model of BSRGAN from the paper + "Designing a Practical Degradation Model for Deep Blind Image Super-Resolution" + ---------- + img: HXWXC, [0, 1], its size should be large than (lq_patchsizexsf)x(lq_patchsizexsf) + sf: scale factor + isp_model: camera ISP model + Returns + ------- + img: low-quality patch, size: lq_patchsizeXlq_patchsizeXC, range: [0, 1] + hq: corresponding high-quality patch, size: (lq_patchsizexsf)X(lq_patchsizexsf)XC, range: [0, 1] + """ + isp_prob, jpeg_prob, scale2_prob = 0.25, 0.9, 0.25 + sf_ori = sf + + h1, w1 = img.shape[:2] + img = img.copy()[:w1 - w1 % sf, :h1 - h1 % sf, ...] # mod crop + h, w = img.shape[:2] + + if h < lq_patchsize * sf or w < lq_patchsize * sf: + raise ValueError(f'img size ({h1}X{w1}) is too small!') + + hq = img.copy() + + if sf == 4 and random.random() < scale2_prob: # downsample1 + if np.random.rand() < 0.5: + img = cv2.resize(img, (int(1 / 2 * img.shape[1]), int(1 / 2 * img.shape[0])), + interpolation=random.choice([1, 2, 3])) + else: + img = util.imresize_np(img, 1 / 2, True) + img = np.clip(img, 0.0, 1.0) + sf = 2 + + shuffle_order = random.sample(range(7), 7) + idx1, idx2 = shuffle_order.index(2), shuffle_order.index(3) + if idx1 > idx2: # keep downsample3 last + shuffle_order[idx1], shuffle_order[idx2] = shuffle_order[idx2], shuffle_order[idx1] + + for i in shuffle_order: + + if i == 0: + img = add_blur(img, sf=sf) + + elif i == 1: + img = add_blur(img, sf=sf) + + elif i == 2: + a, b = img.shape[1], img.shape[0] + # downsample2 + if random.random() < 0.75: + sf1 = random.uniform(1, 2 * sf) + img = cv2.resize(img, (int(1 / sf1 * img.shape[1]), int(1 / sf1 * img.shape[0])), + interpolation=random.choice([1, 2, 3])) + else: + k = fspecial('gaussian', 25, random.uniform(0.1, 0.6 * sf)) + k_shifted = shift_pixel(k, sf) + k_shifted = k_shifted / k_shifted.sum() # blur with shifted kernel + img = ndimage.filters.convolve(img, np.expand_dims(k_shifted, axis=2), mode='mirror') + img = img[0::sf, 0::sf, ...] # nearest downsampling + img = np.clip(img, 0.0, 1.0) + + elif i == 3: + # downsample3 + img = cv2.resize(img, (int(1 / sf * a), int(1 / sf * b)), interpolation=random.choice([1, 2, 3])) + img = np.clip(img, 0.0, 1.0) + + elif i == 4: + # add Gaussian noise + img = add_Gaussian_noise(img, noise_level1=2, noise_level2=25) + + elif i == 5: + # add JPEG noise + if random.random() < jpeg_prob: + img = add_JPEG_noise(img) + + elif i == 6: + # add processed camera sensor noise + if random.random() < isp_prob and isp_model is not None: + with torch.no_grad(): + img, hq = isp_model.forward(img.copy(), hq) + + # add final JPEG compression noise + img = add_JPEG_noise(img) + + # random crop + img, hq = random_crop(img, hq, sf_ori, lq_patchsize) + + return img, hq + + +# todo no isp_model? +def degradation_bsrgan_variant(image, sf=4, isp_model=None): + """ + This is the degradation model of BSRGAN from the paper + "Designing a Practical Degradation Model for Deep Blind Image Super-Resolution" + ---------- + sf: scale factor + isp_model: camera ISP model + Returns + ------- + img: low-quality patch, size: lq_patchsizeXlq_patchsizeXC, range: [0, 1] + hq: corresponding high-quality patch, size: (lq_patchsizexsf)X(lq_patchsizexsf)XC, range: [0, 1] + """ + image = util.uint2single(image) + isp_prob, jpeg_prob, scale2_prob = 0.25, 0.9, 0.25 + sf_ori = sf + + h1, w1 = image.shape[:2] + image = image.copy()[:w1 - w1 % sf, :h1 - h1 % sf, ...] # mod crop + h, w = image.shape[:2] + + hq = image.copy() + + if sf == 4 and random.random() < scale2_prob: # downsample1 + if np.random.rand() < 0.5: + image = cv2.resize(image, (int(1 / 2 * image.shape[1]), int(1 / 2 * image.shape[0])), + interpolation=random.choice([1, 2, 3])) + else: + image = util.imresize_np(image, 1 / 2, True) + image = np.clip(image, 0.0, 1.0) + sf = 2 + + shuffle_order = random.sample(range(7), 7) + idx1, idx2 = shuffle_order.index(2), shuffle_order.index(3) + if idx1 > idx2: # keep downsample3 last + shuffle_order[idx1], shuffle_order[idx2] = shuffle_order[idx2], shuffle_order[idx1] + + for i in shuffle_order: + + if i == 0: + image = add_blur(image, sf=sf) + + elif i == 1: + image = add_blur(image, sf=sf) + + elif i == 2: + a, b = image.shape[1], image.shape[0] + # downsample2 + if random.random() < 0.75: + sf1 = random.uniform(1, 2 * sf) + image = cv2.resize(image, (int(1 / sf1 * image.shape[1]), int(1 / sf1 * image.shape[0])), + interpolation=random.choice([1, 2, 3])) + else: + k = fspecial('gaussian', 25, random.uniform(0.1, 0.6 * sf)) + k_shifted = shift_pixel(k, sf) + k_shifted = k_shifted / k_shifted.sum() # blur with shifted kernel + image = ndimage.filters.convolve(image, np.expand_dims(k_shifted, axis=2), mode='mirror') + image = image[0::sf, 0::sf, ...] # nearest downsampling + image = np.clip(image, 0.0, 1.0) + + elif i == 3: + # downsample3 + image = cv2.resize(image, (int(1 / sf * a), int(1 / sf * b)), interpolation=random.choice([1, 2, 3])) + image = np.clip(image, 0.0, 1.0) + + elif i == 4: + # add Gaussian noise + image = add_Gaussian_noise(image, noise_level1=2, noise_level2=25) + + elif i == 5: + # add JPEG noise + if random.random() < jpeg_prob: + image = add_JPEG_noise(image) + + # elif i == 6: + # # add processed camera sensor noise + # if random.random() < isp_prob and isp_model is not None: + # with torch.no_grad(): + # img, hq = isp_model.forward(img.copy(), hq) + + # add final JPEG compression noise + image = add_JPEG_noise(image) + image = util.single2uint(image) + example = {"image":image} + return example + + +# TODO incase there is a pickle error one needs to replace a += x with a = a + x in add_speckle_noise etc... +def degradation_bsrgan_plus(img, sf=4, shuffle_prob=0.5, use_sharp=True, lq_patchsize=64, isp_model=None): + """ + This is an extended degradation model by combining + the degradation models of BSRGAN and Real-ESRGAN + ---------- + img: HXWXC, [0, 1], its size should be large than (lq_patchsizexsf)x(lq_patchsizexsf) + sf: scale factor + use_shuffle: the degradation shuffle + use_sharp: sharpening the img + Returns + ------- + img: low-quality patch, size: lq_patchsizeXlq_patchsizeXC, range: [0, 1] + hq: corresponding high-quality patch, size: (lq_patchsizexsf)X(lq_patchsizexsf)XC, range: [0, 1] + """ + + h1, w1 = img.shape[:2] + img = img.copy()[:w1 - w1 % sf, :h1 - h1 % sf, ...] # mod crop + h, w = img.shape[:2] + + if h < lq_patchsize * sf or w < lq_patchsize * sf: + raise ValueError(f'img size ({h1}X{w1}) is too small!') + + if use_sharp: + img = add_sharpening(img) + hq = img.copy() + + if random.random() < shuffle_prob: + shuffle_order = random.sample(range(13), 13) + else: + shuffle_order = list(range(13)) + # local shuffle for noise, JPEG is always the last one + shuffle_order[2:6] = random.sample(shuffle_order[2:6], len(range(2, 6))) + shuffle_order[9:13] = random.sample(shuffle_order[9:13], len(range(9, 13))) + + poisson_prob, speckle_prob, isp_prob = 0.1, 0.1, 0.1 + + for i in shuffle_order: + if i == 0: + img = add_blur(img, sf=sf) + elif i == 1: + img = add_resize(img, sf=sf) + elif i == 2: + img = add_Gaussian_noise(img, noise_level1=2, noise_level2=25) + elif i == 3: + if random.random() < poisson_prob: + img = add_Poisson_noise(img) + elif i == 4: + if random.random() < speckle_prob: + img = add_speckle_noise(img) + elif i == 5: + if random.random() < isp_prob and isp_model is not None: + with torch.no_grad(): + img, hq = isp_model.forward(img.copy(), hq) + elif i == 6: + img = add_JPEG_noise(img) + elif i == 7: + img = add_blur(img, sf=sf) + elif i == 8: + img = add_resize(img, sf=sf) + elif i == 9: + img = add_Gaussian_noise(img, noise_level1=2, noise_level2=25) + elif i == 10: + if random.random() < poisson_prob: + img = add_Poisson_noise(img) + elif i == 11: + if random.random() < speckle_prob: + img = add_speckle_noise(img) + elif i == 12: + if random.random() < isp_prob and isp_model is not None: + with torch.no_grad(): + img, hq = isp_model.forward(img.copy(), hq) + else: + print('check the shuffle!') + + # resize to desired size + img = cv2.resize(img, (int(1 / sf * hq.shape[1]), int(1 / sf * hq.shape[0])), + interpolation=random.choice([1, 2, 3])) + + # add final JPEG compression noise + img = add_JPEG_noise(img) + + # random crop + img, hq = random_crop(img, hq, sf, lq_patchsize) + + return img, hq + + +if __name__ == '__main__': + print("hey") + img = util.imread_uint('utils/test.png', 3) + print(img) + img = util.uint2single(img) + print(img) + img = img[:448, :448] + h = img.shape[0] // 4 + print("resizing to", h) + sf = 4 + deg_fn = partial(degradation_bsrgan_variant, sf=sf) + for i in range(20): + print(i) + img_lq = deg_fn(img) + print(img_lq) + img_lq_bicubic = albumentations.SmallestMaxSize(max_size=h, interpolation=cv2.INTER_CUBIC)(image=img)["image"] + print(img_lq.shape) + print("bicubic", img_lq_bicubic.shape) + print(img_hq.shape) + lq_nearest = cv2.resize(util.single2uint(img_lq), (int(sf * img_lq.shape[1]), int(sf * img_lq.shape[0])), + interpolation=0) + lq_bicubic_nearest = cv2.resize(util.single2uint(img_lq_bicubic), (int(sf * img_lq.shape[1]), int(sf * img_lq.shape[0])), + interpolation=0) + img_concat = np.concatenate([lq_bicubic_nearest, lq_nearest, util.single2uint(img_hq)], axis=1) + util.imsave(img_concat, str(i) + '.png') + + diff --git a/ldm/modules/image_degradation/bsrgan_light.py b/ldm/modules/image_degradation/bsrgan_light.py new file mode 100644 index 0000000000000000000000000000000000000000..808c7f882cb75e2ba2340d5b55881d11927351f0 --- /dev/null +++ b/ldm/modules/image_degradation/bsrgan_light.py @@ -0,0 +1,651 @@ +# -*- coding: utf-8 -*- +import numpy as np +import cv2 +import torch + +from functools import partial +import random +from scipy import ndimage +import scipy +import scipy.stats as ss +from scipy.interpolate import interp2d +from scipy.linalg import orth +import albumentations + +import ldm.modules.image_degradation.utils_image as util + +""" +# -------------------------------------------- +# Super-Resolution +# -------------------------------------------- +# +# Kai Zhang (cskaizhang@gmail.com) +# https://github.com/cszn +# From 2019/03--2021/08 +# -------------------------------------------- +""" + +def modcrop_np(img, sf): + ''' + Args: + img: numpy image, WxH or WxHxC + sf: scale factor + Return: + cropped image + ''' + w, h = img.shape[:2] + im = np.copy(img) + return im[:w - w % sf, :h - h % sf, ...] + + +""" +# -------------------------------------------- +# anisotropic Gaussian kernels +# -------------------------------------------- +""" + + +def analytic_kernel(k): + """Calculate the X4 kernel from the X2 kernel (for proof see appendix in paper)""" + k_size = k.shape[0] + # Calculate the big kernels size + big_k = np.zeros((3 * k_size - 2, 3 * k_size - 2)) + # Loop over the small kernel to fill the big one + for r in range(k_size): + for c in range(k_size): + big_k[2 * r:2 * r + k_size, 2 * c:2 * c + k_size] += k[r, c] * k + # Crop the edges of the big kernel to ignore very small values and increase run time of SR + crop = k_size // 2 + cropped_big_k = big_k[crop:-crop, crop:-crop] + # Normalize to 1 + return cropped_big_k / cropped_big_k.sum() + + +def anisotropic_Gaussian(ksize=15, theta=np.pi, l1=6, l2=6): + """ generate an anisotropic Gaussian kernel + Args: + ksize : e.g., 15, kernel size + theta : [0, pi], rotation angle range + l1 : [0.1,50], scaling of eigenvalues + l2 : [0.1,l1], scaling of eigenvalues + If l1 = l2, will get an isotropic Gaussian kernel. + Returns: + k : kernel + """ + + v = np.dot(np.array([[np.cos(theta), -np.sin(theta)], [np.sin(theta), np.cos(theta)]]), np.array([1., 0.])) + V = np.array([[v[0], v[1]], [v[1], -v[0]]]) + D = np.array([[l1, 0], [0, l2]]) + Sigma = np.dot(np.dot(V, D), np.linalg.inv(V)) + k = gm_blur_kernel(mean=[0, 0], cov=Sigma, size=ksize) + + return k + + +def gm_blur_kernel(mean, cov, size=15): + center = size / 2.0 + 0.5 + k = np.zeros([size, size]) + for y in range(size): + for x in range(size): + cy = y - center + 1 + cx = x - center + 1 + k[y, x] = ss.multivariate_normal.pdf([cx, cy], mean=mean, cov=cov) + + k = k / np.sum(k) + return k + + +def shift_pixel(x, sf, upper_left=True): + """shift pixel for super-resolution with different scale factors + Args: + x: WxHxC or WxH + sf: scale factor + upper_left: shift direction + """ + h, w = x.shape[:2] + shift = (sf - 1) * 0.5 + xv, yv = np.arange(0, w, 1.0), np.arange(0, h, 1.0) + if upper_left: + x1 = xv + shift + y1 = yv + shift + else: + x1 = xv - shift + y1 = yv - shift + + x1 = np.clip(x1, 0, w - 1) + y1 = np.clip(y1, 0, h - 1) + + if x.ndim == 2: + x = interp2d(xv, yv, x)(x1, y1) + if x.ndim == 3: + for i in range(x.shape[-1]): + x[:, :, i] = interp2d(xv, yv, x[:, :, i])(x1, y1) + + return x + + +def blur(x, k): + ''' + x: image, NxcxHxW + k: kernel, Nx1xhxw + ''' + n, c = x.shape[:2] + p1, p2 = (k.shape[-2] - 1) // 2, (k.shape[-1] - 1) // 2 + x = torch.nn.functional.pad(x, pad=(p1, p2, p1, p2), mode='replicate') + k = k.repeat(1, c, 1, 1) + k = k.view(-1, 1, k.shape[2], k.shape[3]) + x = x.view(1, -1, x.shape[2], x.shape[3]) + x = torch.nn.functional.conv2d(x, k, bias=None, stride=1, padding=0, groups=n * c) + x = x.view(n, c, x.shape[2], x.shape[3]) + + return x + + +def gen_kernel(k_size=np.array([15, 15]), scale_factor=np.array([4, 4]), min_var=0.6, max_var=10., noise_level=0): + """" + # modified version of https://github.com/assafshocher/BlindSR_dataset_generator + # Kai Zhang + # min_var = 0.175 * sf # variance of the gaussian kernel will be sampled between min_var and max_var + # max_var = 2.5 * sf + """ + # Set random eigen-vals (lambdas) and angle (theta) for COV matrix + lambda_1 = min_var + np.random.rand() * (max_var - min_var) + lambda_2 = min_var + np.random.rand() * (max_var - min_var) + theta = np.random.rand() * np.pi # random theta + noise = -noise_level + np.random.rand(*k_size) * noise_level * 2 + + # Set COV matrix using Lambdas and Theta + LAMBDA = np.diag([lambda_1, lambda_2]) + Q = np.array([[np.cos(theta), -np.sin(theta)], + [np.sin(theta), np.cos(theta)]]) + SIGMA = Q @ LAMBDA @ Q.T + INV_SIGMA = np.linalg.inv(SIGMA)[None, None, :, :] + + # Set expectation position (shifting kernel for aligned image) + MU = k_size // 2 - 0.5 * (scale_factor - 1) # - 0.5 * (scale_factor - k_size % 2) + MU = MU[None, None, :, None] + + # Create meshgrid for Gaussian + [X, Y] = np.meshgrid(range(k_size[0]), range(k_size[1])) + Z = np.stack([X, Y], 2)[:, :, :, None] + + # Calcualte Gaussian for every pixel of the kernel + ZZ = Z - MU + ZZ_t = ZZ.transpose(0, 1, 3, 2) + raw_kernel = np.exp(-0.5 * np.squeeze(ZZ_t @ INV_SIGMA @ ZZ)) * (1 + noise) + + # shift the kernel so it will be centered + # raw_kernel_centered = kernel_shift(raw_kernel, scale_factor) + + # Normalize the kernel and return + # kernel = raw_kernel_centered / np.sum(raw_kernel_centered) + kernel = raw_kernel / np.sum(raw_kernel) + return kernel + + +def fspecial_gaussian(hsize, sigma): + hsize = [hsize, hsize] + siz = [(hsize[0] - 1.0) / 2.0, (hsize[1] - 1.0) / 2.0] + std = sigma + [x, y] = np.meshgrid(np.arange(-siz[1], siz[1] + 1), np.arange(-siz[0], siz[0] + 1)) + arg = -(x * x + y * y) / (2 * std * std) + h = np.exp(arg) + h[h < scipy.finfo(float).eps * h.max()] = 0 + sumh = h.sum() + if sumh != 0: + h = h / sumh + return h + + +def fspecial_laplacian(alpha): + alpha = max([0, min([alpha, 1])]) + h1 = alpha / (alpha + 1) + h2 = (1 - alpha) / (alpha + 1) + h = [[h1, h2, h1], [h2, -4 / (alpha + 1), h2], [h1, h2, h1]] + h = np.array(h) + return h + + +def fspecial(filter_type, *args, **kwargs): + ''' + python code from: + https://github.com/ronaldosena/imagens-medicas-2/blob/40171a6c259edec7827a6693a93955de2bd39e76/Aulas/aula_2_-_uniform_filter/matlab_fspecial.py + ''' + if filter_type == 'gaussian': + return fspecial_gaussian(*args, **kwargs) + if filter_type == 'laplacian': + return fspecial_laplacian(*args, **kwargs) + + +""" +# -------------------------------------------- +# degradation models +# -------------------------------------------- +""" + + +def bicubic_degradation(x, sf=3): + ''' + Args: + x: HxWxC image, [0, 1] + sf: down-scale factor + Return: + bicubicly downsampled LR image + ''' + x = util.imresize_np(x, scale=1 / sf) + return x + + +def srmd_degradation(x, k, sf=3): + ''' blur + bicubic downsampling + Args: + x: HxWxC image, [0, 1] + k: hxw, double + sf: down-scale factor + Return: + downsampled LR image + Reference: + @inproceedings{zhang2018learning, + title={Learning a single convolutional super-resolution network for multiple degradations}, + author={Zhang, Kai and Zuo, Wangmeng and Zhang, Lei}, + booktitle={IEEE Conference on Computer Vision and Pattern Recognition}, + pages={3262--3271}, + year={2018} + } + ''' + x = ndimage.convolve(x, np.expand_dims(k, axis=2), mode='wrap') # 'nearest' | 'mirror' + x = bicubic_degradation(x, sf=sf) + return x + + +def dpsr_degradation(x, k, sf=3): + ''' bicubic downsampling + blur + Args: + x: HxWxC image, [0, 1] + k: hxw, double + sf: down-scale factor + Return: + downsampled LR image + Reference: + @inproceedings{zhang2019deep, + title={Deep Plug-and-Play Super-Resolution for Arbitrary Blur Kernels}, + author={Zhang, Kai and Zuo, Wangmeng and Zhang, Lei}, + booktitle={IEEE Conference on Computer Vision and Pattern Recognition}, + pages={1671--1681}, + year={2019} + } + ''' + x = bicubic_degradation(x, sf=sf) + x = ndimage.convolve(x, np.expand_dims(k, axis=2), mode='wrap') + return x + + +def classical_degradation(x, k, sf=3): + ''' blur + downsampling + Args: + x: HxWxC image, [0, 1]/[0, 255] + k: hxw, double + sf: down-scale factor + Return: + downsampled LR image + ''' + x = ndimage.convolve(x, np.expand_dims(k, axis=2), mode='wrap') + # x = filters.correlate(x, np.expand_dims(np.flip(k), axis=2)) + st = 0 + return x[st::sf, st::sf, ...] + + +def add_sharpening(img, weight=0.5, radius=50, threshold=10): + """USM sharpening. borrowed from real-ESRGAN + Input image: I; Blurry image: B. + 1. K = I + weight * (I - B) + 2. Mask = 1 if abs(I - B) > threshold, else: 0 + 3. Blur mask: + 4. Out = Mask * K + (1 - Mask) * I + Args: + img (Numpy array): Input image, HWC, BGR; float32, [0, 1]. + weight (float): Sharp weight. Default: 1. + radius (float): Kernel size of Gaussian blur. Default: 50. + threshold (int): + """ + if radius % 2 == 0: + radius += 1 + blur = cv2.GaussianBlur(img, (radius, radius), 0) + residual = img - blur + mask = np.abs(residual) * 255 > threshold + mask = mask.astype('float32') + soft_mask = cv2.GaussianBlur(mask, (radius, radius), 0) + + K = img + weight * residual + K = np.clip(K, 0, 1) + return soft_mask * K + (1 - soft_mask) * img + + +def add_blur(img, sf=4): + wd2 = 4.0 + sf + wd = 2.0 + 0.2 * sf + + wd2 = wd2/4 + wd = wd/4 + + if random.random() < 0.5: + l1 = wd2 * random.random() + l2 = wd2 * random.random() + k = anisotropic_Gaussian(ksize=random.randint(2, 11) + 3, theta=random.random() * np.pi, l1=l1, l2=l2) + else: + k = fspecial('gaussian', random.randint(2, 4) + 3, wd * random.random()) + img = ndimage.convolve(img, np.expand_dims(k, axis=2), mode='mirror') + + return img + + +def add_resize(img, sf=4): + rnum = np.random.rand() + if rnum > 0.8: # up + sf1 = random.uniform(1, 2) + elif rnum < 0.7: # down + sf1 = random.uniform(0.5 / sf, 1) + else: + sf1 = 1.0 + img = cv2.resize(img, (int(sf1 * img.shape[1]), int(sf1 * img.shape[0])), interpolation=random.choice([1, 2, 3])) + img = np.clip(img, 0.0, 1.0) + + return img + + +# def add_Gaussian_noise(img, noise_level1=2, noise_level2=25): +# noise_level = random.randint(noise_level1, noise_level2) +# rnum = np.random.rand() +# if rnum > 0.6: # add color Gaussian noise +# img += np.random.normal(0, noise_level / 255.0, img.shape).astype(np.float32) +# elif rnum < 0.4: # add grayscale Gaussian noise +# img += np.random.normal(0, noise_level / 255.0, (*img.shape[:2], 1)).astype(np.float32) +# else: # add noise +# L = noise_level2 / 255. +# D = np.diag(np.random.rand(3)) +# U = orth(np.random.rand(3, 3)) +# conv = np.dot(np.dot(np.transpose(U), D), U) +# img += np.random.multivariate_normal([0, 0, 0], np.abs(L ** 2 * conv), img.shape[:2]).astype(np.float32) +# img = np.clip(img, 0.0, 1.0) +# return img + +def add_Gaussian_noise(img, noise_level1=2, noise_level2=25): + noise_level = random.randint(noise_level1, noise_level2) + rnum = np.random.rand() + if rnum > 0.6: # add color Gaussian noise + img = img + np.random.normal(0, noise_level / 255.0, img.shape).astype(np.float32) + elif rnum < 0.4: # add grayscale Gaussian noise + img = img + np.random.normal(0, noise_level / 255.0, (*img.shape[:2], 1)).astype(np.float32) + else: # add noise + L = noise_level2 / 255. + D = np.diag(np.random.rand(3)) + U = orth(np.random.rand(3, 3)) + conv = np.dot(np.dot(np.transpose(U), D), U) + img = img + np.random.multivariate_normal([0, 0, 0], np.abs(L ** 2 * conv), img.shape[:2]).astype(np.float32) + img = np.clip(img, 0.0, 1.0) + return img + + +def add_speckle_noise(img, noise_level1=2, noise_level2=25): + noise_level = random.randint(noise_level1, noise_level2) + img = np.clip(img, 0.0, 1.0) + rnum = random.random() + if rnum > 0.6: + img += img * np.random.normal(0, noise_level / 255.0, img.shape).astype(np.float32) + elif rnum < 0.4: + img += img * np.random.normal(0, noise_level / 255.0, (*img.shape[:2], 1)).astype(np.float32) + else: + L = noise_level2 / 255. + D = np.diag(np.random.rand(3)) + U = orth(np.random.rand(3, 3)) + conv = np.dot(np.dot(np.transpose(U), D), U) + img += img * np.random.multivariate_normal([0, 0, 0], np.abs(L ** 2 * conv), img.shape[:2]).astype(np.float32) + img = np.clip(img, 0.0, 1.0) + return img + + +def add_Poisson_noise(img): + img = np.clip((img * 255.0).round(), 0, 255) / 255. + vals = 10 ** (2 * random.random() + 2.0) # [2, 4] + if random.random() < 0.5: + img = np.random.poisson(img * vals).astype(np.float32) / vals + else: + img_gray = np.dot(img[..., :3], [0.299, 0.587, 0.114]) + img_gray = np.clip((img_gray * 255.0).round(), 0, 255) / 255. + noise_gray = np.random.poisson(img_gray * vals).astype(np.float32) / vals - img_gray + img += noise_gray[:, :, np.newaxis] + img = np.clip(img, 0.0, 1.0) + return img + + +def add_JPEG_noise(img): + quality_factor = random.randint(80, 95) + img = cv2.cvtColor(util.single2uint(img), cv2.COLOR_RGB2BGR) + result, encimg = cv2.imencode('.jpg', img, [int(cv2.IMWRITE_JPEG_QUALITY), quality_factor]) + img = cv2.imdecode(encimg, 1) + img = cv2.cvtColor(util.uint2single(img), cv2.COLOR_BGR2RGB) + return img + + +def random_crop(lq, hq, sf=4, lq_patchsize=64): + h, w = lq.shape[:2] + rnd_h = random.randint(0, h - lq_patchsize) + rnd_w = random.randint(0, w - lq_patchsize) + lq = lq[rnd_h:rnd_h + lq_patchsize, rnd_w:rnd_w + lq_patchsize, :] + + rnd_h_H, rnd_w_H = int(rnd_h * sf), int(rnd_w * sf) + hq = hq[rnd_h_H:rnd_h_H + lq_patchsize * sf, rnd_w_H:rnd_w_H + lq_patchsize * sf, :] + return lq, hq + + +def degradation_bsrgan(img, sf=4, lq_patchsize=72, isp_model=None): + """ + This is the degradation model of BSRGAN from the paper + "Designing a Practical Degradation Model for Deep Blind Image Super-Resolution" + ---------- + img: HXWXC, [0, 1], its size should be large than (lq_patchsizexsf)x(lq_patchsizexsf) + sf: scale factor + isp_model: camera ISP model + Returns + ------- + img: low-quality patch, size: lq_patchsizeXlq_patchsizeXC, range: [0, 1] + hq: corresponding high-quality patch, size: (lq_patchsizexsf)X(lq_patchsizexsf)XC, range: [0, 1] + """ + isp_prob, jpeg_prob, scale2_prob = 0.25, 0.9, 0.25 + sf_ori = sf + + h1, w1 = img.shape[:2] + img = img.copy()[:w1 - w1 % sf, :h1 - h1 % sf, ...] # mod crop + h, w = img.shape[:2] + + if h < lq_patchsize * sf or w < lq_patchsize * sf: + raise ValueError(f'img size ({h1}X{w1}) is too small!') + + hq = img.copy() + + if sf == 4 and random.random() < scale2_prob: # downsample1 + if np.random.rand() < 0.5: + img = cv2.resize(img, (int(1 / 2 * img.shape[1]), int(1 / 2 * img.shape[0])), + interpolation=random.choice([1, 2, 3])) + else: + img = util.imresize_np(img, 1 / 2, True) + img = np.clip(img, 0.0, 1.0) + sf = 2 + + shuffle_order = random.sample(range(7), 7) + idx1, idx2 = shuffle_order.index(2), shuffle_order.index(3) + if idx1 > idx2: # keep downsample3 last + shuffle_order[idx1], shuffle_order[idx2] = shuffle_order[idx2], shuffle_order[idx1] + + for i in shuffle_order: + + if i == 0: + img = add_blur(img, sf=sf) + + elif i == 1: + img = add_blur(img, sf=sf) + + elif i == 2: + a, b = img.shape[1], img.shape[0] + # downsample2 + if random.random() < 0.75: + sf1 = random.uniform(1, 2 * sf) + img = cv2.resize(img, (int(1 / sf1 * img.shape[1]), int(1 / sf1 * img.shape[0])), + interpolation=random.choice([1, 2, 3])) + else: + k = fspecial('gaussian', 25, random.uniform(0.1, 0.6 * sf)) + k_shifted = shift_pixel(k, sf) + k_shifted = k_shifted / k_shifted.sum() # blur with shifted kernel + img = ndimage.convolve(img, np.expand_dims(k_shifted, axis=2), mode='mirror') + img = img[0::sf, 0::sf, ...] # nearest downsampling + img = np.clip(img, 0.0, 1.0) + + elif i == 3: + # downsample3 + img = cv2.resize(img, (int(1 / sf * a), int(1 / sf * b)), interpolation=random.choice([1, 2, 3])) + img = np.clip(img, 0.0, 1.0) + + elif i == 4: + # add Gaussian noise + img = add_Gaussian_noise(img, noise_level1=2, noise_level2=8) + + elif i == 5: + # add JPEG noise + if random.random() < jpeg_prob: + img = add_JPEG_noise(img) + + elif i == 6: + # add processed camera sensor noise + if random.random() < isp_prob and isp_model is not None: + with torch.no_grad(): + img, hq = isp_model.forward(img.copy(), hq) + + # add final JPEG compression noise + img = add_JPEG_noise(img) + + # random crop + img, hq = random_crop(img, hq, sf_ori, lq_patchsize) + + return img, hq + + +# todo no isp_model? +def degradation_bsrgan_variant(image, sf=4, isp_model=None, up=False): + """ + This is the degradation model of BSRGAN from the paper + "Designing a Practical Degradation Model for Deep Blind Image Super-Resolution" + ---------- + sf: scale factor + isp_model: camera ISP model + Returns + ------- + img: low-quality patch, size: lq_patchsizeXlq_patchsizeXC, range: [0, 1] + hq: corresponding high-quality patch, size: (lq_patchsizexsf)X(lq_patchsizexsf)XC, range: [0, 1] + """ + image = util.uint2single(image) + isp_prob, jpeg_prob, scale2_prob = 0.25, 0.9, 0.25 + sf_ori = sf + + h1, w1 = image.shape[:2] + image = image.copy()[:w1 - w1 % sf, :h1 - h1 % sf, ...] # mod crop + h, w = image.shape[:2] + + hq = image.copy() + + if sf == 4 and random.random() < scale2_prob: # downsample1 + if np.random.rand() < 0.5: + image = cv2.resize(image, (int(1 / 2 * image.shape[1]), int(1 / 2 * image.shape[0])), + interpolation=random.choice([1, 2, 3])) + else: + image = util.imresize_np(image, 1 / 2, True) + image = np.clip(image, 0.0, 1.0) + sf = 2 + + shuffle_order = random.sample(range(7), 7) + idx1, idx2 = shuffle_order.index(2), shuffle_order.index(3) + if idx1 > idx2: # keep downsample3 last + shuffle_order[idx1], shuffle_order[idx2] = shuffle_order[idx2], shuffle_order[idx1] + + for i in shuffle_order: + + if i == 0: + image = add_blur(image, sf=sf) + + # elif i == 1: + # image = add_blur(image, sf=sf) + + if i == 0: + pass + + elif i == 2: + a, b = image.shape[1], image.shape[0] + # downsample2 + if random.random() < 0.8: + sf1 = random.uniform(1, 2 * sf) + image = cv2.resize(image, (int(1 / sf1 * image.shape[1]), int(1 / sf1 * image.shape[0])), + interpolation=random.choice([1, 2, 3])) + else: + k = fspecial('gaussian', 25, random.uniform(0.1, 0.6 * sf)) + k_shifted = shift_pixel(k, sf) + k_shifted = k_shifted / k_shifted.sum() # blur with shifted kernel + image = ndimage.convolve(image, np.expand_dims(k_shifted, axis=2), mode='mirror') + image = image[0::sf, 0::sf, ...] # nearest downsampling + + image = np.clip(image, 0.0, 1.0) + + elif i == 3: + # downsample3 + image = cv2.resize(image, (int(1 / sf * a), int(1 / sf * b)), interpolation=random.choice([1, 2, 3])) + image = np.clip(image, 0.0, 1.0) + + elif i == 4: + # add Gaussian noise + image = add_Gaussian_noise(image, noise_level1=1, noise_level2=2) + + elif i == 5: + # add JPEG noise + if random.random() < jpeg_prob: + image = add_JPEG_noise(image) + # + # elif i == 6: + # # add processed camera sensor noise + # if random.random() < isp_prob and isp_model is not None: + # with torch.no_grad(): + # img, hq = isp_model.forward(img.copy(), hq) + + # add final JPEG compression noise + image = add_JPEG_noise(image) + image = util.single2uint(image) + if up: + image = cv2.resize(image, (w1, h1), interpolation=cv2.INTER_CUBIC) # todo: random, as above? want to condition on it then + example = {"image": image} + return example + + + + +if __name__ == '__main__': + print("hey") + img = util.imread_uint('utils/test.png', 3) + img = img[:448, :448] + h = img.shape[0] // 4 + print("resizing to", h) + sf = 4 + deg_fn = partial(degradation_bsrgan_variant, sf=sf) + for i in range(20): + print(i) + img_hq = img + img_lq = deg_fn(img)["image"] + img_hq, img_lq = util.uint2single(img_hq), util.uint2single(img_lq) + print(img_lq) + img_lq_bicubic = albumentations.SmallestMaxSize(max_size=h, interpolation=cv2.INTER_CUBIC)(image=img_hq)["image"] + print(img_lq.shape) + print("bicubic", img_lq_bicubic.shape) + print(img_hq.shape) + lq_nearest = cv2.resize(util.single2uint(img_lq), (int(sf * img_lq.shape[1]), int(sf * img_lq.shape[0])), + interpolation=0) + lq_bicubic_nearest = cv2.resize(util.single2uint(img_lq_bicubic), + (int(sf * img_lq.shape[1]), int(sf * img_lq.shape[0])), + interpolation=0) + img_concat = np.concatenate([lq_bicubic_nearest, lq_nearest, util.single2uint(img_hq)], axis=1) + util.imsave(img_concat, str(i) + '.png') diff --git a/ldm/modules/image_degradation/utils_image.py b/ldm/modules/image_degradation/utils_image.py new file mode 100644 index 0000000000000000000000000000000000000000..0175f155ad900ae33c3c46ed87f49b352e3faf98 --- /dev/null +++ b/ldm/modules/image_degradation/utils_image.py @@ -0,0 +1,916 @@ +import os +import math +import random +import numpy as np +import torch +import cv2 +from torchvision.utils import make_grid +from datetime import datetime +#import matplotlib.pyplot as plt # TODO: check with Dominik, also bsrgan.py vs bsrgan_light.py + + +os.environ["KMP_DUPLICATE_LIB_OK"]="TRUE" + + +''' +# -------------------------------------------- +# Kai Zhang (github: https://github.com/cszn) +# 03/Mar/2019 +# -------------------------------------------- +# https://github.com/twhui/SRGAN-pyTorch +# https://github.com/xinntao/BasicSR +# -------------------------------------------- +''' + + +IMG_EXTENSIONS = ['.jpg', '.JPG', '.jpeg', '.JPEG', '.png', '.PNG', '.ppm', '.PPM', '.bmp', '.BMP', '.tif'] + + +def is_image_file(filename): + return any(filename.endswith(extension) for extension in IMG_EXTENSIONS) + + +def get_timestamp(): + return datetime.now().strftime('%y%m%d-%H%M%S') + + +def imshow(x, title=None, cbar=False, figsize=None): + plt.figure(figsize=figsize) + plt.imshow(np.squeeze(x), interpolation='nearest', cmap='gray') + if title: + plt.title(title) + if cbar: + plt.colorbar() + plt.show() + + +def surf(Z, cmap='rainbow', figsize=None): + plt.figure(figsize=figsize) + ax3 = plt.axes(projection='3d') + + w, h = Z.shape[:2] + xx = np.arange(0,w,1) + yy = np.arange(0,h,1) + X, Y = np.meshgrid(xx, yy) + ax3.plot_surface(X,Y,Z,cmap=cmap) + #ax3.contour(X,Y,Z, zdim='z',offset=-2，cmap=cmap) + plt.show() + + +''' +# -------------------------------------------- +# get image pathes +# -------------------------------------------- +''' + + +def get_image_paths(dataroot): + paths = None # return None if dataroot is None + if dataroot is not None: + paths = sorted(_get_paths_from_images(dataroot)) + return paths + + +def _get_paths_from_images(path): + assert os.path.isdir(path), '{:s} is not a valid directory'.format(path) + images = [] + for dirpath, _, fnames in sorted(os.walk(path)): + for fname in sorted(fnames): + if is_image_file(fname): + img_path = os.path.join(dirpath, fname) + images.append(img_path) + assert images, '{:s} has no valid image file'.format(path) + return images + + +''' +# -------------------------------------------- +# split large images into small images +# -------------------------------------------- +''' + + +def patches_from_image(img, p_size=512, p_overlap=64, p_max=800): + w, h = img.shape[:2] + patches = [] + if w > p_max and h > p_max: + w1 = list(np.arange(0, w-p_size, p_size-p_overlap, dtype=np.int)) + h1 = list(np.arange(0, h-p_size, p_size-p_overlap, dtype=np.int)) + w1.append(w-p_size) + h1.append(h-p_size) +# print(w1) +# print(h1) + for i in w1: + for j in h1: + patches.append(img[i:i+p_size, j:j+p_size,:]) + else: + patches.append(img) + + return patches + + +def imssave(imgs, img_path): + """ + imgs: list, N images of size WxHxC + """ + img_name, ext = os.path.splitext(os.path.basename(img_path)) + + for i, img in enumerate(imgs): + if img.ndim == 3: + img = img[:, :, [2, 1, 0]] + new_path = os.path.join(os.path.dirname(img_path), img_name+str('_s{:04d}'.format(i))+'.png') + cv2.imwrite(new_path, img) + + +def split_imageset(original_dataroot, taget_dataroot, n_channels=3, p_size=800, p_overlap=96, p_max=1000): + """ + split the large images from original_dataroot into small overlapped images with size (p_size)x(p_size), + and save them into taget_dataroot; only the images with larger size than (p_max)x(p_max) + will be splitted. + Args: + original_dataroot: + taget_dataroot: + p_size: size of small images + p_overlap: patch size in training is a good choice + p_max: images with smaller size than (p_max)x(p_max) keep unchanged. + """ + paths = get_image_paths(original_dataroot) + for img_path in paths: + # img_name, ext = os.path.splitext(os.path.basename(img_path)) + img = imread_uint(img_path, n_channels=n_channels) + patches = patches_from_image(img, p_size, p_overlap, p_max) + imssave(patches, os.path.join(taget_dataroot,os.path.basename(img_path))) + #if original_dataroot == taget_dataroot: + #del img_path + +''' +# -------------------------------------------- +# makedir +# -------------------------------------------- +''' + + +def mkdir(path): + if not os.path.exists(path): + os.makedirs(path) + + +def mkdirs(paths): + if isinstance(paths, str): + mkdir(paths) + else: + for path in paths: + mkdir(path) + + +def mkdir_and_rename(path): + if os.path.exists(path): + new_name = path + '_archived_' + get_timestamp() + print('Path already exists. Rename it to [{:s}]'.format(new_name)) + os.rename(path, new_name) + os.makedirs(path) + + +''' +# -------------------------------------------- +# read image from path +# opencv is fast, but read BGR numpy image +# -------------------------------------------- +''' + + +# -------------------------------------------- +# get uint8 image of size HxWxn_channles (RGB) +# -------------------------------------------- +def imread_uint(path, n_channels=3): + # input: path + # output: HxWx3(RGB or GGG), or HxWx1 (G) + if n_channels == 1: + img = cv2.imread(path, 0) # cv2.IMREAD_GRAYSCALE + img = np.expand_dims(img, axis=2) # HxWx1 + elif n_channels == 3: + img = cv2.imread(path, cv2.IMREAD_UNCHANGED) # BGR or G + if img.ndim == 2: + img = cv2.cvtColor(img, cv2.COLOR_GRAY2RGB) # GGG + else: + img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) # RGB + return img + + +# -------------------------------------------- +# matlab's imwrite +# -------------------------------------------- +def imsave(img, img_path): + img = np.squeeze(img) + if img.ndim == 3: + img = img[:, :, [2, 1, 0]] + cv2.imwrite(img_path, img) + +def imwrite(img, img_path): + img = np.squeeze(img) + if img.ndim == 3: + img = img[:, :, [2, 1, 0]] + cv2.imwrite(img_path, img) + + + +# -------------------------------------------- +# get single image of size HxWxn_channles (BGR) +# -------------------------------------------- +def read_img(path): + # read image by cv2 + # return: Numpy float32, HWC, BGR, [0,1] + img = cv2.imread(path, cv2.IMREAD_UNCHANGED) # cv2.IMREAD_GRAYSCALE + img = img.astype(np.float32) / 255. + if img.ndim == 2: + img = np.expand_dims(img, axis=2) + # some images have 4 channels + if img.shape[2] > 3: + img = img[:, :, :3] + return img + + +''' +# -------------------------------------------- +# image format conversion +# -------------------------------------------- +# numpy(single) <---> numpy(unit) +# numpy(single) <---> tensor +# numpy(unit) <---> tensor +# -------------------------------------------- +''' + + +# -------------------------------------------- +# numpy(single) [0, 1] <---> numpy(unit) +# -------------------------------------------- + + +def uint2single(img): + + return np.float32(img/255.) + + +def single2uint(img): + + return np.uint8((img.clip(0, 1)*255.).round()) + + +def uint162single(img): + + return np.float32(img/65535.) + + +def single2uint16(img): + + return np.uint16((img.clip(0, 1)*65535.).round()) + + +# -------------------------------------------- +# numpy(unit) (HxWxC or HxW) <---> tensor +# -------------------------------------------- + + +# convert uint to 4-dimensional torch tensor +def uint2tensor4(img): + if img.ndim == 2: + img = np.expand_dims(img, axis=2) + return torch.from_numpy(np.ascontiguousarray(img)).permute(2, 0, 1).float().div(255.).unsqueeze(0) + + +# convert uint to 3-dimensional torch tensor +def uint2tensor3(img): + if img.ndim == 2: + img = np.expand_dims(img, axis=2) + return torch.from_numpy(np.ascontiguousarray(img)).permute(2, 0, 1).float().div(255.) + + +# convert 2/3/4-dimensional torch tensor to uint +def tensor2uint(img): + img = img.data.squeeze().float().clamp_(0, 1).cpu().numpy() + if img.ndim == 3: + img = np.transpose(img, (1, 2, 0)) + return np.uint8((img*255.0).round()) + + +# -------------------------------------------- +# numpy(single) (HxWxC) <---> tensor +# -------------------------------------------- + + +# convert single (HxWxC) to 3-dimensional torch tensor +def single2tensor3(img): + return torch.from_numpy(np.ascontiguousarray(img)).permute(2, 0, 1).float() + + +# convert single (HxWxC) to 4-dimensional torch tensor +def single2tensor4(img): + return torch.from_numpy(np.ascontiguousarray(img)).permute(2, 0, 1).float().unsqueeze(0) + + +# convert torch tensor to single +def tensor2single(img): + img = img.data.squeeze().float().cpu().numpy() + if img.ndim == 3: + img = np.transpose(img, (1, 2, 0)) + + return img + +# convert torch tensor to single +def tensor2single3(img): + img = img.data.squeeze().float().cpu().numpy() + if img.ndim == 3: + img = np.transpose(img, (1, 2, 0)) + elif img.ndim == 2: + img = np.expand_dims(img, axis=2) + return img + + +def single2tensor5(img): + return torch.from_numpy(np.ascontiguousarray(img)).permute(2, 0, 1, 3).float().unsqueeze(0) + + +def single32tensor5(img): + return torch.from_numpy(np.ascontiguousarray(img)).float().unsqueeze(0).unsqueeze(0) + + +def single42tensor4(img): + return torch.from_numpy(np.ascontiguousarray(img)).permute(2, 0, 1, 3).float() + + +# from skimage.io import imread, imsave +def tensor2img(tensor, out_type=np.uint8, min_max=(0, 1)): + ''' + Converts a torch Tensor into an image Numpy array of BGR channel order + Input: 4D(B,(3/1),H,W), 3D(C,H,W), or 2D(H,W), any range, RGB channel order + Output: 3D(H,W,C) or 2D(H,W), [0,255], np.uint8 (default) + ''' + tensor = tensor.squeeze().float().cpu().clamp_(*min_max) # squeeze first, then clamp + tensor = (tensor - min_max[0]) / (min_max[1] - min_max[0]) # to range [0,1] + n_dim = tensor.dim() + if n_dim == 4: + n_img = len(tensor) + img_np = make_grid(tensor, nrow=int(math.sqrt(n_img)), normalize=False).numpy() + img_np = np.transpose(img_np[[2, 1, 0], :, :], (1, 2, 0)) # HWC, BGR + elif n_dim == 3: + img_np = tensor.numpy() + img_np = np.transpose(img_np[[2, 1, 0], :, :], (1, 2, 0)) # HWC, BGR + elif n_dim == 2: + img_np = tensor.numpy() + else: + raise TypeError( + 'Only support 4D, 3D and 2D tensor. But received with dimension: {:d}'.format(n_dim)) + if out_type == np.uint8: + img_np = (img_np * 255.0).round() + # Important. Unlike matlab, numpy.unit8() WILL NOT round by default. + return img_np.astype(out_type) + + +''' +# -------------------------------------------- +# Augmentation, flipe and/or rotate +# -------------------------------------------- +# The following two are enough. +# (1) augmet_img: numpy image of WxHxC or WxH +# (2) augment_img_tensor4: tensor image 1xCxWxH +# -------------------------------------------- +''' + + +def augment_img(img, mode=0): + '''Kai Zhang (github: https://github.com/cszn) + ''' + if mode == 0: + return img + elif mode == 1: + return np.flipud(np.rot90(img)) + elif mode == 2: + return np.flipud(img) + elif mode == 3: + return np.rot90(img, k=3) + elif mode == 4: + return np.flipud(np.rot90(img, k=2)) + elif mode == 5: + return np.rot90(img) + elif mode == 6: + return np.rot90(img, k=2) + elif mode == 7: + return np.flipud(np.rot90(img, k=3)) + + +def augment_img_tensor4(img, mode=0): + '''Kai Zhang (github: https://github.com/cszn) + ''' + if mode == 0: + return img + elif mode == 1: + return img.rot90(1, [2, 3]).flip([2]) + elif mode == 2: + return img.flip([2]) + elif mode == 3: + return img.rot90(3, [2, 3]) + elif mode == 4: + return img.rot90(2, [2, 3]).flip([2]) + elif mode == 5: + return img.rot90(1, [2, 3]) + elif mode == 6: + return img.rot90(2, [2, 3]) + elif mode == 7: + return img.rot90(3, [2, 3]).flip([2]) + + +def augment_img_tensor(img, mode=0): + '''Kai Zhang (github: https://github.com/cszn) + ''' + img_size = img.size() + img_np = img.data.cpu().numpy() + if len(img_size) == 3: + img_np = np.transpose(img_np, (1, 2, 0)) + elif len(img_size) == 4: + img_np = np.transpose(img_np, (2, 3, 1, 0)) + img_np = augment_img(img_np, mode=mode) + img_tensor = torch.from_numpy(np.ascontiguousarray(img_np)) + if len(img_size) == 3: + img_tensor = img_tensor.permute(2, 0, 1) + elif len(img_size) == 4: + img_tensor = img_tensor.permute(3, 2, 0, 1) + + return img_tensor.type_as(img) + + +def augment_img_np3(img, mode=0): + if mode == 0: + return img + elif mode == 1: + return img.transpose(1, 0, 2) + elif mode == 2: + return img[::-1, :, :] + elif mode == 3: + img = img[::-1, :, :] + img = img.transpose(1, 0, 2) + return img + elif mode == 4: + return img[:, ::-1, :] + elif mode == 5: + img = img[:, ::-1, :] + img = img.transpose(1, 0, 2) + return img + elif mode == 6: + img = img[:, ::-1, :] + img = img[::-1, :, :] + return img + elif mode == 7: + img = img[:, ::-1, :] + img = img[::-1, :, :] + img = img.transpose(1, 0, 2) + return img + + +def augment_imgs(img_list, hflip=True, rot=True): + # horizontal flip OR rotate + hflip = hflip and random.random() < 0.5 + vflip = rot and random.random() < 0.5 + rot90 = rot and random.random() < 0.5 + + def _augment(img): + if hflip: + img = img[:, ::-1, :] + if vflip: + img = img[::-1, :, :] + if rot90: + img = img.transpose(1, 0, 2) + return img + + return [_augment(img) for img in img_list] + + +''' +# -------------------------------------------- +# modcrop and shave +# -------------------------------------------- +''' + + +def modcrop(img_in, scale): + # img_in: Numpy, HWC or HW + img = np.copy(img_in) + if img.ndim == 2: + H, W = img.shape + H_r, W_r = H % scale, W % scale + img = img[:H - H_r, :W - W_r] + elif img.ndim == 3: + H, W, C = img.shape + H_r, W_r = H % scale, W % scale + img = img[:H - H_r, :W - W_r, :] + else: + raise ValueError('Wrong img ndim: [{:d}].'.format(img.ndim)) + return img + + +def shave(img_in, border=0): + # img_in: Numpy, HWC or HW + img = np.copy(img_in) + h, w = img.shape[:2] + img = img[border:h-border, border:w-border] + return img + + +''' +# -------------------------------------------- +# image processing process on numpy image +# channel_convert(in_c, tar_type, img_list): +# rgb2ycbcr(img, only_y=True): +# bgr2ycbcr(img, only_y=True): +# ycbcr2rgb(img): +# -------------------------------------------- +''' + + +def rgb2ycbcr(img, only_y=True): + '''same as matlab rgb2ycbcr + only_y: only return Y channel + Input: + uint8, [0, 255] + float, [0, 1] + ''' + in_img_type = img.dtype + img.astype(np.float32) + if in_img_type != np.uint8: + img *= 255. + # convert + if only_y: + rlt = np.dot(img, [65.481, 128.553, 24.966]) / 255.0 + 16.0 + else: + rlt = np.matmul(img, [[65.481, -37.797, 112.0], [128.553, -74.203, -93.786], + [24.966, 112.0, -18.214]]) / 255.0 + [16, 128, 128] + if in_img_type == np.uint8: + rlt = rlt.round() + else: + rlt /= 255. + return rlt.astype(in_img_type) + + +def ycbcr2rgb(img): + '''same as matlab ycbcr2rgb + Input: + uint8, [0, 255] + float, [0, 1] + ''' + in_img_type = img.dtype + img.astype(np.float32) + if in_img_type != np.uint8: + img *= 255. + # convert + rlt = np.matmul(img, [[0.00456621, 0.00456621, 0.00456621], [0, -0.00153632, 0.00791071], + [0.00625893, -0.00318811, 0]]) * 255.0 + [-222.921, 135.576, -276.836] + if in_img_type == np.uint8: + rlt = rlt.round() + else: + rlt /= 255. + return rlt.astype(in_img_type) + + +def bgr2ycbcr(img, only_y=True): + '''bgr version of rgb2ycbcr + only_y: only return Y channel + Input: + uint8, [0, 255] + float, [0, 1] + ''' + in_img_type = img.dtype + img.astype(np.float32) + if in_img_type != np.uint8: + img *= 255. + # convert + if only_y: + rlt = np.dot(img, [24.966, 128.553, 65.481]) / 255.0 + 16.0 + else: + rlt = np.matmul(img, [[24.966, 112.0, -18.214], [128.553, -74.203, -93.786], + [65.481, -37.797, 112.0]]) / 255.0 + [16, 128, 128] + if in_img_type == np.uint8: + rlt = rlt.round() + else: + rlt /= 255. + return rlt.astype(in_img_type) + + +def channel_convert(in_c, tar_type, img_list): + # conversion among BGR, gray and y + if in_c == 3 and tar_type == 'gray': # BGR to gray + gray_list = [cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) for img in img_list] + return [np.expand_dims(img, axis=2) for img in gray_list] + elif in_c == 3 and tar_type == 'y': # BGR to y + y_list = [bgr2ycbcr(img, only_y=True) for img in img_list] + return [np.expand_dims(img, axis=2) for img in y_list] + elif in_c == 1 and tar_type == 'RGB': # gray/y to BGR + return [cv2.cvtColor(img, cv2.COLOR_GRAY2BGR) for img in img_list] + else: + return img_list + + +''' +# -------------------------------------------- +# metric, PSNR and SSIM +# -------------------------------------------- +''' + + +# -------------------------------------------- +# PSNR +# -------------------------------------------- +def calculate_psnr(img1, img2, border=0): + # img1 and img2 have range [0, 255] + #img1 = img1.squeeze() + #img2 = img2.squeeze() + if not img1.shape == img2.shape: + raise ValueError('Input images must have the same dimensions.') + h, w = img1.shape[:2] + img1 = img1[border:h-border, border:w-border] + img2 = img2[border:h-border, border:w-border] + + img1 = img1.astype(np.float64) + img2 = img2.astype(np.float64) + mse = np.mean((img1 - img2)**2) + if mse == 0: + return float('inf') + return 20 * math.log10(255.0 / math.sqrt(mse)) + + +# -------------------------------------------- +# SSIM +# -------------------------------------------- +def calculate_ssim(img1, img2, border=0): + '''calculate SSIM + the same outputs as MATLAB's + img1, img2: [0, 255] + ''' + #img1 = img1.squeeze() + #img2 = img2.squeeze() + if not img1.shape == img2.shape: + raise ValueError('Input images must have the same dimensions.') + h, w = img1.shape[:2] + img1 = img1[border:h-border, border:w-border] + img2 = img2[border:h-border, border:w-border] + + if img1.ndim == 2: + return ssim(img1, img2) + elif img1.ndim == 3: + if img1.shape[2] == 3: + ssims = [] + for i in range(3): + ssims.append(ssim(img1[:,:,i], img2[:,:,i])) + return np.array(ssims).mean() + elif img1.shape[2] == 1: + return ssim(np.squeeze(img1), np.squeeze(img2)) + else: + raise ValueError('Wrong input image dimensions.') + + +def ssim(img1, img2): + C1 = (0.01 * 255)**2 + C2 = (0.03 * 255)**2 + + img1 = img1.astype(np.float64) + img2 = img2.astype(np.float64) + kernel = cv2.getGaussianKernel(11, 1.5) + window = np.outer(kernel, kernel.transpose()) + + mu1 = cv2.filter2D(img1, -1, window)[5:-5, 5:-5] # valid + mu2 = cv2.filter2D(img2, -1, window)[5:-5, 5:-5] + mu1_sq = mu1**2 + mu2_sq = mu2**2 + mu1_mu2 = mu1 * mu2 + sigma1_sq = cv2.filter2D(img1**2, -1, window)[5:-5, 5:-5] - mu1_sq + sigma2_sq = cv2.filter2D(img2**2, -1, window)[5:-5, 5:-5] - mu2_sq + sigma12 = cv2.filter2D(img1 * img2, -1, window)[5:-5, 5:-5] - mu1_mu2 + + ssim_map = ((2 * mu1_mu2 + C1) * (2 * sigma12 + C2)) / ((mu1_sq + mu2_sq + C1) * + (sigma1_sq + sigma2_sq + C2)) + return ssim_map.mean() + + +''' +# -------------------------------------------- +# matlab's bicubic imresize (numpy and torch) [0, 1] +# -------------------------------------------- +''' + + +# matlab 'imresize' function, now only support 'bicubic' +def cubic(x): + absx = torch.abs(x) + absx2 = absx**2 + absx3 = absx**3 + return (1.5*absx3 - 2.5*absx2 + 1) * ((absx <= 1).type_as(absx)) + \ + (-0.5*absx3 + 2.5*absx2 - 4*absx + 2) * (((absx > 1)*(absx <= 2)).type_as(absx)) + + +def calculate_weights_indices(in_length, out_length, scale, kernel, kernel_width, antialiasing): + if (scale < 1) and (antialiasing): + # Use a modified kernel to simultaneously interpolate and antialias- larger kernel width + kernel_width = kernel_width / scale + + # Output-space coordinates + x = torch.linspace(1, out_length, out_length) + + # Input-space coordinates. Calculate the inverse mapping such that 0.5 + # in output space maps to 0.5 in input space, and 0.5+scale in output + # space maps to 1.5 in input space. + u = x / scale + 0.5 * (1 - 1 / scale) + + # What is the left-most pixel that can be involved in the computation? + left = torch.floor(u - kernel_width / 2) + + # What is the maximum number of pixels that can be involved in the + # computation? Note: it's OK to use an extra pixel here; if the + # corresponding weights are all zero, it will be eliminated at the end + # of this function. + P = math.ceil(kernel_width) + 2 + + # The indices of the input pixels involved in computing the k-th output + # pixel are in row k of the indices matrix. + indices = left.view(out_length, 1).expand(out_length, P) + torch.linspace(0, P - 1, P).view( + 1, P).expand(out_length, P) + + # The weights used to compute the k-th output pixel are in row k of the + # weights matrix. + distance_to_center = u.view(out_length, 1).expand(out_length, P) - indices + # apply cubic kernel + if (scale < 1) and (antialiasing): + weights = scale * cubic(distance_to_center * scale) + else: + weights = cubic(distance_to_center) + # Normalize the weights matrix so that each row sums to 1. + weights_sum = torch.sum(weights, 1).view(out_length, 1) + weights = weights / weights_sum.expand(out_length, P) + + # If a column in weights is all zero, get rid of it. only consider the first and last column. + weights_zero_tmp = torch.sum((weights == 0), 0) + if not math.isclose(weights_zero_tmp[0], 0, rel_tol=1e-6): + indices = indices.narrow(1, 1, P - 2) + weights = weights.narrow(1, 1, P - 2) + if not math.isclose(weights_zero_tmp[-1], 0, rel_tol=1e-6): + indices = indices.narrow(1, 0, P - 2) + weights = weights.narrow(1, 0, P - 2) + weights = weights.contiguous() + indices = indices.contiguous() + sym_len_s = -indices.min() + 1 + sym_len_e = indices.max() - in_length + indices = indices + sym_len_s - 1 + return weights, indices, int(sym_len_s), int(sym_len_e) + + +# -------------------------------------------- +# imresize for tensor image [0, 1] +# -------------------------------------------- +def imresize(img, scale, antialiasing=True): + # Now the scale should be the same for H and W + # input: img: pytorch tensor, CHW or HW [0,1] + # output: CHW or HW [0,1] w/o round + need_squeeze = True if img.dim() == 2 else False + if need_squeeze: + img.unsqueeze_(0) + in_C, in_H, in_W = img.size() + out_C, out_H, out_W = in_C, math.ceil(in_H * scale), math.ceil(in_W * scale) + kernel_width = 4 + kernel = 'cubic' + + # Return the desired dimension order for performing the resize. The + # strategy is to perform the resize first along the dimension with the + # smallest scale factor. + # Now we do not support this. + + # get weights and indices + weights_H, indices_H, sym_len_Hs, sym_len_He = calculate_weights_indices( + in_H, out_H, scale, kernel, kernel_width, antialiasing) + weights_W, indices_W, sym_len_Ws, sym_len_We = calculate_weights_indices( + in_W, out_W, scale, kernel, kernel_width, antialiasing) + # process H dimension + # symmetric copying + img_aug = torch.FloatTensor(in_C, in_H + sym_len_Hs + sym_len_He, in_W) + img_aug.narrow(1, sym_len_Hs, in_H).copy_(img) + + sym_patch = img[:, :sym_len_Hs, :] + inv_idx = torch.arange(sym_patch.size(1) - 1, -1, -1).long() + sym_patch_inv = sym_patch.index_select(1, inv_idx) + img_aug.narrow(1, 0, sym_len_Hs).copy_(sym_patch_inv) + + sym_patch = img[:, -sym_len_He:, :] + inv_idx = torch.arange(sym_patch.size(1) - 1, -1, -1).long() + sym_patch_inv = sym_patch.index_select(1, inv_idx) + img_aug.narrow(1, sym_len_Hs + in_H, sym_len_He).copy_(sym_patch_inv) + + out_1 = torch.FloatTensor(in_C, out_H, in_W) + kernel_width = weights_H.size(1) + for i in range(out_H): + idx = int(indices_H[i][0]) + for j in range(out_C): + out_1[j, i, :] = img_aug[j, idx:idx + kernel_width, :].transpose(0, 1).mv(weights_H[i]) + + # process W dimension + # symmetric copying + out_1_aug = torch.FloatTensor(in_C, out_H, in_W + sym_len_Ws + sym_len_We) + out_1_aug.narrow(2, sym_len_Ws, in_W).copy_(out_1) + + sym_patch = out_1[:, :, :sym_len_Ws] + inv_idx = torch.arange(sym_patch.size(2) - 1, -1, -1).long() + sym_patch_inv = sym_patch.index_select(2, inv_idx) + out_1_aug.narrow(2, 0, sym_len_Ws).copy_(sym_patch_inv) + + sym_patch = out_1[:, :, -sym_len_We:] + inv_idx = torch.arange(sym_patch.size(2) - 1, -1, -1).long() + sym_patch_inv = sym_patch.index_select(2, inv_idx) + out_1_aug.narrow(2, sym_len_Ws + in_W, sym_len_We).copy_(sym_patch_inv) + + out_2 = torch.FloatTensor(in_C, out_H, out_W) + kernel_width = weights_W.size(1) + for i in range(out_W): + idx = int(indices_W[i][0]) + for j in range(out_C): + out_2[j, :, i] = out_1_aug[j, :, idx:idx + kernel_width].mv(weights_W[i]) + if need_squeeze: + out_2.squeeze_() + return out_2 + + +# -------------------------------------------- +# imresize for numpy image [0, 1] +# -------------------------------------------- +def imresize_np(img, scale, antialiasing=True): + # Now the scale should be the same for H and W + # input: img: Numpy, HWC or HW [0,1] + # output: HWC or HW [0,1] w/o round + img = torch.from_numpy(img) + need_squeeze = True if img.dim() == 2 else False + if need_squeeze: + img.unsqueeze_(2) + + in_H, in_W, in_C = img.size() + out_C, out_H, out_W = in_C, math.ceil(in_H * scale), math.ceil(in_W * scale) + kernel_width = 4 + kernel = 'cubic' + + # Return the desired dimension order for performing the resize. The + # strategy is to perform the resize first along the dimension with the + # smallest scale factor. + # Now we do not support this. + + # get weights and indices + weights_H, indices_H, sym_len_Hs, sym_len_He = calculate_weights_indices( + in_H, out_H, scale, kernel, kernel_width, antialiasing) + weights_W, indices_W, sym_len_Ws, sym_len_We = calculate_weights_indices( + in_W, out_W, scale, kernel, kernel_width, antialiasing) + # process H dimension + # symmetric copying + img_aug = torch.FloatTensor(in_H + sym_len_Hs + sym_len_He, in_W, in_C) + img_aug.narrow(0, sym_len_Hs, in_H).copy_(img) + + sym_patch = img[:sym_len_Hs, :, :] + inv_idx = torch.arange(sym_patch.size(0) - 1, -1, -1).long() + sym_patch_inv = sym_patch.index_select(0, inv_idx) + img_aug.narrow(0, 0, sym_len_Hs).copy_(sym_patch_inv) + + sym_patch = img[-sym_len_He:, :, :] + inv_idx = torch.arange(sym_patch.size(0) - 1, -1, -1).long() + sym_patch_inv = sym_patch.index_select(0, inv_idx) + img_aug.narrow(0, sym_len_Hs + in_H, sym_len_He).copy_(sym_patch_inv) + + out_1 = torch.FloatTensor(out_H, in_W, in_C) + kernel_width = weights_H.size(1) + for i in range(out_H): + idx = int(indices_H[i][0]) + for j in range(out_C): + out_1[i, :, j] = img_aug[idx:idx + kernel_width, :, j].transpose(0, 1).mv(weights_H[i]) + + # process W dimension + # symmetric copying + out_1_aug = torch.FloatTensor(out_H, in_W + sym_len_Ws + sym_len_We, in_C) + out_1_aug.narrow(1, sym_len_Ws, in_W).copy_(out_1) + + sym_patch = out_1[:, :sym_len_Ws, :] + inv_idx = torch.arange(sym_patch.size(1) - 1, -1, -1).long() + sym_patch_inv = sym_patch.index_select(1, inv_idx) + out_1_aug.narrow(1, 0, sym_len_Ws).copy_(sym_patch_inv) + + sym_patch = out_1[:, -sym_len_We:, :] + inv_idx = torch.arange(sym_patch.size(1) - 1, -1, -1).long() + sym_patch_inv = sym_patch.index_select(1, inv_idx) + out_1_aug.narrow(1, sym_len_Ws + in_W, sym_len_We).copy_(sym_patch_inv) + + out_2 = torch.FloatTensor(out_H, out_W, in_C) + kernel_width = weights_W.size(1) + for i in range(out_W): + idx = int(indices_W[i][0]) + for j in range(out_C): + out_2[:, i, j] = out_1_aug[:, idx:idx + kernel_width, j].mv(weights_W[i]) + if need_squeeze: + out_2.squeeze_() + + return out_2.numpy() + + +if __name__ == '__main__': + print('---') +# img = imread_uint('test.bmp', 3) +# img = uint2single(img) +# img_bicubic = imresize_np(img, 1/4) \ No newline at end of file diff --git a/ldm/modules/karlo/__init__.py b/ldm/modules/karlo/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/ldm/modules/karlo/diffusers_pipeline.py b/ldm/modules/karlo/diffusers_pipeline.py new file mode 100644 index 0000000000000000000000000000000000000000..07f72b35a6e05390430880f190ed425985a4a5ef --- /dev/null +++ b/ldm/modules/karlo/diffusers_pipeline.py @@ -0,0 +1,512 @@ +# Copyright 2022 Kakao Brain and The HuggingFace Team. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import inspect +from typing import List, Optional, Tuple, Union + +import torch +from torch.nn import functional as F + +from transformers import CLIPTextModelWithProjection, CLIPTokenizer +from transformers.models.clip.modeling_clip import CLIPTextModelOutput + +from ...models import PriorTransformer, UNet2DConditionModel, UNet2DModel +from ...pipelines import DiffusionPipeline, ImagePipelineOutput +from ...schedulers import UnCLIPScheduler +from ...utils import is_accelerate_available, logging, randn_tensor +from .text_proj import UnCLIPTextProjModel + + +logger = logging.get_logger(__name__) # pylint: disable=invalid-name + + +class UnCLIPPipeline(DiffusionPipeline): + """ + Pipeline for text-to-image generation using unCLIP + This model inherits from [`DiffusionPipeline`]. Check the superclass documentation for the generic methods the + library implements for all the pipelines (such as downloading or saving, running on a particular device, etc.) + Args: + text_encoder ([`CLIPTextModelWithProjection`]): + Frozen text-encoder. + tokenizer (`CLIPTokenizer`): + Tokenizer of class + [CLIPTokenizer](https://huggingface.co/docs/transformers/v4.21.0/en/model_doc/clip#transformers.CLIPTokenizer). + prior ([`PriorTransformer`]): + The canonincal unCLIP prior to approximate the image embedding from the text embedding. + text_proj ([`UnCLIPTextProjModel`]): + Utility class to prepare and combine the embeddings before they are passed to the decoder. + decoder ([`UNet2DConditionModel`]): + The decoder to invert the image embedding into an image. + super_res_first ([`UNet2DModel`]): + Super resolution unet. Used in all but the last step of the super resolution diffusion process. + super_res_last ([`UNet2DModel`]): + Super resolution unet. Used in the last step of the super resolution diffusion process. + prior_scheduler ([`UnCLIPScheduler`]): + Scheduler used in the prior denoising process. Just a modified DDPMScheduler. + decoder_scheduler ([`UnCLIPScheduler`]): + Scheduler used in the decoder denoising process. Just a modified DDPMScheduler. + super_res_scheduler ([`UnCLIPScheduler`]): + Scheduler used in the super resolution denoising process. Just a modified DDPMScheduler. + """ + + prior: PriorTransformer + decoder: UNet2DConditionModel + text_proj: UnCLIPTextProjModel + text_encoder: CLIPTextModelWithProjection + tokenizer: CLIPTokenizer + super_res_first: UNet2DModel + super_res_last: UNet2DModel + + prior_scheduler: UnCLIPScheduler + decoder_scheduler: UnCLIPScheduler + super_res_scheduler: UnCLIPScheduler + + def __init__( + self, + prior: PriorTransformer, + decoder: UNet2DConditionModel, + text_encoder: CLIPTextModelWithProjection, + tokenizer: CLIPTokenizer, + text_proj: UnCLIPTextProjModel, + super_res_first: UNet2DModel, + super_res_last: UNet2DModel, + prior_scheduler: UnCLIPScheduler, + decoder_scheduler: UnCLIPScheduler, + super_res_scheduler: UnCLIPScheduler, + ): + super().__init__() + + self.register_modules( + prior=prior, + decoder=decoder, + text_encoder=text_encoder, + tokenizer=tokenizer, + text_proj=text_proj, + super_res_first=super_res_first, + super_res_last=super_res_last, + prior_scheduler=prior_scheduler, + decoder_scheduler=decoder_scheduler, + super_res_scheduler=super_res_scheduler, + ) + + def prepare_latents(self, shape, dtype, device, generator, latents, scheduler): + if latents is None: + latents = randn_tensor(shape, generator=generator, device=device, dtype=dtype) + else: + if latents.shape != shape: + raise ValueError(f"Unexpected latents shape, got {latents.shape}, expected {shape}") + latents = latents.to(device) + + latents = latents * scheduler.init_noise_sigma + return latents + + def _encode_prompt( + self, + prompt, + device, + num_images_per_prompt, + do_classifier_free_guidance, + text_model_output: Optional[Union[CLIPTextModelOutput, Tuple]] = None, + text_attention_mask: Optional[torch.Tensor] = None, + ): + if text_model_output is None: + batch_size = len(prompt) if isinstance(prompt, list) else 1 + # get prompt text embeddings + text_inputs = self.tokenizer( + prompt, + padding="max_length", + max_length=self.tokenizer.model_max_length, + return_tensors="pt", + ) + text_input_ids = text_inputs.input_ids + text_mask = text_inputs.attention_mask.bool().to(device) + + if text_input_ids.shape[-1] > self.tokenizer.model_max_length: + removed_text = self.tokenizer.batch_decode(text_input_ids[:, self.tokenizer.model_max_length :]) + logger.warning( + "The following part of your input was truncated because CLIP can only handle sequences up to" + f" {self.tokenizer.model_max_length} tokens: {removed_text}" + ) + text_input_ids = text_input_ids[:, : self.tokenizer.model_max_length] + + text_encoder_output = self.text_encoder(text_input_ids.to(device)) + + text_embeddings = text_encoder_output.text_embeds + text_encoder_hidden_states = text_encoder_output.last_hidden_state + + else: + batch_size = text_model_output[0].shape[0] + text_embeddings, text_encoder_hidden_states = text_model_output[0], text_model_output[1] + text_mask = text_attention_mask + + text_embeddings = text_embeddings.repeat_interleave(num_images_per_prompt, dim=0) + text_encoder_hidden_states = text_encoder_hidden_states.repeat_interleave(num_images_per_prompt, dim=0) + text_mask = text_mask.repeat_interleave(num_images_per_prompt, dim=0) + + if do_classifier_free_guidance: + uncond_tokens = [""] * batch_size + + uncond_input = self.tokenizer( + uncond_tokens, + padding="max_length", + max_length=self.tokenizer.model_max_length, + truncation=True, + return_tensors="pt", + ) + uncond_text_mask = uncond_input.attention_mask.bool().to(device) + uncond_embeddings_text_encoder_output = self.text_encoder(uncond_input.input_ids.to(device)) + + uncond_embeddings = uncond_embeddings_text_encoder_output.text_embeds + uncond_text_encoder_hidden_states = uncond_embeddings_text_encoder_output.last_hidden_state + + # duplicate unconditional embeddings for each generation per prompt, using mps friendly method + + seq_len = uncond_embeddings.shape[1] + uncond_embeddings = uncond_embeddings.repeat(1, num_images_per_prompt) + uncond_embeddings = uncond_embeddings.view(batch_size * num_images_per_prompt, seq_len) + + seq_len = uncond_text_encoder_hidden_states.shape[1] + uncond_text_encoder_hidden_states = uncond_text_encoder_hidden_states.repeat(1, num_images_per_prompt, 1) + uncond_text_encoder_hidden_states = uncond_text_encoder_hidden_states.view( + batch_size * num_images_per_prompt, seq_len, -1 + ) + uncond_text_mask = uncond_text_mask.repeat_interleave(num_images_per_prompt, dim=0) + + # done duplicates + + # For classifier free guidance, we need to do two forward passes. + # Here we concatenate the unconditional and text embeddings into a single batch + # to avoid doing two forward passes + text_embeddings = torch.cat([uncond_embeddings, text_embeddings]) + text_encoder_hidden_states = torch.cat([uncond_text_encoder_hidden_states, text_encoder_hidden_states]) + + text_mask = torch.cat([uncond_text_mask, text_mask]) + + return text_embeddings, text_encoder_hidden_states, text_mask + + def enable_sequential_cpu_offload(self, gpu_id=0): + r""" + Offloads all models to CPU using accelerate, significantly reducing memory usage. When called, the pipeline's + models have their state dicts saved to CPU and then are moved to a `torch.device('meta') and loaded to GPU only + when their specific submodule has its `forward` method called. + """ + if is_accelerate_available(): + from accelerate import cpu_offload + else: + raise ImportError("Please install accelerate via `pip install accelerate`") + + device = torch.device(f"cuda:{gpu_id}") + + # TODO: self.prior.post_process_latents is not covered by the offload hooks, so it fails if added to the list + models = [ + self.decoder, + self.text_proj, + self.text_encoder, + self.super_res_first, + self.super_res_last, + ] + for cpu_offloaded_model in models: + if cpu_offloaded_model is not None: + cpu_offload(cpu_offloaded_model, device) + + @property + def _execution_device(self): + r""" + Returns the device on which the pipeline's models will be executed. After calling + `pipeline.enable_sequential_cpu_offload()` the execution device can only be inferred from Accelerate's module + hooks. + """ + if self.device != torch.device("meta") or not hasattr(self.decoder, "_hf_hook"): + return self.device + for module in self.decoder.modules(): + if ( + hasattr(module, "_hf_hook") + and hasattr(module._hf_hook, "execution_device") + and module._hf_hook.execution_device is not None + ): + return torch.device(module._hf_hook.execution_device) + return self.device + + @torch.no_grad() + def __call__( + self, + prompt: Optional[Union[str, List[str]]] = None, + num_images_per_prompt: int = 1, + prior_num_inference_steps: int = 25, + decoder_num_inference_steps: int = 25, + super_res_num_inference_steps: int = 7, + generator: Optional[torch.Generator] = None, + prior_latents: Optional[torch.FloatTensor] = None, + decoder_latents: Optional[torch.FloatTensor] = None, + super_res_latents: Optional[torch.FloatTensor] = None, + text_model_output: Optional[Union[CLIPTextModelOutput, Tuple]] = None, + text_attention_mask: Optional[torch.Tensor] = None, + prior_guidance_scale: float = 4.0, + decoder_guidance_scale: float = 8.0, + output_type: Optional[str] = "pil", + return_dict: bool = True, + ): + """ + Function invoked when calling the pipeline for generation. + Args: + prompt (`str` or `List[str]`): + The prompt or prompts to guide the image generation. This can only be left undefined if + `text_model_output` and `text_attention_mask` is passed. + num_images_per_prompt (`int`, *optional*, defaults to 1): + The number of images to generate per prompt. + prior_num_inference_steps (`int`, *optional*, defaults to 25): + The number of denoising steps for the prior. More denoising steps usually lead to a higher quality + image at the expense of slower inference. + decoder_num_inference_steps (`int`, *optional*, defaults to 25): + The number of denoising steps for the decoder. More denoising steps usually lead to a higher quality + image at the expense of slower inference. + super_res_num_inference_steps (`int`, *optional*, defaults to 7): + The number of denoising steps for super resolution. More denoising steps usually lead to a higher + quality image at the expense of slower inference. + generator (`torch.Generator`, *optional*): + One or a list of [torch generator(s)](https://pytorch.org/docs/stable/generated/torch.Generator.html) + to make generation deterministic. + prior_latents (`torch.FloatTensor` of shape (batch size, embeddings dimension), *optional*): + Pre-generated noisy latents to be used as inputs for the prior. + decoder_latents (`torch.FloatTensor` of shape (batch size, channels, height, width), *optional*): + Pre-generated noisy latents to be used as inputs for the decoder. + super_res_latents (`torch.FloatTensor` of shape (batch size, channels, super res height, super res width), *optional*): + Pre-generated noisy latents to be used as inputs for the decoder. + prior_guidance_scale (`float`, *optional*, defaults to 4.0): + Guidance scale as defined in [Classifier-Free Diffusion Guidance](https://arxiv.org/abs/2207.12598). + `guidance_scale` is defined as `w` of equation 2. of [Imagen + Paper](https://arxiv.org/pdf/2205.11487.pdf). Guidance scale is enabled by setting `guidance_scale > + 1`. Higher guidance scale encourages to generate images that are closely linked to the text `prompt`, + usually at the expense of lower image quality. + decoder_guidance_scale (`float`, *optional*, defaults to 4.0): + Guidance scale as defined in [Classifier-Free Diffusion Guidance](https://arxiv.org/abs/2207.12598). + `guidance_scale` is defined as `w` of equation 2. of [Imagen + Paper](https://arxiv.org/pdf/2205.11487.pdf). Guidance scale is enabled by setting `guidance_scale > + 1`. Higher guidance scale encourages to generate images that are closely linked to the text `prompt`, + usually at the expense of lower image quality. + text_model_output (`CLIPTextModelOutput`, *optional*): + Pre-defined CLIPTextModel outputs that can be derived from the text encoder. Pre-defined text outputs + can be passed for tasks like text embedding interpolations. Make sure to also pass + `text_attention_mask` in this case. `prompt` can the be left to `None`. + text_attention_mask (`torch.Tensor`, *optional*): + Pre-defined CLIP text attention mask that can be derived from the tokenizer. Pre-defined text attention + masks are necessary when passing `text_model_output`. + output_type (`str`, *optional*, defaults to `"pil"`): + The output format of the generated image. Choose between + [PIL](https://pillow.readthedocs.io/en/stable/): `PIL.Image.Image` or `np.array`. + return_dict (`bool`, *optional*, defaults to `True`): + Whether or not to return a [`~pipelines.ImagePipelineOutput`] instead of a plain tuple. + """ + if prompt is not None: + if isinstance(prompt, str): + batch_size = 1 + elif isinstance(prompt, list): + batch_size = len(prompt) + else: + raise ValueError(f"`prompt` has to be of type `str` or `list` but is {type(prompt)}") + else: + batch_size = text_model_output[0].shape[0] + + device = self._execution_device + + batch_size = batch_size * num_images_per_prompt + + do_classifier_free_guidance = prior_guidance_scale > 1.0 or decoder_guidance_scale > 1.0 + + text_embeddings, text_encoder_hidden_states, text_mask = self._encode_prompt( + prompt, device, num_images_per_prompt, do_classifier_free_guidance, text_model_output, text_attention_mask + ) + + # prior + + self.prior_scheduler.set_timesteps(prior_num_inference_steps, device=device) + prior_timesteps_tensor = self.prior_scheduler.timesteps + + embedding_dim = self.prior.config.embedding_dim + + prior_latents = self.prepare_latents( + (batch_size, embedding_dim), + text_embeddings.dtype, + device, + generator, + prior_latents, + self.prior_scheduler, + ) + + for i, t in enumerate(self.progress_bar(prior_timesteps_tensor)): + # expand the latents if we are doing classifier free guidance + latent_model_input = torch.cat([prior_latents] * 2) if do_classifier_free_guidance else prior_latents + + predicted_image_embedding = self.prior( + latent_model_input, + timestep=t, + proj_embedding=text_embeddings, + encoder_hidden_states=text_encoder_hidden_states, + attention_mask=text_mask, + ).predicted_image_embedding + + if do_classifier_free_guidance: + predicted_image_embedding_uncond, predicted_image_embedding_text = predicted_image_embedding.chunk(2) + predicted_image_embedding = predicted_image_embedding_uncond + prior_guidance_scale * ( + predicted_image_embedding_text - predicted_image_embedding_uncond + ) + + if i + 1 == prior_timesteps_tensor.shape[0]: + prev_timestep = None + else: + prev_timestep = prior_timesteps_tensor[i + 1] + + prior_latents = self.prior_scheduler.step( + predicted_image_embedding, + timestep=t, + sample=prior_latents, + generator=generator, + prev_timestep=prev_timestep, + ).prev_sample + + prior_latents = self.prior.post_process_latents(prior_latents) + + image_embeddings = prior_latents + + # done prior + + # decoder + + text_encoder_hidden_states, additive_clip_time_embeddings = self.text_proj( + image_embeddings=image_embeddings, + text_embeddings=text_embeddings, + text_encoder_hidden_states=text_encoder_hidden_states, + do_classifier_free_guidance=do_classifier_free_guidance, + ) + + decoder_text_mask = F.pad(text_mask, (self.text_proj.clip_extra_context_tokens, 0), value=1) + + self.decoder_scheduler.set_timesteps(decoder_num_inference_steps, device=device) + decoder_timesteps_tensor = self.decoder_scheduler.timesteps + + num_channels_latents = self.decoder.in_channels + height = self.decoder.sample_size + width = self.decoder.sample_size + + decoder_latents = self.prepare_latents( + (batch_size, num_channels_latents, height, width), + text_encoder_hidden_states.dtype, + device, + generator, + decoder_latents, + self.decoder_scheduler, + ) + + for i, t in enumerate(self.progress_bar(decoder_timesteps_tensor)): + # expand the latents if we are doing classifier free guidance + latent_model_input = torch.cat([decoder_latents] * 2) if do_classifier_free_guidance else decoder_latents + + noise_pred = self.decoder( + sample=latent_model_input, + timestep=t, + encoder_hidden_states=text_encoder_hidden_states, + class_labels=additive_clip_time_embeddings, + attention_mask=decoder_text_mask, + ).sample + + if do_classifier_free_guidance: + noise_pred_uncond, noise_pred_text = noise_pred.chunk(2) + noise_pred_uncond, _ = noise_pred_uncond.split(latent_model_input.shape[1], dim=1) + noise_pred_text, predicted_variance = noise_pred_text.split(latent_model_input.shape[1], dim=1) + noise_pred = noise_pred_uncond + decoder_guidance_scale * (noise_pred_text - noise_pred_uncond) + noise_pred = torch.cat([noise_pred, predicted_variance], dim=1) + + if i + 1 == decoder_timesteps_tensor.shape[0]: + prev_timestep = None + else: + prev_timestep = decoder_timesteps_tensor[i + 1] + + # compute the previous noisy sample x_t -> x_t-1 + decoder_latents = self.decoder_scheduler.step( + noise_pred, t, decoder_latents, prev_timestep=prev_timestep, generator=generator + ).prev_sample + + decoder_latents = decoder_latents.clamp(-1, 1) + + image_small = decoder_latents + + # done decoder + + # super res + + self.super_res_scheduler.set_timesteps(super_res_num_inference_steps, device=device) + super_res_timesteps_tensor = self.super_res_scheduler.timesteps + + channels = self.super_res_first.in_channels // 2 + height = self.super_res_first.sample_size + width = self.super_res_first.sample_size + + super_res_latents = self.prepare_latents( + (batch_size, channels, height, width), + image_small.dtype, + device, + generator, + super_res_latents, + self.super_res_scheduler, + ) + + interpolate_antialias = {} + if "antialias" in inspect.signature(F.interpolate).parameters: + interpolate_antialias["antialias"] = True + + image_upscaled = F.interpolate( + image_small, size=[height, width], mode="bicubic", align_corners=False, **interpolate_antialias + ) + + for i, t in enumerate(self.progress_bar(super_res_timesteps_tensor)): + # no classifier free guidance + + if i == super_res_timesteps_tensor.shape[0] - 1: + unet = self.super_res_last + else: + unet = self.super_res_first + + latent_model_input = torch.cat([super_res_latents, image_upscaled], dim=1) + + noise_pred = unet( + sample=latent_model_input, + timestep=t, + ).sample + + if i + 1 == super_res_timesteps_tensor.shape[0]: + prev_timestep = None + else: + prev_timestep = super_res_timesteps_tensor[i + 1] + + # compute the previous noisy sample x_t -> x_t-1 + super_res_latents = self.super_res_scheduler.step( + noise_pred, t, super_res_latents, prev_timestep=prev_timestep, generator=generator + ).prev_sample + + image = super_res_latents + # done super res + + # post processing + + image = image * 0.5 + 0.5 + image = image.clamp(0, 1) + image = image.cpu().permute(0, 2, 3, 1).float().numpy() + + if output_type == "pil": + image = self.numpy_to_pil(image) + + if not return_dict: + return (image,) + + return ImagePipelineOutput(images=image) \ No newline at end of file diff --git a/ldm/modules/karlo/kakao/__init__.py b/ldm/modules/karlo/kakao/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/ldm/modules/karlo/kakao/models/__init__.py b/ldm/modules/karlo/kakao/models/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/ldm/modules/karlo/kakao/models/clip.py b/ldm/modules/karlo/kakao/models/clip.py new file mode 100644 index 0000000000000000000000000000000000000000..961d81502a069ae29b6752478f048c979b27fb9b --- /dev/null +++ b/ldm/modules/karlo/kakao/models/clip.py @@ -0,0 +1,182 @@ +# ------------------------------------------------------------------------------------ +# Karlo-v1.0.alpha +# Copyright (c) 2022 KakaoBrain. All Rights Reserved. +# ------------------------------------------------------------------------------------ +# ------------------------------------------------------------------------------------ +# Adapted from OpenAI's CLIP (https://github.com/openai/CLIP/) +# ------------------------------------------------------------------------------------ + + +import torch +import torch.nn as nn +import torch.nn.functional as F +import clip + +from clip.model import CLIP, convert_weights +from clip.simple_tokenizer import SimpleTokenizer, default_bpe + + +"""===== Monkey-Patching original CLIP for JIT compile =====""" + + +class LayerNorm(nn.LayerNorm): + """Subclass torch's LayerNorm to handle fp16.""" + + def forward(self, x: torch.Tensor): + orig_type = x.dtype + ret = F.layer_norm( + x.type(torch.float32), + self.normalized_shape, + self.weight, + self.bias, + self.eps, + ) + return ret.type(orig_type) + + +clip.model.LayerNorm = LayerNorm +delattr(clip.model.CLIP, "forward") + +"""===== End of Monkey-Patching =====""" + + +class CustomizedCLIP(CLIP): + def __init__(self, *args, **kwargs): + super().__init__(*args, **kwargs) + + @torch.jit.export + def encode_image(self, image): + return self.visual(image) + + @torch.jit.export + def encode_text(self, text): + # re-define this function to return unpooled text features + + x = self.token_embedding(text).type(self.dtype) # [batch_size, n_ctx, d_model] + + x = x + self.positional_embedding.type(self.dtype) + x = x.permute(1, 0, 2) # NLD -> LND + x = self.transformer(x) + x = x.permute(1, 0, 2) # LND -> NLD + x = self.ln_final(x).type(self.dtype) + + x_seq = x + # x.shape = [batch_size, n_ctx, transformer.width] + # take features from the eot embedding (eot_token is the highest number in each sequence) + x_out = x[torch.arange(x.shape[0]), text.argmax(dim=-1)] @ self.text_projection + + return x_out, x_seq + + @torch.jit.ignore + def forward(self, image, text): + super().forward(image, text) + + @classmethod + def load_from_checkpoint(cls, ckpt_path: str): + state_dict = torch.load(ckpt_path, map_location="cpu").state_dict() + + vit = "visual.proj" in state_dict + if vit: + vision_width = state_dict["visual.conv1.weight"].shape[0] + vision_layers = len( + [ + k + for k in state_dict.keys() + if k.startswith("visual.") and k.endswith(".attn.in_proj_weight") + ] + ) + vision_patch_size = state_dict["visual.conv1.weight"].shape[-1] + grid_size = round( + (state_dict["visual.positional_embedding"].shape[0] - 1) ** 0.5 + ) + image_resolution = vision_patch_size * grid_size + else: + counts: list = [ + len( + set( + k.split(".")[2] + for k in state_dict + if k.startswith(f"visual.layer{b}") + ) + ) + for b in [1, 2, 3, 4] + ] + vision_layers = tuple(counts) + vision_width = state_dict["visual.layer1.0.conv1.weight"].shape[0] + output_width = round( + (state_dict["visual.attnpool.positional_embedding"].shape[0] - 1) ** 0.5 + ) + vision_patch_size = None + assert ( + output_width**2 + 1 + == state_dict["visual.attnpool.positional_embedding"].shape[0] + ) + image_resolution = output_width * 32 + + embed_dim = state_dict["text_projection"].shape[1] + context_length = state_dict["positional_embedding"].shape[0] + vocab_size = state_dict["token_embedding.weight"].shape[0] + transformer_width = state_dict["ln_final.weight"].shape[0] + transformer_heads = transformer_width // 64 + transformer_layers = len( + set( + k.split(".")[2] + for k in state_dict + if k.startswith("transformer.resblocks") + ) + ) + + model = cls( + embed_dim, + image_resolution, + vision_layers, + vision_width, + vision_patch_size, + context_length, + vocab_size, + transformer_width, + transformer_heads, + transformer_layers, + ) + + for key in ["input_resolution", "context_length", "vocab_size"]: + if key in state_dict: + del state_dict[key] + + convert_weights(model) + model.load_state_dict(state_dict) + model.eval() + model.float() + return model + + +class CustomizedTokenizer(SimpleTokenizer): + def __init__(self): + super().__init__(bpe_path=default_bpe()) + + self.sot_token = self.encoder["<|startoftext|>"] + self.eot_token = self.encoder["<|endoftext|>"] + + def padded_tokens_and_mask(self, texts, text_ctx): + assert isinstance(texts, list) and all( + isinstance(elem, str) for elem in texts + ), "texts should be a list of strings" + + all_tokens = [ + [self.sot_token] + self.encode(text) + [self.eot_token] for text in texts + ] + + mask = [ + [True] * min(text_ctx, len(tokens)) + + [False] * max(text_ctx - len(tokens), 0) + for tokens in all_tokens + ] + mask = torch.tensor(mask, dtype=torch.bool) + result = torch.zeros(len(all_tokens), text_ctx, dtype=torch.int) + for i, tokens in enumerate(all_tokens): + if len(tokens) > text_ctx: + tokens = tokens[:text_ctx] + tokens[-1] = self.eot_token + result[i, : len(tokens)] = torch.tensor(tokens) + + return result, mask diff --git a/ldm/modules/karlo/kakao/models/decoder_model.py b/ldm/modules/karlo/kakao/models/decoder_model.py new file mode 100644 index 0000000000000000000000000000000000000000..84e96c9b2f3f54561a5d950097d5d069ce4ce3a0 --- /dev/null +++ b/ldm/modules/karlo/kakao/models/decoder_model.py @@ -0,0 +1,193 @@ +# ------------------------------------------------------------------------------------ +# Karlo-v1.0.alpha +# Copyright (c) 2022 KakaoBrain. All Rights Reserved. +# ------------------------------------------------------------------------------------ + +import copy +import torch + +from ldm.modules.karlo.kakao.modules import create_gaussian_diffusion +from ldm.modules.karlo.kakao.modules.unet import PLMImUNet + + +class Text2ImProgressiveModel(torch.nn.Module): + """ + A decoder that generates 64x64px images based on the text prompt. + + :param config: yaml config to define the decoder. + :param tokenizer: tokenizer used in clip. + """ + + def __init__( + self, + config, + tokenizer, + ): + super().__init__() + + self._conf = config + self._model_conf = config.model.hparams + self._diffusion_kwargs = dict( + steps=config.diffusion.steps, + learn_sigma=config.diffusion.learn_sigma, + sigma_small=config.diffusion.sigma_small, + noise_schedule=config.diffusion.noise_schedule, + use_kl=config.diffusion.use_kl, + predict_xstart=config.diffusion.predict_xstart, + rescale_learned_sigmas=config.diffusion.rescale_learned_sigmas, + timestep_respacing=config.diffusion.timestep_respacing, + ) + self._tokenizer = tokenizer + + self.model = self.create_plm_dec_model() + + cf_token, cf_mask = self.set_cf_text_tensor() + self.register_buffer("cf_token", cf_token, persistent=False) + self.register_buffer("cf_mask", cf_mask, persistent=False) + + @classmethod + def load_from_checkpoint(cls, config, tokenizer, ckpt_path, strict: bool = True): + ckpt = torch.load(ckpt_path, map_location="cpu")["state_dict"] + + model = cls(config, tokenizer) + model.load_state_dict(ckpt, strict=strict) + return model + + def create_plm_dec_model(self): + image_size = self._model_conf.image_size + if self._model_conf.channel_mult == "": + if image_size == 256: + channel_mult = (1, 1, 2, 2, 4, 4) + elif image_size == 128: + channel_mult = (1, 1, 2, 3, 4) + elif image_size == 64: + channel_mult = (1, 2, 3, 4) + else: + raise ValueError(f"unsupported image size: {image_size}") + else: + channel_mult = tuple( + int(ch_mult) for ch_mult in self._model_conf.channel_mult.split(",") + ) + assert 2 ** (len(channel_mult) + 2) == image_size + + attention_ds = [] + for res in self._model_conf.attention_resolutions.split(","): + attention_ds.append(image_size // int(res)) + + return PLMImUNet( + text_ctx=self._model_conf.text_ctx, + xf_width=self._model_conf.xf_width, + in_channels=3, + model_channels=self._model_conf.num_channels, + out_channels=6 if self._model_conf.learn_sigma else 3, + num_res_blocks=self._model_conf.num_res_blocks, + attention_resolutions=tuple(attention_ds), + dropout=self._model_conf.dropout, + channel_mult=channel_mult, + num_heads=self._model_conf.num_heads, + num_head_channels=self._model_conf.num_head_channels, + num_heads_upsample=self._model_conf.num_heads_upsample, + use_scale_shift_norm=self._model_conf.use_scale_shift_norm, + resblock_updown=self._model_conf.resblock_updown, + clip_dim=self._model_conf.clip_dim, + clip_emb_mult=self._model_conf.clip_emb_mult, + clip_emb_type=self._model_conf.clip_emb_type, + clip_emb_drop=self._model_conf.clip_emb_drop, + ) + + def set_cf_text_tensor(self): + return self._tokenizer.padded_tokens_and_mask([""], self.model.text_ctx) + + def get_sample_fn(self, timestep_respacing): + use_ddim = timestep_respacing.startswith(("ddim", "fast")) + + diffusion_kwargs = copy.deepcopy(self._diffusion_kwargs) + diffusion_kwargs.update(timestep_respacing=timestep_respacing) + diffusion = create_gaussian_diffusion(**diffusion_kwargs) + sample_fn = ( + diffusion.ddim_sample_loop_progressive + if use_ddim + else diffusion.p_sample_loop_progressive + ) + + return sample_fn + + def forward( + self, + txt_feat, + txt_feat_seq, + tok, + mask, + img_feat=None, + cf_guidance_scales=None, + timestep_respacing=None, + ): + # cfg should be enabled in inference + assert cf_guidance_scales is not None and all(cf_guidance_scales > 0.0) + assert img_feat is not None + + bsz = txt_feat.shape[0] + img_sz = self._model_conf.image_size + + def guided_model_fn(x_t, ts, **kwargs): + half = x_t[: len(x_t) // 2] + combined = torch.cat([half, half], dim=0) + model_out = self.model(combined, ts, **kwargs) + eps, rest = model_out[:, :3], model_out[:, 3:] + cond_eps, uncond_eps = torch.split(eps, len(eps) // 2, dim=0) + half_eps = uncond_eps + cf_guidance_scales.view(-1, 1, 1, 1) * ( + cond_eps - uncond_eps + ) + eps = torch.cat([half_eps, half_eps], dim=0) + return torch.cat([eps, rest], dim=1) + + cf_feat = self.model.cf_param.unsqueeze(0) + cf_feat = cf_feat.expand(bsz // 2, -1) + feat = torch.cat([img_feat, cf_feat.to(txt_feat.device)], dim=0) + + cond = { + "y": feat, + "txt_feat": txt_feat, + "txt_feat_seq": txt_feat_seq, + "mask": mask, + } + sample_fn = self.get_sample_fn(timestep_respacing) + sample_outputs = sample_fn( + guided_model_fn, + (bsz, 3, img_sz, img_sz), + noise=None, + device=txt_feat.device, + clip_denoised=True, + model_kwargs=cond, + ) + + for out in sample_outputs: + sample = out["sample"] + yield sample if cf_guidance_scales is None else sample[ + : sample.shape[0] // 2 + ] + + +class Text2ImModel(Text2ImProgressiveModel): + def forward( + self, + txt_feat, + txt_feat_seq, + tok, + mask, + img_feat=None, + cf_guidance_scales=None, + timestep_respacing=None, + ): + last_out = None + for out in super().forward( + txt_feat, + txt_feat_seq, + tok, + mask, + img_feat, + cf_guidance_scales, + timestep_respacing, + ): + last_out = out + return last_out diff --git a/ldm/modules/karlo/kakao/models/prior_model.py b/ldm/modules/karlo/kakao/models/prior_model.py new file mode 100644 index 0000000000000000000000000000000000000000..03ef230d2ac5e7f785c138f710337980e6754022 --- /dev/null +++ b/ldm/modules/karlo/kakao/models/prior_model.py @@ -0,0 +1,138 @@ +# ------------------------------------------------------------------------------------ +# Karlo-v1.0.alpha +# Copyright (c) 2022 KakaoBrain. All Rights Reserved. +# ------------------------------------------------------------------------------------ + +import copy +import torch + +from ldm.modules.karlo.kakao.modules import create_gaussian_diffusion +from ldm.modules.karlo.kakao.modules.xf import PriorTransformer + + +class PriorDiffusionModel(torch.nn.Module): + """ + A prior that generates clip image feature based on the text prompt. + + :param config: yaml config to define the decoder. + :param tokenizer: tokenizer used in clip. + :param clip_mean: mean to normalize the clip image feature (zero-mean, unit variance). + :param clip_std: std to noramlize the clip image feature (zero-mean, unit variance). + """ + + def __init__(self, config, tokenizer, clip_mean, clip_std): + super().__init__() + + self._conf = config + self._model_conf = config.model.hparams + self._diffusion_kwargs = dict( + steps=config.diffusion.steps, + learn_sigma=config.diffusion.learn_sigma, + sigma_small=config.diffusion.sigma_small, + noise_schedule=config.diffusion.noise_schedule, + use_kl=config.diffusion.use_kl, + predict_xstart=config.diffusion.predict_xstart, + rescale_learned_sigmas=config.diffusion.rescale_learned_sigmas, + timestep_respacing=config.diffusion.timestep_respacing, + ) + self._tokenizer = tokenizer + + self.register_buffer("clip_mean", clip_mean[None, :], persistent=False) + self.register_buffer("clip_std", clip_std[None, :], persistent=False) + + causal_mask = self.get_causal_mask() + self.register_buffer("causal_mask", causal_mask, persistent=False) + + self.model = PriorTransformer( + text_ctx=self._model_conf.text_ctx, + xf_width=self._model_conf.xf_width, + xf_layers=self._model_conf.xf_layers, + xf_heads=self._model_conf.xf_heads, + xf_final_ln=self._model_conf.xf_final_ln, + clip_dim=self._model_conf.clip_dim, + ) + + cf_token, cf_mask = self.set_cf_text_tensor() + self.register_buffer("cf_token", cf_token, persistent=False) + self.register_buffer("cf_mask", cf_mask, persistent=False) + + @classmethod + def load_from_checkpoint( + cls, config, tokenizer, clip_mean, clip_std, ckpt_path, strict: bool = True + ): + ckpt = torch.load(ckpt_path, map_location="cpu")["state_dict"] + + model = cls(config, tokenizer, clip_mean, clip_std) + model.load_state_dict(ckpt, strict=strict) + return model + + def set_cf_text_tensor(self): + return self._tokenizer.padded_tokens_and_mask([""], self.model.text_ctx) + + def get_sample_fn(self, timestep_respacing): + use_ddim = timestep_respacing.startswith(("ddim", "fast")) + + diffusion_kwargs = copy.deepcopy(self._diffusion_kwargs) + diffusion_kwargs.update(timestep_respacing=timestep_respacing) + diffusion = create_gaussian_diffusion(**diffusion_kwargs) + sample_fn = diffusion.ddim_sample_loop if use_ddim else diffusion.p_sample_loop + + return sample_fn + + def get_causal_mask(self): + seq_len = self._model_conf.text_ctx + 4 + mask = torch.empty(seq_len, seq_len) + mask.fill_(float("-inf")) + mask.triu_(1) + mask = mask[None, ...] + return mask + + def forward( + self, + txt_feat, + txt_feat_seq, + mask, + cf_guidance_scales=None, + timestep_respacing=None, + denoised_fn=True, + ): + # cfg should be enabled in inference + assert cf_guidance_scales is not None and all(cf_guidance_scales > 0.0) + + bsz_ = txt_feat.shape[0] + bsz = bsz_ // 2 + + def guided_model_fn(x_t, ts, **kwargs): + half = x_t[: len(x_t) // 2] + combined = torch.cat([half, half], dim=0) + model_out = self.model(combined, ts, **kwargs) + eps, rest = ( + model_out[:, : int(x_t.shape[1])], + model_out[:, int(x_t.shape[1]) :], + ) + cond_eps, uncond_eps = torch.split(eps, len(eps) // 2, dim=0) + half_eps = uncond_eps + cf_guidance_scales.view(-1, 1) * ( + cond_eps - uncond_eps + ) + eps = torch.cat([half_eps, half_eps], dim=0) + return torch.cat([eps, rest], dim=1) + + cond = { + "text_emb": txt_feat, + "text_enc": txt_feat_seq, + "mask": mask, + "causal_mask": self.causal_mask, + } + sample_fn = self.get_sample_fn(timestep_respacing) + sample = sample_fn( + guided_model_fn, + (bsz_, self.model.clip_dim), + noise=None, + device=txt_feat.device, + clip_denoised=False, + denoised_fn=lambda x: torch.clamp(x, -10, 10), + model_kwargs=cond, + ) + sample = (sample * self.clip_std) + self.clip_mean + + return sample[:bsz] diff --git a/ldm/modules/karlo/kakao/models/sr_256_1k.py b/ldm/modules/karlo/kakao/models/sr_256_1k.py new file mode 100644 index 0000000000000000000000000000000000000000..1e874f6f1b8286d85456ae335316880cb5c15336 --- /dev/null +++ b/ldm/modules/karlo/kakao/models/sr_256_1k.py @@ -0,0 +1,10 @@ +# ------------------------------------------------------------------------------------ +# Karlo-v1.0.alpha +# Copyright (c) 2022 KakaoBrain. All Rights Reserved. +# ------------------------------------------------------------------------------------ + +from ldm.modules.karlo.kakao.models.sr_64_256 import SupRes64to256Progressive + + +class SupRes256to1kProgressive(SupRes64to256Progressive): + pass # no difference currently diff --git a/ldm/modules/karlo/kakao/models/sr_64_256.py b/ldm/modules/karlo/kakao/models/sr_64_256.py new file mode 100644 index 0000000000000000000000000000000000000000..32687afe38134c4eed06083fc9c345b1dbe958a9 --- /dev/null +++ b/ldm/modules/karlo/kakao/models/sr_64_256.py @@ -0,0 +1,88 @@ +# ------------------------------------------------------------------------------------ +# Karlo-v1.0.alpha +# Copyright (c) 2022 KakaoBrain. All Rights Reserved. +# ------------------------------------------------------------------------------------ + +import copy +import torch + +from ldm.modules.karlo.kakao.modules.unet import SuperResUNetModel +from ldm.modules.karlo.kakao.modules import create_gaussian_diffusion + + +class ImprovedSupRes64to256ProgressiveModel(torch.nn.Module): + """ + ImprovedSR model fine-tunes the pretrained DDPM-based SR model by using adversarial and perceptual losses. + In specific, the low-resolution sample is iteratively recovered by 6 steps with the frozen pretrained SR model. + In the following additional one step, a seperate fine-tuned model recovers high-frequency details. + This approach greatly improves the fidelity of images of 256x256px, even with small number of reverse steps. + """ + + def __init__(self, config): + super().__init__() + + self._config = config + self._diffusion_kwargs = dict( + steps=config.diffusion.steps, + learn_sigma=config.diffusion.learn_sigma, + sigma_small=config.diffusion.sigma_small, + noise_schedule=config.diffusion.noise_schedule, + use_kl=config.diffusion.use_kl, + predict_xstart=config.diffusion.predict_xstart, + rescale_learned_sigmas=config.diffusion.rescale_learned_sigmas, + ) + + self.model_first_steps = SuperResUNetModel( + in_channels=3, # auto-changed to 6 inside the model + model_channels=config.model.hparams.channels, + out_channels=3, + num_res_blocks=config.model.hparams.depth, + attention_resolutions=(), # no attention + dropout=config.model.hparams.dropout, + channel_mult=config.model.hparams.channels_multiple, + resblock_updown=True, + use_middle_attention=False, + ) + self.model_last_step = SuperResUNetModel( + in_channels=3, # auto-changed to 6 inside the model + model_channels=config.model.hparams.channels, + out_channels=3, + num_res_blocks=config.model.hparams.depth, + attention_resolutions=(), # no attention + dropout=config.model.hparams.dropout, + channel_mult=config.model.hparams.channels_multiple, + resblock_updown=True, + use_middle_attention=False, + ) + + @classmethod + def load_from_checkpoint(cls, config, ckpt_path, strict: bool = True): + ckpt = torch.load(ckpt_path, map_location="cpu")["state_dict"] + + model = cls(config) + model.load_state_dict(ckpt, strict=strict) + return model + + def get_sample_fn(self, timestep_respacing): + diffusion_kwargs = copy.deepcopy(self._diffusion_kwargs) + diffusion_kwargs.update(timestep_respacing=timestep_respacing) + diffusion = create_gaussian_diffusion(**diffusion_kwargs) + return diffusion.p_sample_loop_progressive_for_improved_sr + + def forward(self, low_res, timestep_respacing="7", **kwargs): + assert ( + timestep_respacing == "7" + ), "different respacing method may work, but no guaranteed" + + sample_fn = self.get_sample_fn(timestep_respacing) + sample_outputs = sample_fn( + self.model_first_steps, + self.model_last_step, + shape=low_res.shape, + clip_denoised=True, + model_kwargs=dict(low_res=low_res), + **kwargs, + ) + for x in sample_outputs: + sample = x["sample"] + yield sample diff --git a/ldm/modules/karlo/kakao/modules/__init__.py b/ldm/modules/karlo/kakao/modules/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..11d4358a6475243b8b789efb7595566993ccd9e1 --- /dev/null +++ b/ldm/modules/karlo/kakao/modules/__init__.py @@ -0,0 +1,49 @@ +# ------------------------------------------------------------------------------------ +# Adapted from Guided-Diffusion repo (https://github.com/openai/guided-diffusion) +# ------------------------------------------------------------------------------------ + + +from .diffusion import gaussian_diffusion as gd +from .diffusion.respace import ( + SpacedDiffusion, + space_timesteps, +) + + +def create_gaussian_diffusion( + steps, + learn_sigma, + sigma_small, + noise_schedule, + use_kl, + predict_xstart, + rescale_learned_sigmas, + timestep_respacing, +): + betas = gd.get_named_beta_schedule(noise_schedule, steps) + if use_kl: + loss_type = gd.LossType.RESCALED_KL + elif rescale_learned_sigmas: + loss_type = gd.LossType.RESCALED_MSE + else: + loss_type = gd.LossType.MSE + if not timestep_respacing: + timestep_respacing = [steps] + + return SpacedDiffusion( + use_timesteps=space_timesteps(steps, timestep_respacing), + betas=betas, + model_mean_type=( + gd.ModelMeanType.EPSILON if not predict_xstart else gd.ModelMeanType.START_X + ), + model_var_type=( + ( + gd.ModelVarType.FIXED_LARGE + if not sigma_small + else gd.ModelVarType.FIXED_SMALL + ) + if not learn_sigma + else gd.ModelVarType.LEARNED_RANGE + ), + loss_type=loss_type, + ) diff --git a/ldm/modules/karlo/kakao/modules/diffusion/gaussian_diffusion.py b/ldm/modules/karlo/kakao/modules/diffusion/gaussian_diffusion.py new file mode 100644 index 0000000000000000000000000000000000000000..6a111aa09ea84157735cc2a4a66a68c4faaf42f4 --- /dev/null +++ b/ldm/modules/karlo/kakao/modules/diffusion/gaussian_diffusion.py @@ -0,0 +1,828 @@ +# ------------------------------------------------------------------------------------ +# Adapted from Guided-Diffusion repo (https://github.com/openai/guided-diffusion) +# ------------------------------------------------------------------------------------ + +import enum +import math + +import numpy as np +import torch as th + + +def _warmup_beta(beta_start, beta_end, num_diffusion_timesteps, warmup_frac): + betas = beta_end * np.ones(num_diffusion_timesteps, dtype=np.float64) + warmup_time = int(num_diffusion_timesteps * warmup_frac) + betas[:warmup_time] = np.linspace( + beta_start, beta_end, warmup_time, dtype=np.float64 + ) + return betas + + +def get_beta_schedule(beta_schedule, *, beta_start, beta_end, num_diffusion_timesteps): + """ + This is the deprecated API for creating beta schedules. + See get_named_beta_schedule() for the new library of schedules. + """ + if beta_schedule == "quad": + betas = ( + np.linspace( + beta_start**0.5, + beta_end**0.5, + num_diffusion_timesteps, + dtype=np.float64, + ) + ** 2 + ) + elif beta_schedule == "linear": + betas = np.linspace( + beta_start, beta_end, num_diffusion_timesteps, dtype=np.float64 + ) + elif beta_schedule == "warmup10": + betas = _warmup_beta(beta_start, beta_end, num_diffusion_timesteps, 0.1) + elif beta_schedule == "warmup50": + betas = _warmup_beta(beta_start, beta_end, num_diffusion_timesteps, 0.5) + elif beta_schedule == "const": + betas = beta_end * np.ones(num_diffusion_timesteps, dtype=np.float64) + elif beta_schedule == "jsd": # 1/T, 1/(T-1), 1/(T-2), ..., 1 + betas = 1.0 / np.linspace( + num_diffusion_timesteps, 1, num_diffusion_timesteps, dtype=np.float64 + ) + else: + raise NotImplementedError(beta_schedule) + assert betas.shape == (num_diffusion_timesteps,) + return betas + + +def get_named_beta_schedule(schedule_name, num_diffusion_timesteps): + """ + Get a pre-defined beta schedule for the given name. + The beta schedule library consists of beta schedules which remain similar + in the limit of num_diffusion_timesteps. + Beta schedules may be added, but should not be removed or changed once + they are committed to maintain backwards compatibility. + """ + if schedule_name == "linear": + # Linear schedule from Ho et al, extended to work for any number of + # diffusion steps. + scale = 1000 / num_diffusion_timesteps + return get_beta_schedule( + "linear", + beta_start=scale * 0.0001, + beta_end=scale * 0.02, + num_diffusion_timesteps=num_diffusion_timesteps, + ) + elif schedule_name == "squaredcos_cap_v2": + return betas_for_alpha_bar( + num_diffusion_timesteps, + lambda t: math.cos((t + 0.008) / 1.008 * math.pi / 2) ** 2, + ) + else: + raise NotImplementedError(f"unknown beta schedule: {schedule_name}") + + +def betas_for_alpha_bar(num_diffusion_timesteps, alpha_bar, max_beta=0.999): + """ + Create a beta schedule that discretizes the given alpha_t_bar function, + which defines the cumulative product of (1-beta) over time from t = [0,1]. + :param num_diffusion_timesteps: the number of betas to produce. + :param alpha_bar: a lambda that takes an argument t from 0 to 1 and + produces the cumulative product of (1-beta) up to that + part of the diffusion process. + :param max_beta: the maximum beta to use; use values lower than 1 to + prevent singularities. + """ + betas = [] + for i in range(num_diffusion_timesteps): + t1 = i / num_diffusion_timesteps + t2 = (i + 1) / num_diffusion_timesteps + betas.append(min(1 - alpha_bar(t2) / alpha_bar(t1), max_beta)) + return np.array(betas) + + +class ModelMeanType(enum.Enum): + """ + Which type of output the model predicts. + """ + + PREVIOUS_X = enum.auto() # the model predicts x_{t-1} + START_X = enum.auto() # the model predicts x_0 + EPSILON = enum.auto() # the model predicts epsilon + + +class ModelVarType(enum.Enum): + """ + What is used as the model's output variance. + The LEARNED_RANGE option has been added to allow the model to predict + values between FIXED_SMALL and FIXED_LARGE, making its job easier. + """ + + LEARNED = enum.auto() + FIXED_SMALL = enum.auto() + FIXED_LARGE = enum.auto() + LEARNED_RANGE = enum.auto() + + +class LossType(enum.Enum): + MSE = enum.auto() # use raw MSE loss (and KL when learning variances) + RESCALED_MSE = ( + enum.auto() + ) # use raw MSE loss (with RESCALED_KL when learning variances) + KL = enum.auto() # use the variational lower-bound + RESCALED_KL = enum.auto() # like KL, but rescale to estimate the full VLB + + def is_vb(self): + return self == LossType.KL or self == LossType.RESCALED_KL + + +class GaussianDiffusion(th.nn.Module): + """ + Utilities for training and sampling diffusion models. + Original ported from this codebase: + https://github.com/hojonathanho/diffusion/blob/1e0dceb3b3495bbe19116a5e1b3596cd0706c543/diffusion_tf/diffusion_utils_2.py#L42 + :param betas: a 1-D numpy array of betas for each diffusion timestep, + starting at T and going to 1. + """ + + def __init__( + self, + *, + betas, + model_mean_type, + model_var_type, + loss_type, + ): + super(GaussianDiffusion, self).__init__() + self.model_mean_type = model_mean_type + self.model_var_type = model_var_type + self.loss_type = loss_type + + # Use float64 for accuracy. + betas = np.array(betas, dtype=np.float64) + assert len(betas.shape) == 1, "betas must be 1-D" + assert (betas > 0).all() and (betas <= 1).all() + + self.num_timesteps = int(betas.shape[0]) + + alphas = 1.0 - betas + alphas_cumprod = np.cumprod(alphas, axis=0) + alphas_cumprod_prev = np.append(1.0, alphas_cumprod[:-1]) + alphas_cumprod_next = np.append(alphas_cumprod[1:], 0.0) + assert alphas_cumprod_prev.shape == (self.num_timesteps,) + + # calculations for diffusion q(x_t | x_{t-1}) and others + sqrt_alphas_cumprod = np.sqrt(alphas_cumprod) + sqrt_one_minus_alphas_cumprod = np.sqrt(1.0 - alphas_cumprod) + log_one_minus_alphas_cumprod = np.log(1.0 - alphas_cumprod) + sqrt_recip_alphas_cumprod = np.sqrt(1.0 / alphas_cumprod) + sqrt_recipm1_alphas_cumprod = np.sqrt(1.0 / alphas_cumprod - 1) + + # calculations for posterior q(x_{t-1} | x_t, x_0) + posterior_variance = ( + betas * (1.0 - alphas_cumprod_prev) / (1.0 - alphas_cumprod) + ) + # below: log calculation clipped because the posterior variance is 0 at the beginning of the diffusion chain + posterior_log_variance_clipped = np.log( + np.append(posterior_variance[1], posterior_variance[1:]) + ) + posterior_mean_coef1 = ( + betas * np.sqrt(alphas_cumprod_prev) / (1.0 - alphas_cumprod) + ) + posterior_mean_coef2 = ( + (1.0 - alphas_cumprod_prev) * np.sqrt(alphas) / (1.0 - alphas_cumprod) + ) + + self.register_buffer("betas", th.from_numpy(betas), persistent=False) + self.register_buffer( + "alphas_cumprod", th.from_numpy(alphas_cumprod), persistent=False + ) + self.register_buffer( + "alphas_cumprod_prev", th.from_numpy(alphas_cumprod_prev), persistent=False + ) + self.register_buffer( + "alphas_cumprod_next", th.from_numpy(alphas_cumprod_next), persistent=False + ) + + self.register_buffer( + "sqrt_alphas_cumprod", th.from_numpy(sqrt_alphas_cumprod), persistent=False + ) + self.register_buffer( + "sqrt_one_minus_alphas_cumprod", + th.from_numpy(sqrt_one_minus_alphas_cumprod), + persistent=False, + ) + self.register_buffer( + "log_one_minus_alphas_cumprod", + th.from_numpy(log_one_minus_alphas_cumprod), + persistent=False, + ) + self.register_buffer( + "sqrt_recip_alphas_cumprod", + th.from_numpy(sqrt_recip_alphas_cumprod), + persistent=False, + ) + self.register_buffer( + "sqrt_recipm1_alphas_cumprod", + th.from_numpy(sqrt_recipm1_alphas_cumprod), + persistent=False, + ) + + self.register_buffer( + "posterior_variance", th.from_numpy(posterior_variance), persistent=False + ) + self.register_buffer( + "posterior_log_variance_clipped", + th.from_numpy(posterior_log_variance_clipped), + persistent=False, + ) + self.register_buffer( + "posterior_mean_coef1", + th.from_numpy(posterior_mean_coef1), + persistent=False, + ) + self.register_buffer( + "posterior_mean_coef2", + th.from_numpy(posterior_mean_coef2), + persistent=False, + ) + + def q_mean_variance(self, x_start, t): + """ + Get the distribution q(x_t | x_0). + :param x_start: the [N x C x ...] tensor of noiseless inputs. + :param t: the number of diffusion steps (minus 1). Here, 0 means one step. + :return: A tuple (mean, variance, log_variance), all of x_start's shape. + """ + mean = ( + _extract_into_tensor(self.sqrt_alphas_cumprod, t, x_start.shape) * x_start + ) + variance = _extract_into_tensor(1.0 - self.alphas_cumprod, t, x_start.shape) + log_variance = _extract_into_tensor( + self.log_one_minus_alphas_cumprod, t, x_start.shape + ) + return mean, variance, log_variance + + def q_sample(self, x_start, t, noise=None): + """ + Diffuse the data for a given number of diffusion steps. + In other words, sample from q(x_t | x_0). + :param x_start: the initial data batch. + :param t: the number of diffusion steps (minus 1). Here, 0 means one step. + :param noise: if specified, the split-out normal noise. + :return: A noisy version of x_start. + """ + if noise is None: + noise = th.randn_like(x_start) + assert noise.shape == x_start.shape + return ( + _extract_into_tensor(self.sqrt_alphas_cumprod, t, x_start.shape) * x_start + + _extract_into_tensor(self.sqrt_one_minus_alphas_cumprod, t, x_start.shape) + * noise + ) + + def q_posterior_mean_variance(self, x_start, x_t, t): + """ + Compute the mean and variance of the diffusion posterior: + q(x_{t-1} | x_t, x_0) + """ + assert x_start.shape == x_t.shape + posterior_mean = ( + _extract_into_tensor(self.posterior_mean_coef1, t, x_t.shape) * x_start + + _extract_into_tensor(self.posterior_mean_coef2, t, x_t.shape) * x_t + ) + posterior_variance = _extract_into_tensor(self.posterior_variance, t, x_t.shape) + posterior_log_variance_clipped = _extract_into_tensor( + self.posterior_log_variance_clipped, t, x_t.shape + ) + assert ( + posterior_mean.shape[0] + == posterior_variance.shape[0] + == posterior_log_variance_clipped.shape[0] + == x_start.shape[0] + ) + return posterior_mean, posterior_variance, posterior_log_variance_clipped + + def p_mean_variance( + self, + model, + x, + t, + clip_denoised=True, + denoised_fn=None, + model_kwargs=None, + **ignore_kwargs, + ): + """ + Apply the model to get p(x_{t-1} | x_t), as well as a prediction of + the initial x, x_0. + :param model: the model, which takes a signal and a batch of timesteps + as input. + :param x: the [N x C x ...] tensor at time t. + :param t: a 1-D Tensor of timesteps. + :param clip_denoised: if True, clip the denoised signal into [-1, 1]. + :param denoised_fn: if not None, a function which applies to the + x_start prediction before it is used to sample. Applies before + clip_denoised. + :param model_kwargs: if not None, a dict of extra keyword arguments to + pass to the model. This can be used for conditioning. + :return: a dict with the following keys: + - 'mean': the model mean output. + - 'variance': the model variance output. + - 'log_variance': the log of 'variance'. + - 'pred_xstart': the prediction for x_0. + """ + if model_kwargs is None: + model_kwargs = {} + + B, C = x.shape[:2] + assert t.shape == (B,) + model_output = model(x, t, **model_kwargs) + if isinstance(model_output, tuple): + model_output, extra = model_output + else: + extra = None + + if self.model_var_type in [ModelVarType.LEARNED, ModelVarType.LEARNED_RANGE]: + assert model_output.shape == (B, C * 2, *x.shape[2:]) + model_output, model_var_values = th.split(model_output, C, dim=1) + if self.model_var_type == ModelVarType.LEARNED: + model_log_variance = model_var_values + model_variance = th.exp(model_log_variance) + else: + min_log = _extract_into_tensor( + self.posterior_log_variance_clipped, t, x.shape + ) + max_log = _extract_into_tensor(th.log(self.betas), t, x.shape) + # The model_var_values is [-1, 1] for [min_var, max_var]. + frac = (model_var_values + 1) / 2 + model_log_variance = frac * max_log + (1 - frac) * min_log + model_variance = th.exp(model_log_variance) + else: + model_variance, model_log_variance = { + # for fixedlarge, we set the initial (log-)variance like so + # to get a better decoder log likelihood. + ModelVarType.FIXED_LARGE: ( + th.cat([self.posterior_variance[1][None], self.betas[1:]]), + th.log(th.cat([self.posterior_variance[1][None], self.betas[1:]])), + ), + ModelVarType.FIXED_SMALL: ( + self.posterior_variance, + self.posterior_log_variance_clipped, + ), + }[self.model_var_type] + model_variance = _extract_into_tensor(model_variance, t, x.shape) + model_log_variance = _extract_into_tensor(model_log_variance, t, x.shape) + + def process_xstart(x): + if denoised_fn is not None: + x = denoised_fn(x) + if clip_denoised: + return x.clamp(-1, 1) + return x + + if self.model_mean_type == ModelMeanType.PREVIOUS_X: + pred_xstart = process_xstart( + self._predict_xstart_from_xprev(x_t=x, t=t, xprev=model_output) + ) + model_mean = model_output + elif self.model_mean_type in [ModelMeanType.START_X, ModelMeanType.EPSILON]: + if self.model_mean_type == ModelMeanType.START_X: + pred_xstart = process_xstart(model_output) + else: + pred_xstart = process_xstart( + self._predict_xstart_from_eps(x_t=x, t=t, eps=model_output) + ) + model_mean, _, _ = self.q_posterior_mean_variance( + x_start=pred_xstart, x_t=x, t=t + ) + else: + raise NotImplementedError(self.model_mean_type) + + assert ( + model_mean.shape == model_log_variance.shape == pred_xstart.shape == x.shape + ) + return { + "mean": model_mean, + "variance": model_variance, + "log_variance": model_log_variance, + "pred_xstart": pred_xstart, + } + + def _predict_xstart_from_eps(self, x_t, t, eps): + assert x_t.shape == eps.shape + return ( + _extract_into_tensor(self.sqrt_recip_alphas_cumprod, t, x_t.shape) * x_t + - _extract_into_tensor(self.sqrt_recipm1_alphas_cumprod, t, x_t.shape) * eps + ) + + def _predict_eps_from_xstart(self, x_t, t, pred_xstart): + return ( + _extract_into_tensor(self.sqrt_recip_alphas_cumprod, t, x_t.shape) * x_t + - pred_xstart + ) / _extract_into_tensor(self.sqrt_recipm1_alphas_cumprod, t, x_t.shape) + + def condition_mean(self, cond_fn, p_mean_var, x, t, model_kwargs=None): + """ + Compute the mean for the previous step, given a function cond_fn that + computes the gradient of a conditional log probability with respect to + x. In particular, cond_fn computes grad(log(p(y|x))), and we want to + condition on y. + This uses the conditioning strategy from Sohl-Dickstein et al. (2015). + """ + gradient = cond_fn(x, t, **model_kwargs) + new_mean = ( + p_mean_var["mean"].float() + p_mean_var["variance"] * gradient.float() + ) + return new_mean + + def condition_score(self, cond_fn, p_mean_var, x, t, model_kwargs=None): + """ + Compute what the p_mean_variance output would have been, should the + model's score function be conditioned by cond_fn. + See condition_mean() for details on cond_fn. + Unlike condition_mean(), this instead uses the conditioning strategy + from Song et al (2020). + """ + alpha_bar = _extract_into_tensor(self.alphas_cumprod, t, x.shape) + + eps = self._predict_eps_from_xstart(x, t, p_mean_var["pred_xstart"]) + eps = eps - (1 - alpha_bar).sqrt() * cond_fn(x, t, **model_kwargs) + + out = p_mean_var.copy() + out["pred_xstart"] = self._predict_xstart_from_eps(x, t, eps) + out["mean"], _, _ = self.q_posterior_mean_variance( + x_start=out["pred_xstart"], x_t=x, t=t + ) + return out + + def p_sample( + self, + model, + x, + t, + clip_denoised=True, + denoised_fn=None, + cond_fn=None, + model_kwargs=None, + ): + """ + Sample x_{t-1} from the model at the given timestep. + :param model: the model to sample from. + :param x: the current tensor at x_{t-1}. + :param t: the value of t, starting at 0 for the first diffusion step. + :param clip_denoised: if True, clip the x_start prediction to [-1, 1]. + :param denoised_fn: if not None, a function which applies to the + x_start prediction before it is used to sample. + :param cond_fn: if not None, this is a gradient function that acts + similarly to the model. + :param model_kwargs: if not None, a dict of extra keyword arguments to + pass to the model. This can be used for conditioning. + :return: a dict containing the following keys: + - 'sample': a random sample from the model. + - 'pred_xstart': a prediction of x_0. + """ + out = self.p_mean_variance( + model, + x, + t, + clip_denoised=clip_denoised, + denoised_fn=denoised_fn, + model_kwargs=model_kwargs, + ) + noise = th.randn_like(x) + nonzero_mask = ( + (t != 0).float().view(-1, *([1] * (len(x.shape) - 1))) + ) # no noise when t == 0 + if cond_fn is not None: + out["mean"] = self.condition_mean( + cond_fn, out, x, t, model_kwargs=model_kwargs + ) + sample = out["mean"] + nonzero_mask * th.exp(0.5 * out["log_variance"]) * noise + return {"sample": sample, "pred_xstart": out["pred_xstart"]} + + def p_sample_loop( + self, + model, + shape, + noise=None, + clip_denoised=True, + denoised_fn=None, + cond_fn=None, + model_kwargs=None, + device=None, + progress=False, + ): + """ + Generate samples from the model. + :param model: the model module. + :param shape: the shape of the samples, (N, C, H, W). + :param noise: if specified, the noise from the encoder to sample. + Should be of the same shape as `shape`. + :param clip_denoised: if True, clip x_start predictions to [-1, 1]. + :param denoised_fn: if not None, a function which applies to the + x_start prediction before it is used to sample. + :param cond_fn: if not None, this is a gradient function that acts + similarly to the model. + :param model_kwargs: if not None, a dict of extra keyword arguments to + pass to the model. This can be used for conditioning. + :param device: if specified, the device to create the samples on. + If not specified, use a model parameter's device. + :param progress: if True, show a tqdm progress bar. + :return: a non-differentiable batch of samples. + """ + final = None + for sample in self.p_sample_loop_progressive( + model, + shape, + noise=noise, + clip_denoised=clip_denoised, + denoised_fn=denoised_fn, + cond_fn=cond_fn, + model_kwargs=model_kwargs, + device=device, + progress=progress, + ): + final = sample + return final["sample"] + + def p_sample_loop_progressive( + self, + model, + shape, + noise=None, + clip_denoised=True, + denoised_fn=None, + cond_fn=None, + model_kwargs=None, + device=None, + progress=False, + ): + """ + Generate samples from the model and yield intermediate samples from + each timestep of diffusion. + Arguments are the same as p_sample_loop(). + Returns a generator over dicts, where each dict is the return value of + p_sample(). + """ + if device is None: + device = next(model.parameters()).device + assert isinstance(shape, (tuple, list)) + if noise is not None: + img = noise + else: + img = th.randn(*shape, device=device) + indices = list(range(self.num_timesteps))[::-1] + + if progress: + # Lazy import so that we don't depend on tqdm. + from tqdm.auto import tqdm + + indices = tqdm(indices) + + for idx, i in enumerate(indices): + t = th.tensor([i] * shape[0], device=device) + with th.no_grad(): + out = self.p_sample( + model, + img, + t, + clip_denoised=clip_denoised, + denoised_fn=denoised_fn, + cond_fn=cond_fn, + model_kwargs=model_kwargs, + ) + yield out + img = out["sample"] + + def p_sample_loop_progressive_for_improved_sr( + self, + model, + model_aux, + shape, + noise=None, + clip_denoised=True, + denoised_fn=None, + cond_fn=None, + model_kwargs=None, + device=None, + progress=False, + ): + """ + Modified version of p_sample_loop_progressive for sampling from the improved sr model + """ + + if device is None: + device = next(model.parameters()).device + assert isinstance(shape, (tuple, list)) + if noise is not None: + img = noise + else: + img = th.randn(*shape, device=device) + indices = list(range(self.num_timesteps))[::-1] + + if progress: + # Lazy import so that we don't depend on tqdm. + from tqdm.auto import tqdm + + indices = tqdm(indices) + + for idx, i in enumerate(indices): + t = th.tensor([i] * shape[0], device=device) + with th.no_grad(): + out = self.p_sample( + model_aux if len(indices) - 1 == idx else model, + img, + t, + clip_denoised=clip_denoised, + denoised_fn=denoised_fn, + cond_fn=cond_fn, + model_kwargs=model_kwargs, + ) + yield out + img = out["sample"] + + def ddim_sample( + self, + model, + x, + t, + clip_denoised=True, + denoised_fn=None, + cond_fn=None, + model_kwargs=None, + eta=0.0, + ): + """ + Sample x_{t-1} from the model using DDIM. + Same usage as p_sample(). + """ + out = self.p_mean_variance( + model, + x, + t, + clip_denoised=clip_denoised, + denoised_fn=denoised_fn, + model_kwargs=model_kwargs, + ) + if cond_fn is not None: + out = self.condition_score(cond_fn, out, x, t, model_kwargs=model_kwargs) + + # Usually our model outputs epsilon, but we re-derive it + # in case we used x_start or x_prev prediction. + eps = self._predict_eps_from_xstart(x, t, out["pred_xstart"]) + + alpha_bar = _extract_into_tensor(self.alphas_cumprod, t, x.shape) + alpha_bar_prev = _extract_into_tensor(self.alphas_cumprod_prev, t, x.shape) + sigma = ( + eta + * th.sqrt((1 - alpha_bar_prev) / (1 - alpha_bar)) + * th.sqrt(1 - alpha_bar / alpha_bar_prev) + ) + # Equation 12. + noise = th.randn_like(x) + mean_pred = ( + out["pred_xstart"] * th.sqrt(alpha_bar_prev) + + th.sqrt(1 - alpha_bar_prev - sigma**2) * eps + ) + nonzero_mask = ( + (t != 0).float().view(-1, *([1] * (len(x.shape) - 1))) + ) # no noise when t == 0 + sample = mean_pred + nonzero_mask * sigma * noise + return {"sample": sample, "pred_xstart": out["pred_xstart"]} + + def ddim_reverse_sample( + self, + model, + x, + t, + clip_denoised=True, + denoised_fn=None, + cond_fn=None, + model_kwargs=None, + eta=0.0, + ): + """ + Sample x_{t+1} from the model using DDIM reverse ODE. + """ + assert eta == 0.0, "Reverse ODE only for deterministic path" + out = self.p_mean_variance( + model, + x, + t, + clip_denoised=clip_denoised, + denoised_fn=denoised_fn, + model_kwargs=model_kwargs, + ) + if cond_fn is not None: + out = self.condition_score(cond_fn, out, x, t, model_kwargs=model_kwargs) + # Usually our model outputs epsilon, but we re-derive it + # in case we used x_start or x_prev prediction. + eps = ( + _extract_into_tensor(self.sqrt_recip_alphas_cumprod, t, x.shape) * x + - out["pred_xstart"] + ) / _extract_into_tensor(self.sqrt_recipm1_alphas_cumprod, t, x.shape) + alpha_bar_next = _extract_into_tensor(self.alphas_cumprod_next, t, x.shape) + + # Equation 12. reversed + mean_pred = ( + out["pred_xstart"] * th.sqrt(alpha_bar_next) + + th.sqrt(1 - alpha_bar_next) * eps + ) + + return {"sample": mean_pred, "pred_xstart": out["pred_xstart"]} + + def ddim_sample_loop( + self, + model, + shape, + noise=None, + clip_denoised=True, + denoised_fn=None, + cond_fn=None, + model_kwargs=None, + device=None, + progress=False, + eta=0.0, + ): + """ + Generate samples from the model using DDIM. + Same usage as p_sample_loop(). + """ + final = None + for sample in self.ddim_sample_loop_progressive( + model, + shape, + noise=noise, + clip_denoised=clip_denoised, + denoised_fn=denoised_fn, + cond_fn=cond_fn, + model_kwargs=model_kwargs, + device=device, + progress=progress, + eta=eta, + ): + final = sample + return final["sample"] + + def ddim_sample_loop_progressive( + self, + model, + shape, + noise=None, + clip_denoised=True, + denoised_fn=None, + cond_fn=None, + model_kwargs=None, + device=None, + progress=False, + eta=0.0, + ): + """ + Use DDIM to sample from the model and yield intermediate samples from + each timestep of DDIM. + Same usage as p_sample_loop_progressive(). + """ + if device is None: + device = next(model.parameters()).device + assert isinstance(shape, (tuple, list)) + if noise is not None: + img = noise + else: + img = th.randn(*shape, device=device) + indices = list(range(self.num_timesteps))[::-1] + + if progress: + # Lazy import so that we don't depend on tqdm. + from tqdm.auto import tqdm + + indices = tqdm(indices) + + for i in indices: + t = th.tensor([i] * shape[0], device=device) + with th.no_grad(): + out = self.ddim_sample( + model, + img, + t, + clip_denoised=clip_denoised, + denoised_fn=denoised_fn, + cond_fn=cond_fn, + model_kwargs=model_kwargs, + eta=eta, + ) + yield out + img = out["sample"] + + +def _extract_into_tensor(arr, timesteps, broadcast_shape): + """ + Extract values from a 1-D numpy array for a batch of indices. + :param arr: the 1-D numpy array. + :param timesteps: a tensor of indices into the array to extract. + :param broadcast_shape: a larger shape of K dimensions with the batch + dimension equal to the length of timesteps. + :return: a tensor of shape [batch_size, 1, ...] where the shape has K dims. + """ + res = arr.to(device=timesteps.device)[timesteps].float() + while len(res.shape) < len(broadcast_shape): + res = res[..., None] + return res + th.zeros(broadcast_shape, device=timesteps.device) diff --git a/ldm/modules/karlo/kakao/modules/diffusion/respace.py b/ldm/modules/karlo/kakao/modules/diffusion/respace.py new file mode 100644 index 0000000000000000000000000000000000000000..70c808f8b3ce947a8466026ca0d4ceccabda3745 --- /dev/null +++ b/ldm/modules/karlo/kakao/modules/diffusion/respace.py @@ -0,0 +1,112 @@ +# ------------------------------------------------------------------------------------ +# Adapted from Guided-Diffusion repo (https://github.com/openai/guided-diffusion) +# ------------------------------------------------------------------------------------ + + +import torch as th + +from .gaussian_diffusion import GaussianDiffusion + + +def space_timesteps(num_timesteps, section_counts): + """ + Create a list of timesteps to use from an original diffusion process, + given the number of timesteps we want to take from equally-sized portions + of the original process. + + For example, if there's 300 timesteps and the section counts are [10,15,20] + then the first 100 timesteps are strided to be 10 timesteps, the second 100 + are strided to be 15 timesteps, and the final 100 are strided to be 20. + + :param num_timesteps: the number of diffusion steps in the original + process to divide up. + :param section_counts: either a list of numbers, or a string containing + comma-separated numbers, indicating the step count + per section. As a special case, use "ddimN" where N + is a number of steps to use the striding from the + DDIM paper. + :return: a set of diffusion steps from the original process to use. + """ + if isinstance(section_counts, str): + if section_counts.startswith("ddim"): + desired_count = int(section_counts[len("ddim") :]) + for i in range(1, num_timesteps): + if len(range(0, num_timesteps, i)) == desired_count: + return set(range(0, num_timesteps, i)) + raise ValueError( + f"cannot create exactly {num_timesteps} steps with an integer stride" + ) + elif section_counts == "fast27": + steps = space_timesteps(num_timesteps, "10,10,3,2,2") + # Help reduce DDIM artifacts from noisiest timesteps. + steps.remove(num_timesteps - 1) + steps.add(num_timesteps - 3) + return steps + section_counts = [int(x) for x in section_counts.split(",")] + size_per = num_timesteps // len(section_counts) + extra = num_timesteps % len(section_counts) + start_idx = 0 + all_steps = [] + for i, section_count in enumerate(section_counts): + size = size_per + (1 if i < extra else 0) + if size < section_count: + raise ValueError( + f"cannot divide section of {size} steps into {section_count}" + ) + if section_count <= 1: + frac_stride = 1 + else: + frac_stride = (size - 1) / (section_count - 1) + cur_idx = 0.0 + taken_steps = [] + for _ in range(section_count): + taken_steps.append(start_idx + round(cur_idx)) + cur_idx += frac_stride + all_steps += taken_steps + start_idx += size + return set(all_steps) + + +class SpacedDiffusion(GaussianDiffusion): + """ + A diffusion process which can skip steps in a base diffusion process. + + :param use_timesteps: a collection (sequence or set) of timesteps from the + original diffusion process to retain. + :param kwargs: the kwargs to create the base diffusion process. + """ + + def __init__(self, use_timesteps, **kwargs): + self.use_timesteps = set(use_timesteps) + self.original_num_steps = len(kwargs["betas"]) + + base_diffusion = GaussianDiffusion(**kwargs) # pylint: disable=missing-kwoa + last_alpha_cumprod = 1.0 + new_betas = [] + timestep_map = [] + for i, alpha_cumprod in enumerate(base_diffusion.alphas_cumprod): + if i in self.use_timesteps: + new_betas.append(1 - alpha_cumprod / last_alpha_cumprod) + last_alpha_cumprod = alpha_cumprod + timestep_map.append(i) + kwargs["betas"] = th.tensor(new_betas).numpy() + super().__init__(**kwargs) + self.register_buffer("timestep_map", th.tensor(timestep_map), persistent=False) + + def p_mean_variance(self, model, *args, **kwargs): + return super().p_mean_variance(self._wrap_model(model), *args, **kwargs) + + def condition_mean(self, cond_fn, *args, **kwargs): + return super().condition_mean(self._wrap_model(cond_fn), *args, **kwargs) + + def condition_score(self, cond_fn, *args, **kwargs): + return super().condition_score(self._wrap_model(cond_fn), *args, **kwargs) + + def _wrap_model(self, model): + def wrapped(x, ts, **kwargs): + ts_cpu = ts.detach().to("cpu") + return model( + x, self.timestep_map[ts_cpu].to(device=ts.device, dtype=ts.dtype), **kwargs + ) + + return wrapped diff --git a/ldm/modules/karlo/kakao/modules/nn.py b/ldm/modules/karlo/kakao/modules/nn.py new file mode 100644 index 0000000000000000000000000000000000000000..2eef3f5a06778b269f99168d2a2962df84422ad0 --- /dev/null +++ b/ldm/modules/karlo/kakao/modules/nn.py @@ -0,0 +1,114 @@ +# ------------------------------------------------------------------------------------ +# Adapted from Guided-Diffusion repo (https://github.com/openai/guided-diffusion) +# ------------------------------------------------------------------------------------ + +import math + +import torch as th +import torch.nn as nn +import torch.nn.functional as F + + +class GroupNorm32(nn.GroupNorm): + def __init__(self, num_groups, num_channels, swish, eps=1e-5): + super().__init__(num_groups=num_groups, num_channels=num_channels, eps=eps) + self.swish = swish + + def forward(self, x): + y = super().forward(x.float()).to(x.dtype) + if self.swish == 1.0: + y = F.silu(y) + elif self.swish: + y = y * F.sigmoid(y * float(self.swish)) + return y + + +def conv_nd(dims, *args, **kwargs): + """ + Create a 1D, 2D, or 3D convolution module. + """ + if dims == 1: + return nn.Conv1d(*args, **kwargs) + elif dims == 2: + return nn.Conv2d(*args, **kwargs) + elif dims == 3: + return nn.Conv3d(*args, **kwargs) + raise ValueError(f"unsupported dimensions: {dims}") + + +def linear(*args, **kwargs): + """ + Create a linear module. + """ + return nn.Linear(*args, **kwargs) + + +def avg_pool_nd(dims, *args, **kwargs): + """ + Create a 1D, 2D, or 3D average pooling module. + """ + if dims == 1: + return nn.AvgPool1d(*args, **kwargs) + elif dims == 2: + return nn.AvgPool2d(*args, **kwargs) + elif dims == 3: + return nn.AvgPool3d(*args, **kwargs) + raise ValueError(f"unsupported dimensions: {dims}") + + +def zero_module(module): + """ + Zero out the parameters of a module and return it. + """ + for p in module.parameters(): + p.detach().zero_() + return module + + +def scale_module(module, scale): + """ + Scale the parameters of a module and return it. + """ + for p in module.parameters(): + p.detach().mul_(scale) + return module + + +def normalization(channels, swish=0.0): + """ + Make a standard normalization layer, with an optional swish activation. + + :param channels: number of input channels. + :return: an nn.Module for normalization. + """ + return GroupNorm32(num_channels=channels, num_groups=32, swish=swish) + + +def timestep_embedding(timesteps, dim, max_period=10000): + """ + Create sinusoidal timestep embeddings. + + :param timesteps: a 1-D Tensor of N indices, one per batch element. + These may be fractional. + :param dim: the dimension of the output. + :param max_period: controls the minimum frequency of the embeddings. + :return: an [N x dim] Tensor of positional embeddings. + """ + half = dim // 2 + freqs = th.exp( + -math.log(max_period) + * th.arange(start=0, end=half, dtype=th.float32, device=timesteps.device) + / half + ) + args = timesteps[:, None].float() * freqs[None] + embedding = th.cat([th.cos(args), th.sin(args)], dim=-1) + if dim % 2: + embedding = th.cat([embedding, th.zeros_like(embedding[:, :1])], dim=-1) + return embedding + + +def mean_flat(tensor): + """ + Take the mean over all non-batch dimensions. + """ + return tensor.mean(dim=list(range(1, len(tensor.shape)))) diff --git a/ldm/modules/karlo/kakao/modules/resample.py b/ldm/modules/karlo/kakao/modules/resample.py new file mode 100644 index 0000000000000000000000000000000000000000..485421aa4066a34ec01bdba8a26bd113598461ac --- /dev/null +++ b/ldm/modules/karlo/kakao/modules/resample.py @@ -0,0 +1,68 @@ +# ------------------------------------------------------------------------------------ +# Modified from Guided-Diffusion (https://github.com/openai/guided-diffusion) +# ------------------------------------------------------------------------------------ + +from abc import abstractmethod + +import torch as th + + +def create_named_schedule_sampler(name, diffusion): + """ + Create a ScheduleSampler from a library of pre-defined samplers. + + :param name: the name of the sampler. + :param diffusion: the diffusion object to sample for. + """ + if name == "uniform": + return UniformSampler(diffusion) + else: + raise NotImplementedError(f"unknown schedule sampler: {name}") + + +class ScheduleSampler(th.nn.Module): + """ + A distribution over timesteps in the diffusion process, intended to reduce + variance of the objective. + + By default, samplers perform unbiased importance sampling, in which the + objective's mean is unchanged. + However, subclasses may override sample() to change how the resampled + terms are reweighted, allowing for actual changes in the objective. + """ + + @abstractmethod + def weights(self): + """ + Get a numpy array of weights, one per diffusion step. + + The weights needn't be normalized, but must be positive. + """ + + def sample(self, batch_size, device): + """ + Importance-sample timesteps for a batch. + + :param batch_size: the number of timesteps. + :param device: the torch device to save to. + :return: a tuple (timesteps, weights): + - timesteps: a tensor of timestep indices. + - weights: a tensor of weights to scale the resulting losses. + """ + w = self.weights() + p = w / th.sum(w) + indices = p.multinomial(batch_size, replacement=True) + weights = 1 / (len(p) * p[indices]) + return indices, weights + + +class UniformSampler(ScheduleSampler): + def __init__(self, diffusion): + super(UniformSampler, self).__init__() + self.diffusion = diffusion + self.register_buffer( + "_weights", th.ones([diffusion.num_timesteps]), persistent=False + ) + + def weights(self): + return self._weights diff --git a/ldm/modules/karlo/kakao/modules/unet.py b/ldm/modules/karlo/kakao/modules/unet.py new file mode 100644 index 0000000000000000000000000000000000000000..c99d0b791876add8b85354d05d61a6ae2c852e68 --- /dev/null +++ b/ldm/modules/karlo/kakao/modules/unet.py @@ -0,0 +1,792 @@ +# ------------------------------------------------------------------------------------ +# Modified from Guided-Diffusion (https://github.com/openai/guided-diffusion) +# ------------------------------------------------------------------------------------ + +import math +from abc import abstractmethod + +import torch as th +import torch.nn as nn +import torch.nn.functional as F + +from .nn import ( + avg_pool_nd, + conv_nd, + linear, + normalization, + timestep_embedding, + zero_module, +) +from .xf import LayerNorm + + +class TimestepBlock(nn.Module): + """ + Any module where forward() takes timestep embeddings as a second argument. + """ + + @abstractmethod + def forward(self, x, emb): + """ + Apply the module to `x` given `emb` timestep embeddings. + """ + + +class TimestepEmbedSequential(nn.Sequential, TimestepBlock): + """ + A sequential module that passes timestep embeddings to the children that + support it as an extra input. + """ + + def forward(self, x, emb, encoder_out=None, mask=None): + for layer in self: + if isinstance(layer, TimestepBlock): + x = layer(x, emb) + elif isinstance(layer, AttentionBlock): + x = layer(x, encoder_out, mask=mask) + else: + x = layer(x) + return x + + +class Upsample(nn.Module): + """ + An upsampling layer with an optional convolution. + + :param channels: channels in the inputs and outputs. + :param use_conv: a bool determining if a convolution is applied. + :param dims: determines if the signal is 1D, 2D, or 3D. If 3D, then + upsampling occurs in the inner-two dimensions. + """ + + def __init__(self, channels, use_conv, dims=2, out_channels=None): + super().__init__() + self.channels = channels + self.out_channels = out_channels or channels + self.use_conv = use_conv + self.dims = dims + if use_conv: + self.conv = conv_nd(dims, self.channels, self.out_channels, 3, padding=1) + + def forward(self, x): + assert x.shape[1] == self.channels + if self.dims == 3: + x = F.interpolate( + x, (x.shape[2], x.shape[3] * 2, x.shape[4] * 2), mode="nearest" + ) + else: + x = F.interpolate(x, scale_factor=2, mode="nearest") + if self.use_conv: + x = self.conv(x) + return x + + +class Downsample(nn.Module): + """ + A downsampling layer with an optional convolution. + + :param channels: channels in the inputs and outputs. + :param use_conv: a bool determining if a convolution is applied. + :param dims: determines if the signal is 1D, 2D, or 3D. If 3D, then + downsampling occurs in the inner-two dimensions. + """ + + def __init__(self, channels, use_conv, dims=2, out_channels=None): + super().__init__() + self.channels = channels + self.out_channels = out_channels or channels + self.use_conv = use_conv + self.dims = dims + stride = 2 if dims != 3 else (1, 2, 2) + if use_conv: + self.op = conv_nd( + dims, self.channels, self.out_channels, 3, stride=stride, padding=1 + ) + else: + assert self.channels == self.out_channels + self.op = avg_pool_nd(dims, kernel_size=stride, stride=stride) + + def forward(self, x): + assert x.shape[1] == self.channels + return self.op(x) + + +class ResBlock(TimestepBlock): + """ + A residual block that can optionally change the number of channels. + + :param channels: the number of input channels. + :param emb_channels: the number of timestep embedding channels. + :param dropout: the rate of dropout. + :param out_channels: if specified, the number of out channels. + :param use_conv: if True and out_channels is specified, use a spatial + convolution instead of a smaller 1x1 convolution to change the + channels in the skip connection. + :param dims: determines if the signal is 1D, 2D, or 3D. + :param use_checkpoint: if True, use gradient checkpointing on this module. + :param up: if True, use this block for upsampling. + :param down: if True, use this block for downsampling. + """ + + def __init__( + self, + channels, + emb_channels, + dropout, + out_channels=None, + use_conv=False, + use_scale_shift_norm=False, + dims=2, + use_checkpoint=False, + up=False, + down=False, + ): + super().__init__() + self.channels = channels + self.emb_channels = emb_channels + self.dropout = dropout + self.out_channels = out_channels or channels + self.use_conv = use_conv + self.use_checkpoint = use_checkpoint + self.use_scale_shift_norm = use_scale_shift_norm + + self.in_layers = nn.Sequential( + normalization(channels, swish=1.0), + nn.Identity(), + conv_nd(dims, channels, self.out_channels, 3, padding=1), + ) + + self.updown = up or down + + if up: + self.h_upd = Upsample(channels, False, dims) + self.x_upd = Upsample(channels, False, dims) + elif down: + self.h_upd = Downsample(channels, False, dims) + self.x_upd = Downsample(channels, False, dims) + else: + self.h_upd = self.x_upd = nn.Identity() + + self.emb_layers = nn.Sequential( + nn.SiLU(), + linear( + emb_channels, + 2 * self.out_channels if use_scale_shift_norm else self.out_channels, + ), + ) + self.out_layers = nn.Sequential( + normalization( + self.out_channels, swish=0.0 if use_scale_shift_norm else 1.0 + ), + nn.SiLU() if use_scale_shift_norm else nn.Identity(), + nn.Dropout(p=dropout), + zero_module( + conv_nd(dims, self.out_channels, self.out_channels, 3, padding=1) + ), + ) + + if self.out_channels == channels: + self.skip_connection = nn.Identity() + elif use_conv: + self.skip_connection = conv_nd( + dims, channels, self.out_channels, 3, padding=1 + ) + else: + self.skip_connection = conv_nd(dims, channels, self.out_channels, 1) + + def forward(self, x, emb): + """ + Apply the block to a Tensor, conditioned on a timestep embedding. + + :param x: an [N x C x ...] Tensor of features. + :param emb: an [N x emb_channels] Tensor of timestep embeddings. + :return: an [N x C x ...] Tensor of outputs. + """ + if self.updown: + in_rest, in_conv = self.in_layers[:-1], self.in_layers[-1] + h = in_rest(x) + h = self.h_upd(h) + x = self.x_upd(x) + h = in_conv(h) + else: + h = self.in_layers(x) + emb_out = self.emb_layers(emb) + while len(emb_out.shape) < len(h.shape): + emb_out = emb_out[..., None] + if self.use_scale_shift_norm: + out_norm, out_rest = self.out_layers[0], self.out_layers[1:] + scale, shift = th.chunk(emb_out, 2, dim=1) + h = out_norm(h) * (1 + scale) + shift + h = out_rest(h) + else: + h = h + emb_out + h = self.out_layers(h) + return self.skip_connection(x) + h + + +class ResBlockNoTimeEmbedding(nn.Module): + """ + A residual block without time embedding + + :param channels: the number of input channels. + :param emb_channels: the number of timestep embedding channels. + :param dropout: the rate of dropout. + :param out_channels: if specified, the number of out channels. + :param use_conv: if True and out_channels is specified, use a spatial + convolution instead of a smaller 1x1 convolution to change the + channels in the skip connection. + :param dims: determines if the signal is 1D, 2D, or 3D. + :param use_checkpoint: if True, use gradient checkpointing on this module. + :param up: if True, use this block for upsampling. + :param down: if True, use this block for downsampling. + """ + + def __init__( + self, + channels, + emb_channels, + dropout, + out_channels=None, + use_conv=False, + dims=2, + use_checkpoint=False, + up=False, + down=False, + **kwargs, + ): + super().__init__() + self.channels = channels + self.emb_channels = emb_channels + self.dropout = dropout + self.out_channels = out_channels or channels + self.use_conv = use_conv + self.use_checkpoint = use_checkpoint + + self.in_layers = nn.Sequential( + normalization(channels, swish=1.0), + nn.Identity(), + conv_nd(dims, channels, self.out_channels, 3, padding=1), + ) + + self.updown = up or down + + if up: + self.h_upd = Upsample(channels, False, dims) + self.x_upd = Upsample(channels, False, dims) + elif down: + self.h_upd = Downsample(channels, False, dims) + self.x_upd = Downsample(channels, False, dims) + else: + self.h_upd = self.x_upd = nn.Identity() + + self.out_layers = nn.Sequential( + normalization(self.out_channels, swish=1.0), + nn.Dropout(p=dropout), + zero_module( + conv_nd(dims, self.out_channels, self.out_channels, 3, padding=1) + ), + ) + + if self.out_channels == channels: + self.skip_connection = nn.Identity() + elif use_conv: + self.skip_connection = conv_nd( + dims, channels, self.out_channels, 3, padding=1 + ) + else: + self.skip_connection = conv_nd(dims, channels, self.out_channels, 1) + + def forward(self, x, emb=None): + """ + Apply the block to a Tensor, NOT conditioned on a timestep embedding. + + :param x: an [N x C x ...] Tensor of features. + :param emb: an [N x emb_channels] Tensor of timestep embeddings. + :return: an [N x C x ...] Tensor of outputs. + """ + assert emb is None + + if self.updown: + in_rest, in_conv = self.in_layers[:-1], self.in_layers[-1] + h = in_rest(x) + h = self.h_upd(h) + x = self.x_upd(x) + h = in_conv(h) + else: + h = self.in_layers(x) + h = self.out_layers(h) + return self.skip_connection(x) + h + + +class AttentionBlock(nn.Module): + """ + An attention block that allows spatial positions to attend to each other. + + Originally ported from here, but adapted to the N-d case. + https://github.com/hojonathanho/diffusion/blob/1e0dceb3b3495bbe19116a5e1b3596cd0706c543/diffusion_tf/models/unet.py#L66. + """ + + def __init__( + self, + channels, + num_heads=1, + num_head_channels=-1, + use_checkpoint=False, + encoder_channels=None, + ): + super().__init__() + self.channels = channels + if num_head_channels == -1: + self.num_heads = num_heads + else: + assert ( + channels % num_head_channels == 0 + ), f"q,k,v channels {channels} is not divisible by num_head_channels {num_head_channels}" + self.num_heads = channels // num_head_channels + self.use_checkpoint = use_checkpoint + self.norm = normalization(channels, swish=0.0) + self.qkv = conv_nd(1, channels, channels * 3, 1) + self.attention = QKVAttention(self.num_heads) + + if encoder_channels is not None: + self.encoder_kv = conv_nd(1, encoder_channels, channels * 2, 1) + self.proj_out = zero_module(conv_nd(1, channels, channels, 1)) + + def forward(self, x, encoder_out=None, mask=None): + b, c, *spatial = x.shape + qkv = self.qkv(self.norm(x).view(b, c, -1)) + if encoder_out is not None: + encoder_out = self.encoder_kv(encoder_out) + h = self.attention(qkv, encoder_out, mask=mask) + else: + h = self.attention(qkv) + h = self.proj_out(h) + return x + h.reshape(b, c, *spatial) + + +class QKVAttention(nn.Module): + """ + A module which performs QKV attention. Matches legacy QKVAttention + input/ouput heads shaping + """ + + def __init__(self, n_heads): + super().__init__() + self.n_heads = n_heads + + def forward(self, qkv, encoder_kv=None, mask=None): + """ + Apply QKV attention. + + :param qkv: an [N x (H * 3 * C) x T] tensor of Qs, Ks, and Vs. + :return: an [N x (H * C) x T] tensor after attention. + """ + bs, width, length = qkv.shape + assert width % (3 * self.n_heads) == 0 + ch = width // (3 * self.n_heads) + q, k, v = qkv.reshape(bs * self.n_heads, ch * 3, length).split(ch, dim=1) + if encoder_kv is not None: + assert encoder_kv.shape[1] == self.n_heads * ch * 2 + ek, ev = encoder_kv.reshape(bs * self.n_heads, ch * 2, -1).split(ch, dim=1) + k = th.cat([ek, k], dim=-1) + v = th.cat([ev, v], dim=-1) + scale = 1 / math.sqrt(math.sqrt(ch)) + weight = th.einsum("bct,bcs->bts", q * scale, k * scale) + if mask is not None: + mask = F.pad(mask, (0, length), value=0.0) + mask = ( + mask.unsqueeze(1) + .expand(-1, self.n_heads, -1) + .reshape(bs * self.n_heads, 1, -1) + ) + weight = weight + mask + weight = th.softmax(weight, dim=-1) + a = th.einsum("bts,bcs->bct", weight, v) + return a.reshape(bs, -1, length) + + +class UNetModel(nn.Module): + """ + The full UNet model with attention and timestep embedding. + + :param in_channels: channels in the input Tensor. + :param model_channels: base channel count for the model. + :param out_channels: channels in the output Tensor. + :param num_res_blocks: number of residual blocks per downsample. + :param attention_resolutions: a collection of downsample rates at which + attention will take place. May be a set, list, or tuple. + For example, if this contains 4, then at 4x downsampling, attention + will be used. + :param dropout: the dropout probability. + :param channel_mult: channel multiplier for each level of the UNet. + :param conv_resample: if True, use learned convolutions for upsampling and + downsampling. + :param dims: determines if the signal is 1D, 2D, or 3D. + :param clip_dim: dimension of clip feature. + :param num_classes: if specified (as an int), then this model will be + class-conditional with `num_classes` classes. + :param use_checkpoint: use gradient checkpointing to reduce memory usage. + :param num_heads: the number of attention heads in each attention layer. + :param num_heads_channels: if specified, ignore num_heads and instead use + a fixed channel width per attention head. + :param num_heads_upsample: works with num_heads to set a different number + of heads for upsampling. Deprecated. + :param use_scale_shift_norm: use a FiLM-like conditioning mechanism. + :param resblock_updown: use residual blocks for up/downsampling. + :param encoder_channels: use to make the dimension of query and kv same in AttentionBlock. + :param use_time_embedding: use time embedding for condition. + """ + + def __init__( + self, + in_channels, + model_channels, + out_channels, + num_res_blocks, + attention_resolutions, + dropout=0, + channel_mult=(1, 2, 4, 8), + conv_resample=True, + dims=2, + clip_dim=None, + use_checkpoint=False, + num_heads=1, + num_head_channels=-1, + num_heads_upsample=-1, + use_scale_shift_norm=False, + use_middle_attention=True, + resblock_updown=False, + encoder_channels=None, + use_time_embedding=True, + ): + super().__init__() + + if num_heads_upsample == -1: + num_heads_upsample = num_heads + + self.in_channels = in_channels + self.model_channels = model_channels + self.out_channels = out_channels + self.num_res_blocks = num_res_blocks + self.attention_resolutions = attention_resolutions + self.dropout = dropout + self.channel_mult = channel_mult + self.conv_resample = conv_resample + self.clip_dim = clip_dim + self.use_checkpoint = use_checkpoint + self.num_heads = num_heads + self.num_head_channels = num_head_channels + self.num_heads_upsample = num_heads_upsample + self.use_middle_attention = use_middle_attention + self.use_time_embedding = use_time_embedding + + if self.use_time_embedding: + time_embed_dim = model_channels * 4 + self.time_embed = nn.Sequential( + linear(model_channels, time_embed_dim), + nn.SiLU(), + linear(time_embed_dim, time_embed_dim), + ) + + if self.clip_dim is not None: + self.clip_emb = nn.Linear(clip_dim, time_embed_dim) + else: + time_embed_dim = None + + CustomResidualBlock = ( + ResBlock if self.use_time_embedding else ResBlockNoTimeEmbedding + ) + ch = input_ch = int(channel_mult[0] * model_channels) + self.input_blocks = nn.ModuleList( + [TimestepEmbedSequential(conv_nd(dims, in_channels, ch, 3, padding=1))] + ) + self._feature_size = ch + input_block_chans = [ch] + ds = 1 + for level, mult in enumerate(channel_mult): + for _ in range(num_res_blocks): + layers = [ + CustomResidualBlock( + ch, + time_embed_dim, + dropout, + out_channels=int(mult * model_channels), + dims=dims, + use_checkpoint=use_checkpoint, + use_scale_shift_norm=use_scale_shift_norm, + ) + ] + ch = int(mult * model_channels) + if ds in attention_resolutions: + layers.append( + AttentionBlock( + ch, + use_checkpoint=use_checkpoint, + num_heads=num_heads, + num_head_channels=num_head_channels, + encoder_channels=encoder_channels, + ) + ) + self.input_blocks.append(TimestepEmbedSequential(*layers)) + self._feature_size += ch + input_block_chans.append(ch) + if level != len(channel_mult) - 1: + out_ch = ch + self.input_blocks.append( + TimestepEmbedSequential( + CustomResidualBlock( + ch, + time_embed_dim, + dropout, + out_channels=out_ch, + dims=dims, + use_checkpoint=use_checkpoint, + use_scale_shift_norm=use_scale_shift_norm, + down=True, + ) + if resblock_updown + else Downsample( + ch, conv_resample, dims=dims, out_channels=out_ch + ) + ) + ) + ch = out_ch + input_block_chans.append(ch) + ds *= 2 + self._feature_size += ch + + self.middle_block = TimestepEmbedSequential( + CustomResidualBlock( + ch, + time_embed_dim, + dropout, + dims=dims, + use_checkpoint=use_checkpoint, + use_scale_shift_norm=use_scale_shift_norm, + ), + *( + AttentionBlock( + ch, + use_checkpoint=use_checkpoint, + num_heads=num_heads, + num_head_channels=num_head_channels, + encoder_channels=encoder_channels, + ), + ) + if self.use_middle_attention + else tuple(), # add AttentionBlock or not + CustomResidualBlock( + ch, + time_embed_dim, + dropout, + dims=dims, + use_checkpoint=use_checkpoint, + use_scale_shift_norm=use_scale_shift_norm, + ), + ) + self._feature_size += ch + + self.output_blocks = nn.ModuleList([]) + for level, mult in list(enumerate(channel_mult))[::-1]: + for i in range(num_res_blocks + 1): + ich = input_block_chans.pop() + layers = [ + CustomResidualBlock( + ch + ich, + time_embed_dim, + dropout, + out_channels=int(model_channels * mult), + dims=dims, + use_checkpoint=use_checkpoint, + use_scale_shift_norm=use_scale_shift_norm, + ) + ] + ch = int(model_channels * mult) + if ds in attention_resolutions: + layers.append( + AttentionBlock( + ch, + use_checkpoint=use_checkpoint, + num_heads=num_heads_upsample, + num_head_channels=num_head_channels, + encoder_channels=encoder_channels, + ) + ) + if level and i == num_res_blocks: + out_ch = ch + layers.append( + CustomResidualBlock( + ch, + time_embed_dim, + dropout, + out_channels=out_ch, + dims=dims, + use_checkpoint=use_checkpoint, + use_scale_shift_norm=use_scale_shift_norm, + up=True, + ) + if resblock_updown + else Upsample(ch, conv_resample, dims=dims, out_channels=out_ch) + ) + ds //= 2 + self.output_blocks.append(TimestepEmbedSequential(*layers)) + self._feature_size += ch + + self.out = nn.Sequential( + normalization(ch, swish=1.0), + nn.Identity(), + zero_module(conv_nd(dims, input_ch, out_channels, 3, padding=1)), + ) + + def forward(self, x, timesteps, y=None): + """ + Apply the model to an input batch. + + :param x: an [N x C x ...] Tensor of inputs. + :param timesteps: a 1-D batch of timesteps. + :param y: an [N] Tensor of labels, if class-conditional. + :return: an [N x C x ...] Tensor of outputs. + """ + assert (y is not None) == ( + self.clip_dim is not None + ), "must specify y if and only if the model is clip-rep-conditional" + + hs = [] + if self.use_time_embedding: + emb = self.time_embed(timestep_embedding(timesteps, self.model_channels)) + if self.clip_dim is not None: + emb = emb + self.clip_emb(y) + else: + emb = None + + h = x + for module in self.input_blocks: + h = module(h, emb) + hs.append(h) + h = self.middle_block(h, emb) + for module in self.output_blocks: + h = th.cat([h, hs.pop()], dim=1) + h = module(h, emb) + + return self.out(h) + + +class SuperResUNetModel(UNetModel): + """ + A UNetModel that performs super-resolution. + + Expects an extra kwarg `low_res` to condition on a low-resolution image. + Assumes that the shape of low-resolution and the input should be the same. + """ + + def __init__(self, *args, **kwargs): + if "in_channels" in kwargs: + kwargs = dict(kwargs) + kwargs["in_channels"] = kwargs["in_channels"] * 2 + else: + # Curse you, Python. Or really, just curse positional arguments :|. + args = list(args) + args[1] = args[1] * 2 + super().__init__(*args, **kwargs) + + def forward(self, x, timesteps, low_res=None, **kwargs): + _, _, new_height, new_width = x.shape + assert new_height == low_res.shape[2] and new_width == low_res.shape[3] + + x = th.cat([x, low_res], dim=1) + return super().forward(x, timesteps, **kwargs) + + +class PLMImUNet(UNetModel): + """ + A UNetModel that conditions on text with a pretrained text encoder in CLIP. + + :param text_ctx: number of text tokens to expect. + :param xf_width: width of the transformer. + :param clip_emb_mult: #extra tokens by projecting clip text feature. + :param clip_emb_type: type of condition (here, we fix clip image feature). + :param clip_emb_drop: dropout rato of clip image feature for cfg. + """ + + def __init__( + self, + text_ctx, + xf_width, + *args, + clip_emb_mult=None, + clip_emb_type="image", + clip_emb_drop=0.0, + **kwargs, + ): + self.text_ctx = text_ctx + self.xf_width = xf_width + self.clip_emb_mult = clip_emb_mult + self.clip_emb_type = clip_emb_type + self.clip_emb_drop = clip_emb_drop + + if not xf_width: + super().__init__(*args, **kwargs, encoder_channels=None) + else: + super().__init__(*args, **kwargs, encoder_channels=xf_width) + + # Project text encoded feat seq from pre-trained text encoder in CLIP + self.text_seq_proj = nn.Sequential( + nn.Linear(self.clip_dim, xf_width), + LayerNorm(xf_width), + ) + # Project CLIP text feat + self.text_feat_proj = nn.Linear(self.clip_dim, self.model_channels * 4) + + assert clip_emb_mult is not None + assert clip_emb_type == "image" + assert self.clip_dim is not None, "CLIP representation dim should be specified" + + self.clip_tok_proj = nn.Linear( + self.clip_dim, self.xf_width * self.clip_emb_mult + ) + if self.clip_emb_drop > 0: + self.cf_param = nn.Parameter(th.empty(self.clip_dim, dtype=th.float32)) + + def proc_clip_emb_drop(self, feat): + if self.clip_emb_drop > 0: + bsz, feat_dim = feat.shape + assert ( + feat_dim == self.clip_dim + ), f"CLIP input dim: {feat_dim}, model CLIP dim: {self.clip_dim}" + drop_idx = th.rand((bsz,), device=feat.device) < self.clip_emb_drop + feat = th.where( + drop_idx[..., None], self.cf_param[None].type_as(feat), feat + ) + return feat + + def forward( + self, x, timesteps, txt_feat=None, txt_feat_seq=None, mask=None, y=None + ): + bsz = x.shape[0] + hs = [] + emb = self.time_embed(timestep_embedding(timesteps, self.model_channels)) + emb = emb + self.clip_emb(y) + + xf_out = self.text_seq_proj(txt_feat_seq) + xf_out = xf_out.permute(0, 2, 1) + emb = emb + self.text_feat_proj(txt_feat) + xf_out = th.cat( + [ + self.clip_tok_proj(y).reshape(bsz, -1, self.clip_emb_mult), + xf_out, + ], + dim=2, + ) + mask = F.pad(mask, (self.clip_emb_mult, 0), value=True) + mask = th.where(mask, 0.0, float("-inf")) + + h = x + for module in self.input_blocks: + h = module(h, emb, xf_out, mask=mask) + hs.append(h) + h = self.middle_block(h, emb, xf_out, mask=mask) + for module in self.output_blocks: + h = th.cat([h, hs.pop()], dim=1) + h = module(h, emb, xf_out, mask=mask) + h = self.out(h) + + return h diff --git a/ldm/modules/karlo/kakao/modules/xf.py b/ldm/modules/karlo/kakao/modules/xf.py new file mode 100644 index 0000000000000000000000000000000000000000..66d7d4a2f3fd9fec420ac8272ae00b96c634a3a9 --- /dev/null +++ b/ldm/modules/karlo/kakao/modules/xf.py @@ -0,0 +1,231 @@ +# ------------------------------------------------------------------------------------ +# Adapted from the repos below: +# (a) Guided-Diffusion (https://github.com/openai/guided-diffusion) +# (b) CLIP ViT (https://github.com/openai/CLIP/) +# ------------------------------------------------------------------------------------ + +import math + +import torch as th +import torch.nn as nn +import torch.nn.functional as F + +from .nn import timestep_embedding + + +def convert_module_to_f16(param): + """ + Convert primitive modules to float16. + """ + if isinstance(param, (nn.Linear, nn.Conv2d, nn.ConvTranspose2d)): + param.weight.data = param.weight.data.half() + if param.bias is not None: + param.bias.data = param.bias.data.half() + + +class LayerNorm(nn.LayerNorm): + """ + Implementation that supports fp16 inputs but fp32 gains/biases. + """ + + def forward(self, x: th.Tensor): + return super().forward(x.float()).to(x.dtype) + + +class MultiheadAttention(nn.Module): + def __init__(self, n_ctx, width, heads): + super().__init__() + self.n_ctx = n_ctx + self.width = width + self.heads = heads + self.c_qkv = nn.Linear(width, width * 3) + self.c_proj = nn.Linear(width, width) + self.attention = QKVMultiheadAttention(heads, n_ctx) + + def forward(self, x, mask=None): + x = self.c_qkv(x) + x = self.attention(x, mask=mask) + x = self.c_proj(x) + return x + + +class MLP(nn.Module): + def __init__(self, width): + super().__init__() + self.width = width + self.c_fc = nn.Linear(width, width * 4) + self.c_proj = nn.Linear(width * 4, width) + self.gelu = nn.GELU() + + def forward(self, x): + return self.c_proj(self.gelu(self.c_fc(x))) + + +class QKVMultiheadAttention(nn.Module): + def __init__(self, n_heads: int, n_ctx: int): + super().__init__() + self.n_heads = n_heads + self.n_ctx = n_ctx + + def forward(self, qkv, mask=None): + bs, n_ctx, width = qkv.shape + attn_ch = width // self.n_heads // 3 + scale = 1 / math.sqrt(math.sqrt(attn_ch)) + qkv = qkv.view(bs, n_ctx, self.n_heads, -1) + q, k, v = th.split(qkv, attn_ch, dim=-1) + weight = th.einsum("bthc,bshc->bhts", q * scale, k * scale) + wdtype = weight.dtype + if mask is not None: + weight = weight + mask[:, None, ...] + weight = th.softmax(weight, dim=-1).type(wdtype) + return th.einsum("bhts,bshc->bthc", weight, v).reshape(bs, n_ctx, -1) + + +class ResidualAttentionBlock(nn.Module): + def __init__( + self, + n_ctx: int, + width: int, + heads: int, + ): + super().__init__() + + self.attn = MultiheadAttention( + n_ctx, + width, + heads, + ) + self.ln_1 = LayerNorm(width) + self.mlp = MLP(width) + self.ln_2 = LayerNorm(width) + + def forward(self, x, mask=None): + x = x + self.attn(self.ln_1(x), mask=mask) + x = x + self.mlp(self.ln_2(x)) + return x + + +class Transformer(nn.Module): + def __init__( + self, + n_ctx: int, + width: int, + layers: int, + heads: int, + ): + super().__init__() + self.n_ctx = n_ctx + self.width = width + self.layers = layers + self.resblocks = nn.ModuleList( + [ + ResidualAttentionBlock( + n_ctx, + width, + heads, + ) + for _ in range(layers) + ] + ) + + def forward(self, x, mask=None): + for block in self.resblocks: + x = block(x, mask=mask) + return x + + +class PriorTransformer(nn.Module): + """ + A Causal Transformer that conditions on CLIP text embedding, text. + + :param text_ctx: number of text tokens to expect. + :param xf_width: width of the transformer. + :param xf_layers: depth of the transformer. + :param xf_heads: heads in the transformer. + :param xf_final_ln: use a LayerNorm after the output layer. + :param clip_dim: dimension of clip feature. + """ + + def __init__( + self, + text_ctx, + xf_width, + xf_layers, + xf_heads, + xf_final_ln, + clip_dim, + ): + super().__init__() + + self.text_ctx = text_ctx + self.xf_width = xf_width + self.xf_layers = xf_layers + self.xf_heads = xf_heads + self.clip_dim = clip_dim + self.ext_len = 4 + + self.time_embed = nn.Sequential( + nn.Linear(xf_width, xf_width), + nn.SiLU(), + nn.Linear(xf_width, xf_width), + ) + self.text_enc_proj = nn.Linear(clip_dim, xf_width) + self.text_emb_proj = nn.Linear(clip_dim, xf_width) + self.clip_img_proj = nn.Linear(clip_dim, xf_width) + self.out_proj = nn.Linear(xf_width, clip_dim) + self.transformer = Transformer( + text_ctx + self.ext_len, + xf_width, + xf_layers, + xf_heads, + ) + if xf_final_ln: + self.final_ln = LayerNorm(xf_width) + else: + self.final_ln = None + + self.positional_embedding = nn.Parameter( + th.empty(1, text_ctx + self.ext_len, xf_width) + ) + self.prd_emb = nn.Parameter(th.randn((1, 1, xf_width))) + + nn.init.normal_(self.prd_emb, std=0.01) + nn.init.normal_(self.positional_embedding, std=0.01) + + def forward( + self, + x, + timesteps, + text_emb=None, + text_enc=None, + mask=None, + causal_mask=None, + ): + bsz = x.shape[0] + mask = F.pad(mask, (0, self.ext_len), value=True) + + t_emb = self.time_embed(timestep_embedding(timesteps, self.xf_width)) + text_enc = self.text_enc_proj(text_enc) + text_emb = self.text_emb_proj(text_emb) + x = self.clip_img_proj(x) + + input_seq = [ + text_enc, + text_emb[:, None, :], + t_emb[:, None, :], + x[:, None, :], + self.prd_emb.to(x.dtype).expand(bsz, -1, -1), + ] + input = th.cat(input_seq, dim=1) + input = input + self.positional_embedding.to(input.dtype) + + mask = th.where(mask, 0.0, float("-inf")) + mask = (mask[:, None, :] + causal_mask).to(input.dtype) + + out = self.transformer(input, mask=mask) + if self.final_ln is not None: + out = self.final_ln(out) + + out = self.out_proj(out[:, -1]) + + return out diff --git a/ldm/modules/karlo/kakao/sampler.py b/ldm/modules/karlo/kakao/sampler.py new file mode 100644 index 0000000000000000000000000000000000000000..b56bf2f20c280d735a2be10af03d7cd3e7bf85ac --- /dev/null +++ b/ldm/modules/karlo/kakao/sampler.py @@ -0,0 +1,272 @@ +# ------------------------------------------------------------------------------------ +# Karlo-v1.0.alpha +# Copyright (c) 2022 KakaoBrain. All Rights Reserved. + +# source: https://github.com/kakaobrain/karlo/blob/3c68a50a16d76b48a15c181d1c5a5e0879a90f85/karlo/sampler/t2i.py#L15 +# ------------------------------------------------------------------------------------ + +from typing import Iterator + +import torch +import torchvision.transforms.functional as TVF +from torchvision.transforms import InterpolationMode + +from .template import BaseSampler, CKPT_PATH + + +class T2ISampler(BaseSampler): + """ + A sampler for text-to-image generation. + :param root_dir: directory for model checkpoints. + :param sampling_type: ["default", "fast"] + """ + + def __init__( + self, + root_dir: str, + sampling_type: str = "default", + ): + super().__init__(root_dir, sampling_type) + + @classmethod + def from_pretrained( + cls, + root_dir: str, + clip_model_path: str, + clip_stat_path: str, + sampling_type: str = "default", + ): + + model = cls( + root_dir=root_dir, + sampling_type=sampling_type, + ) + model.load_clip(clip_model_path) + model.load_prior( + f"{CKPT_PATH['prior']}", + clip_stat_path=clip_stat_path, + prior_config="configs/karlo/prior_1B_vit_l.yaml" + ) + model.load_decoder(f"{CKPT_PATH['decoder']}", decoder_config="configs/karlo/decoder_900M_vit_l.yaml") + model.load_sr_64_256(CKPT_PATH["sr_256"], sr_config="configs/karlo/improved_sr_64_256_1.4B.yaml") + return model + + def preprocess( + self, + prompt: str, + bsz: int, + ): + """Setup prompts & cfg scales""" + prompts_batch = [prompt for _ in range(bsz)] + + prior_cf_scales_batch = [self._prior_cf_scale] * len(prompts_batch) + prior_cf_scales_batch = torch.tensor(prior_cf_scales_batch, device="cuda") + + decoder_cf_scales_batch = [self._decoder_cf_scale] * len(prompts_batch) + decoder_cf_scales_batch = torch.tensor(decoder_cf_scales_batch, device="cuda") + + """ Get CLIP text feature """ + clip_model = self._clip + tokenizer = self._tokenizer + max_txt_length = self._prior.model.text_ctx + + tok, mask = tokenizer.padded_tokens_and_mask(prompts_batch, max_txt_length) + cf_token, cf_mask = tokenizer.padded_tokens_and_mask([""], max_txt_length) + if not (cf_token.shape == tok.shape): + cf_token = cf_token.expand(tok.shape[0], -1) + cf_mask = cf_mask.expand(tok.shape[0], -1) + + tok = torch.cat([tok, cf_token], dim=0) + mask = torch.cat([mask, cf_mask], dim=0) + + tok, mask = tok.to(device="cuda"), mask.to(device="cuda") + txt_feat, txt_feat_seq = clip_model.encode_text(tok) + + return ( + prompts_batch, + prior_cf_scales_batch, + decoder_cf_scales_batch, + txt_feat, + txt_feat_seq, + tok, + mask, + ) + + def __call__( + self, + prompt: str, + bsz: int, + progressive_mode=None, + ) -> Iterator[torch.Tensor]: + assert progressive_mode in ("loop", "stage", "final") + with torch.no_grad(), torch.cuda.amp.autocast(): + ( + prompts_batch, + prior_cf_scales_batch, + decoder_cf_scales_batch, + txt_feat, + txt_feat_seq, + tok, + mask, + ) = self.preprocess( + prompt, + bsz, + ) + + """ Transform CLIP text feature into image feature """ + img_feat = self._prior( + txt_feat, + txt_feat_seq, + mask, + prior_cf_scales_batch, + timestep_respacing=self._prior_sm, + ) + + """ Generate 64x64px images """ + images_64_outputs = self._decoder( + txt_feat, + txt_feat_seq, + tok, + mask, + img_feat, + cf_guidance_scales=decoder_cf_scales_batch, + timestep_respacing=self._decoder_sm, + ) + + images_64 = None + for k, out in enumerate(images_64_outputs): + images_64 = out + if progressive_mode == "loop": + yield torch.clamp(out * 0.5 + 0.5, 0.0, 1.0) + if progressive_mode == "stage": + yield torch.clamp(out * 0.5 + 0.5, 0.0, 1.0) + + images_64 = torch.clamp(images_64, -1, 1) + + """ Upsample 64x64 to 256x256 """ + images_256 = TVF.resize( + images_64, + [256, 256], + interpolation=InterpolationMode.BICUBIC, + antialias=True, + ) + images_256_outputs = self._sr_64_256( + images_256, timestep_respacing=self._sr_sm + ) + + for k, out in enumerate(images_256_outputs): + images_256 = out + if progressive_mode == "loop": + yield torch.clamp(out * 0.5 + 0.5, 0.0, 1.0) + if progressive_mode == "stage": + yield torch.clamp(out * 0.5 + 0.5, 0.0, 1.0) + + yield torch.clamp(images_256 * 0.5 + 0.5, 0.0, 1.0) + + +class PriorSampler(BaseSampler): + """ + A sampler for text-to-image generation, but only the prior. + :param root_dir: directory for model checkpoints. + :param sampling_type: ["default", "fast"] + """ + + def __init__( + self, + root_dir: str, + sampling_type: str = "default", + ): + super().__init__(root_dir, sampling_type) + + @classmethod + def from_pretrained( + cls, + root_dir: str, + clip_model_path: str, + clip_stat_path: str, + sampling_type: str = "default", + ): + model = cls( + root_dir=root_dir, + sampling_type=sampling_type, + ) + model.load_clip(clip_model_path) + model.load_prior( + f"{CKPT_PATH['prior']}", + clip_stat_path=clip_stat_path, + prior_config="configs/karlo/prior_1B_vit_l.yaml" + ) + return model + + def preprocess( + self, + prompt: str, + bsz: int, + ): + """Setup prompts & cfg scales""" + prompts_batch = [prompt for _ in range(bsz)] + + prior_cf_scales_batch = [self._prior_cf_scale] * len(prompts_batch) + prior_cf_scales_batch = torch.tensor(prior_cf_scales_batch, device="cuda") + + decoder_cf_scales_batch = [self._decoder_cf_scale] * len(prompts_batch) + decoder_cf_scales_batch = torch.tensor(decoder_cf_scales_batch, device="cuda") + + """ Get CLIP text feature """ + clip_model = self._clip + tokenizer = self._tokenizer + max_txt_length = self._prior.model.text_ctx + + tok, mask = tokenizer.padded_tokens_and_mask(prompts_batch, max_txt_length) + cf_token, cf_mask = tokenizer.padded_tokens_and_mask([""], max_txt_length) + if not (cf_token.shape == tok.shape): + cf_token = cf_token.expand(tok.shape[0], -1) + cf_mask = cf_mask.expand(tok.shape[0], -1) + + tok = torch.cat([tok, cf_token], dim=0) + mask = torch.cat([mask, cf_mask], dim=0) + + tok, mask = tok.to(device="cuda"), mask.to(device="cuda") + txt_feat, txt_feat_seq = clip_model.encode_text(tok) + + return ( + prompts_batch, + prior_cf_scales_batch, + decoder_cf_scales_batch, + txt_feat, + txt_feat_seq, + tok, + mask, + ) + + def __call__( + self, + prompt: str, + bsz: int, + progressive_mode=None, + ) -> Iterator[torch.Tensor]: + assert progressive_mode in ("loop", "stage", "final") + with torch.no_grad(), torch.cuda.amp.autocast(): + ( + prompts_batch, + prior_cf_scales_batch, + decoder_cf_scales_batch, + txt_feat, + txt_feat_seq, + tok, + mask, + ) = self.preprocess( + prompt, + bsz, + ) + + """ Transform CLIP text feature into image feature """ + img_feat = self._prior( + txt_feat, + txt_feat_seq, + mask, + prior_cf_scales_batch, + timestep_respacing=self._prior_sm, + ) + + yield img_feat diff --git a/ldm/modules/karlo/kakao/template.py b/ldm/modules/karlo/kakao/template.py new file mode 100644 index 0000000000000000000000000000000000000000..949e80e67b6a8a7c7bbd2c7baad5ec8c8c7e2fdf --- /dev/null +++ b/ldm/modules/karlo/kakao/template.py @@ -0,0 +1,141 @@ +# ------------------------------------------------------------------------------------ +# Karlo-v1.0.alpha +# Copyright (c) 2022 KakaoBrain. All Rights Reserved. +# ------------------------------------------------------------------------------------ + +import os +import logging +import torch + +from omegaconf import OmegaConf + +from ldm.modules.karlo.kakao.models.clip import CustomizedCLIP, CustomizedTokenizer +from ldm.modules.karlo.kakao.models.prior_model import PriorDiffusionModel +from ldm.modules.karlo.kakao.models.decoder_model import Text2ImProgressiveModel +from ldm.modules.karlo.kakao.models.sr_64_256 import ImprovedSupRes64to256ProgressiveModel + + +SAMPLING_CONF = { + "default": { + "prior_sm": "25", + "prior_n_samples": 1, + "prior_cf_scale": 4.0, + "decoder_sm": "50", + "decoder_cf_scale": 8.0, + "sr_sm": "7", + }, + "fast": { + "prior_sm": "25", + "prior_n_samples": 1, + "prior_cf_scale": 4.0, + "decoder_sm": "25", + "decoder_cf_scale": 8.0, + "sr_sm": "7", + }, +} + +CKPT_PATH = { + "prior": "prior-ckpt-step=01000000-of-01000000.ckpt", + "decoder": "decoder-ckpt-step=01000000-of-01000000.ckpt", + "sr_256": "improved-sr-ckpt-step=1.2M.ckpt", +} + + +class BaseSampler: + _PRIOR_CLASS = PriorDiffusionModel + _DECODER_CLASS = Text2ImProgressiveModel + _SR256_CLASS = ImprovedSupRes64to256ProgressiveModel + + def __init__( + self, + root_dir: str, + sampling_type: str = "fast", + ): + self._root_dir = root_dir + + sampling_type = SAMPLING_CONF[sampling_type] + self._prior_sm = sampling_type["prior_sm"] + self._prior_n_samples = sampling_type["prior_n_samples"] + self._prior_cf_scale = sampling_type["prior_cf_scale"] + + assert self._prior_n_samples == 1 + + self._decoder_sm = sampling_type["decoder_sm"] + self._decoder_cf_scale = sampling_type["decoder_cf_scale"] + + self._sr_sm = sampling_type["sr_sm"] + + def __repr__(self): + line = "" + line += f"Prior, sampling method: {self._prior_sm}, cf_scale: {self._prior_cf_scale}\n" + line += f"Decoder, sampling method: {self._decoder_sm}, cf_scale: {self._decoder_cf_scale}\n" + line += f"SR(64->256), sampling method: {self._sr_sm}" + + return line + + def load_clip(self, clip_path: str): + clip = CustomizedCLIP.load_from_checkpoint( + os.path.join(self._root_dir, clip_path) + ) + clip = torch.jit.script(clip) + clip.cuda() + clip.eval() + + self._clip = clip + self._tokenizer = CustomizedTokenizer() + + def load_prior( + self, + ckpt_path: str, + clip_stat_path: str, + prior_config: str = "configs/prior_1B_vit_l.yaml" + ): + logging.info(f"Loading prior: {ckpt_path}") + + config = OmegaConf.load(prior_config) + clip_mean, clip_std = torch.load( + os.path.join(self._root_dir, clip_stat_path), map_location="cpu" + ) + + prior = self._PRIOR_CLASS.load_from_checkpoint( + config, + self._tokenizer, + clip_mean, + clip_std, + os.path.join(self._root_dir, ckpt_path), + strict=True, + ) + prior.cuda() + prior.eval() + logging.info("done.") + + self._prior = prior + + def load_decoder(self, ckpt_path: str, decoder_config: str = "configs/decoder_900M_vit_l.yaml"): + logging.info(f"Loading decoder: {ckpt_path}") + + config = OmegaConf.load(decoder_config) + decoder = self._DECODER_CLASS.load_from_checkpoint( + config, + self._tokenizer, + os.path.join(self._root_dir, ckpt_path), + strict=True, + ) + decoder.cuda() + decoder.eval() + logging.info("done.") + + self._decoder = decoder + + def load_sr_64_256(self, ckpt_path: str, sr_config: str = "configs/improved_sr_64_256_1.4B.yaml"): + logging.info(f"Loading SR(64->256): {ckpt_path}") + + config = OmegaConf.load(sr_config) + sr = self._SR256_CLASS.load_from_checkpoint( + config, os.path.join(self._root_dir, ckpt_path), strict=True + ) + sr.cuda() + sr.eval() + logging.info("done.") + + self._sr_64_256 = sr \ No newline at end of file diff --git a/ldm/modules/midas/__init__.py b/ldm/modules/midas/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/ldm/modules/midas/api.py b/ldm/modules/midas/api.py new file mode 100644 index 0000000000000000000000000000000000000000..b58ebbffd942a2fc22264f0ab47e400c26b9f41c --- /dev/null +++ b/ldm/modules/midas/api.py @@ -0,0 +1,170 @@ +# based on https://github.com/isl-org/MiDaS + +import cv2 +import torch +import torch.nn as nn +from torchvision.transforms import Compose + +from ldm.modules.midas.midas.dpt_depth import DPTDepthModel +from ldm.modules.midas.midas.midas_net import MidasNet +from ldm.modules.midas.midas.midas_net_custom import MidasNet_small +from ldm.modules.midas.midas.transforms import Resize, NormalizeImage, PrepareForNet + + +ISL_PATHS = { + "dpt_large": "midas_models/dpt_large-midas-2f21e586.pt", + "dpt_hybrid": "midas_models/dpt_hybrid-midas-501f0c75.pt", + "midas_v21": "", + "midas_v21_small": "", +} + + +def disabled_train(self, mode=True): + """Overwrite model.train with this function to make sure train/eval mode + does not change anymore.""" + return self + + +def load_midas_transform(model_type): + # https://github.com/isl-org/MiDaS/blob/master/run.py + # load transform only + if model_type == "dpt_large": # DPT-Large + net_w, net_h = 384, 384 + resize_mode = "minimal" + normalization = NormalizeImage(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]) + + elif model_type == "dpt_hybrid": # DPT-Hybrid + net_w, net_h = 384, 384 + resize_mode = "minimal" + normalization = NormalizeImage(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]) + + elif model_type == "midas_v21": + net_w, net_h = 384, 384 + resize_mode = "upper_bound" + normalization = NormalizeImage(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) + + elif model_type == "midas_v21_small": + net_w, net_h = 256, 256 + resize_mode = "upper_bound" + normalization = NormalizeImage(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) + + else: + assert False, f"model_type '{model_type}' not implemented, use: --model_type large" + + transform = Compose( + [ + Resize( + net_w, + net_h, + resize_target=None, + keep_aspect_ratio=True, + ensure_multiple_of=32, + resize_method=resize_mode, + image_interpolation_method=cv2.INTER_CUBIC, + ), + normalization, + PrepareForNet(), + ] + ) + + return transform + + +def load_model(model_type): + # https://github.com/isl-org/MiDaS/blob/master/run.py + # load network + model_path = ISL_PATHS[model_type] + if model_type == "dpt_large": # DPT-Large + model = DPTDepthModel( + path=model_path, + backbone="vitl16_384", + non_negative=True, + ) + net_w, net_h = 384, 384 + resize_mode = "minimal" + normalization = NormalizeImage(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]) + + elif model_type == "dpt_hybrid": # DPT-Hybrid + model = DPTDepthModel( + path=model_path, + backbone="vitb_rn50_384", + non_negative=True, + ) + net_w, net_h = 384, 384 + resize_mode = "minimal" + normalization = NormalizeImage(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]) + + elif model_type == "midas_v21": + model = MidasNet(model_path, non_negative=True) + net_w, net_h = 384, 384 + resize_mode = "upper_bound" + normalization = NormalizeImage( + mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225] + ) + + elif model_type == "midas_v21_small": + model = MidasNet_small(model_path, features=64, backbone="efficientnet_lite3", exportable=True, + non_negative=True, blocks={'expand': True}) + net_w, net_h = 256, 256 + resize_mode = "upper_bound" + normalization = NormalizeImage( + mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225] + ) + + else: + print(f"model_type '{model_type}' not implemented, use: --model_type large") + assert False + + transform = Compose( + [ + Resize( + net_w, + net_h, + resize_target=None, + keep_aspect_ratio=True, + ensure_multiple_of=32, + resize_method=resize_mode, + image_interpolation_method=cv2.INTER_CUBIC, + ), + normalization, + PrepareForNet(), + ] + ) + + return model.eval(), transform + + +class MiDaSInference(nn.Module): + MODEL_TYPES_TORCH_HUB = [ + "DPT_Large", + "DPT_Hybrid", + "MiDaS_small" + ] + MODEL_TYPES_ISL = [ + "dpt_large", + "dpt_hybrid", + "midas_v21", + "midas_v21_small", + ] + + def __init__(self, model_type): + super().__init__() + assert (model_type in self.MODEL_TYPES_ISL) + model, _ = load_model(model_type) + self.model = model + self.model.train = disabled_train + + def forward(self, x): + # x in 0..1 as produced by calling self.transform on a 0..1 float64 numpy array + # NOTE: we expect that the correct transform has been called during dataloading. + with torch.no_grad(): + prediction = self.model(x) + prediction = torch.nn.functional.interpolate( + prediction.unsqueeze(1), + size=x.shape[2:], + mode="bicubic", + align_corners=False, + ) + assert prediction.shape == (x.shape[0], 1, x.shape[2], x.shape[3]) + return prediction + diff --git a/ldm/modules/midas/midas/__init__.py b/ldm/modules/midas/midas/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/ldm/modules/midas/midas/base_model.py b/ldm/modules/midas/midas/base_model.py new file mode 100644 index 0000000000000000000000000000000000000000..5cf430239b47ec5ec07531263f26f5c24a2311cd --- /dev/null +++ b/ldm/modules/midas/midas/base_model.py @@ -0,0 +1,16 @@ +import torch + + +class BaseModel(torch.nn.Module): + def load(self, path): + """Load model from file. + + Args: + path (str): file path + """ + parameters = torch.load(path, map_location=torch.device('cpu')) + + if "optimizer" in parameters: + parameters = parameters["model"] + + self.load_state_dict(parameters) diff --git a/ldm/modules/midas/midas/blocks.py b/ldm/modules/midas/midas/blocks.py new file mode 100644 index 0000000000000000000000000000000000000000..2145d18fa98060a618536d9a64fe6589e9be4f78 --- /dev/null +++ b/ldm/modules/midas/midas/blocks.py @@ -0,0 +1,342 @@ +import torch +import torch.nn as nn + +from .vit import ( + _make_pretrained_vitb_rn50_384, + _make_pretrained_vitl16_384, + _make_pretrained_vitb16_384, + forward_vit, +) + +def _make_encoder(backbone, features, use_pretrained, groups=1, expand=False, exportable=True, hooks=None, use_vit_only=False, use_readout="ignore",): + if backbone == "vitl16_384": + pretrained = _make_pretrained_vitl16_384( + use_pretrained, hooks=hooks, use_readout=use_readout + ) + scratch = _make_scratch( + [256, 512, 1024, 1024], features, groups=groups, expand=expand + ) # ViT-L/16 - 85.0% Top1 (backbone) + elif backbone == "vitb_rn50_384": + pretrained = _make_pretrained_vitb_rn50_384( + use_pretrained, + hooks=hooks, + use_vit_only=use_vit_only, + use_readout=use_readout, + ) + scratch = _make_scratch( + [256, 512, 768, 768], features, groups=groups, expand=expand + ) # ViT-H/16 - 85.0% Top1 (backbone) + elif backbone == "vitb16_384": + pretrained = _make_pretrained_vitb16_384( + use_pretrained, hooks=hooks, use_readout=use_readout + ) + scratch = _make_scratch( + [96, 192, 384, 768], features, groups=groups, expand=expand + ) # ViT-B/16 - 84.6% Top1 (backbone) + elif backbone == "resnext101_wsl": + pretrained = _make_pretrained_resnext101_wsl(use_pretrained) + scratch = _make_scratch([256, 512, 1024, 2048], features, groups=groups, expand=expand) # efficientnet_lite3 + elif backbone == "efficientnet_lite3": + pretrained = _make_pretrained_efficientnet_lite3(use_pretrained, exportable=exportable) + scratch = _make_scratch([32, 48, 136, 384], features, groups=groups, expand=expand) # efficientnet_lite3 + else: + print(f"Backbone '{backbone}' not implemented") + assert False + + return pretrained, scratch + + +def _make_scratch(in_shape, out_shape, groups=1, expand=False): + scratch = nn.Module() + + out_shape1 = out_shape + out_shape2 = out_shape + out_shape3 = out_shape + out_shape4 = out_shape + if expand==True: + out_shape1 = out_shape + out_shape2 = out_shape*2 + out_shape3 = out_shape*4 + out_shape4 = out_shape*8 + + scratch.layer1_rn = nn.Conv2d( + in_shape[0], out_shape1, kernel_size=3, stride=1, padding=1, bias=False, groups=groups + ) + scratch.layer2_rn = nn.Conv2d( + in_shape[1], out_shape2, kernel_size=3, stride=1, padding=1, bias=False, groups=groups + ) + scratch.layer3_rn = nn.Conv2d( + in_shape[2], out_shape3, kernel_size=3, stride=1, padding=1, bias=False, groups=groups + ) + scratch.layer4_rn = nn.Conv2d( + in_shape[3], out_shape4, kernel_size=3, stride=1, padding=1, bias=False, groups=groups + ) + + return scratch + + +def _make_pretrained_efficientnet_lite3(use_pretrained, exportable=False): + efficientnet = torch.hub.load( + "rwightman/gen-efficientnet-pytorch", + "tf_efficientnet_lite3", + pretrained=use_pretrained, + exportable=exportable + ) + return _make_efficientnet_backbone(efficientnet) + + +def _make_efficientnet_backbone(effnet): + pretrained = nn.Module() + + pretrained.layer1 = nn.Sequential( + effnet.conv_stem, effnet.bn1, effnet.act1, *effnet.blocks[0:2] + ) + pretrained.layer2 = nn.Sequential(*effnet.blocks[2:3]) + pretrained.layer3 = nn.Sequential(*effnet.blocks[3:5]) + pretrained.layer4 = nn.Sequential(*effnet.blocks[5:9]) + + return pretrained + + +def _make_resnet_backbone(resnet): + pretrained = nn.Module() + pretrained.layer1 = nn.Sequential( + resnet.conv1, resnet.bn1, resnet.relu, resnet.maxpool, resnet.layer1 + ) + + pretrained.layer2 = resnet.layer2 + pretrained.layer3 = resnet.layer3 + pretrained.layer4 = resnet.layer4 + + return pretrained + + +def _make_pretrained_resnext101_wsl(use_pretrained): + resnet = torch.hub.load("facebookresearch/WSL-Images", "resnext101_32x8d_wsl") + return _make_resnet_backbone(resnet) + + + +class Interpolate(nn.Module): + """Interpolation module. + """ + + def __init__(self, scale_factor, mode, align_corners=False): + """Init. + + Args: + scale_factor (float): scaling + mode (str): interpolation mode + """ + super(Interpolate, self).__init__() + + self.interp = nn.functional.interpolate + self.scale_factor = scale_factor + self.mode = mode + self.align_corners = align_corners + + def forward(self, x): + """Forward pass. + + Args: + x (tensor): input + + Returns: + tensor: interpolated data + """ + + x = self.interp( + x, scale_factor=self.scale_factor, mode=self.mode, align_corners=self.align_corners + ) + + return x + + +class ResidualConvUnit(nn.Module): + """Residual convolution module. + """ + + def __init__(self, features): + """Init. + + Args: + features (int): number of features + """ + super().__init__() + + self.conv1 = nn.Conv2d( + features, features, kernel_size=3, stride=1, padding=1, bias=True + ) + + self.conv2 = nn.Conv2d( + features, features, kernel_size=3, stride=1, padding=1, bias=True + ) + + self.relu = nn.ReLU(inplace=True) + + def forward(self, x): + """Forward pass. + + Args: + x (tensor): input + + Returns: + tensor: output + """ + out = self.relu(x) + out = self.conv1(out) + out = self.relu(out) + out = self.conv2(out) + + return out + x + + +class FeatureFusionBlock(nn.Module): + """Feature fusion block. + """ + + def __init__(self, features): + """Init. + + Args: + features (int): number of features + """ + super(FeatureFusionBlock, self).__init__() + + self.resConfUnit1 = ResidualConvUnit(features) + self.resConfUnit2 = ResidualConvUnit(features) + + def forward(self, *xs): + """Forward pass. + + Returns: + tensor: output + """ + output = xs[0] + + if len(xs) == 2: + output += self.resConfUnit1(xs[1]) + + output = self.resConfUnit2(output) + + output = nn.functional.interpolate( + output, scale_factor=2, mode="bilinear", align_corners=True + ) + + return output + + + + +class ResidualConvUnit_custom(nn.Module): + """Residual convolution module. + """ + + def __init__(self, features, activation, bn): + """Init. + + Args: + features (int): number of features + """ + super().__init__() + + self.bn = bn + + self.groups=1 + + self.conv1 = nn.Conv2d( + features, features, kernel_size=3, stride=1, padding=1, bias=True, groups=self.groups + ) + + self.conv2 = nn.Conv2d( + features, features, kernel_size=3, stride=1, padding=1, bias=True, groups=self.groups + ) + + if self.bn==True: + self.bn1 = nn.BatchNorm2d(features) + self.bn2 = nn.BatchNorm2d(features) + + self.activation = activation + + self.skip_add = nn.quantized.FloatFunctional() + + def forward(self, x): + """Forward pass. + + Args: + x (tensor): input + + Returns: + tensor: output + """ + + out = self.activation(x) + out = self.conv1(out) + if self.bn==True: + out = self.bn1(out) + + out = self.activation(out) + out = self.conv2(out) + if self.bn==True: + out = self.bn2(out) + + if self.groups > 1: + out = self.conv_merge(out) + + return self.skip_add.add(out, x) + + # return out + x + + +class FeatureFusionBlock_custom(nn.Module): + """Feature fusion block. + """ + + def __init__(self, features, activation, deconv=False, bn=False, expand=False, align_corners=True): + """Init. + + Args: + features (int): number of features + """ + super(FeatureFusionBlock_custom, self).__init__() + + self.deconv = deconv + self.align_corners = align_corners + + self.groups=1 + + self.expand = expand + out_features = features + if self.expand==True: + out_features = features//2 + + self.out_conv = nn.Conv2d(features, out_features, kernel_size=1, stride=1, padding=0, bias=True, groups=1) + + self.resConfUnit1 = ResidualConvUnit_custom(features, activation, bn) + self.resConfUnit2 = ResidualConvUnit_custom(features, activation, bn) + + self.skip_add = nn.quantized.FloatFunctional() + + def forward(self, *xs): + """Forward pass. + + Returns: + tensor: output + """ + output = xs[0] + + if len(xs) == 2: + res = self.resConfUnit1(xs[1]) + output = self.skip_add.add(output, res) + # output += res + + output = self.resConfUnit2(output) + + output = nn.functional.interpolate( + output, scale_factor=2, mode="bilinear", align_corners=self.align_corners + ) + + output = self.out_conv(output) + + return output + diff --git a/ldm/modules/midas/midas/dpt_depth.py b/ldm/modules/midas/midas/dpt_depth.py new file mode 100644 index 0000000000000000000000000000000000000000..4e9aab5d2767dffea39da5b3f30e2798688216f1 --- /dev/null +++ b/ldm/modules/midas/midas/dpt_depth.py @@ -0,0 +1,109 @@ +import torch +import torch.nn as nn +import torch.nn.functional as F + +from .base_model import BaseModel +from .blocks import ( + FeatureFusionBlock, + FeatureFusionBlock_custom, + Interpolate, + _make_encoder, + forward_vit, +) + + +def _make_fusion_block(features, use_bn): + return FeatureFusionBlock_custom( + features, + nn.ReLU(False), + deconv=False, + bn=use_bn, + expand=False, + align_corners=True, + ) + + +class DPT(BaseModel): + def __init__( + self, + head, + features=256, + backbone="vitb_rn50_384", + readout="project", + channels_last=False, + use_bn=False, + ): + + super(DPT, self).__init__() + + self.channels_last = channels_last + + hooks = { + "vitb_rn50_384": [0, 1, 8, 11], + "vitb16_384": [2, 5, 8, 11], + "vitl16_384": [5, 11, 17, 23], + } + + # Instantiate backbone and reassemble blocks + self.pretrained, self.scratch = _make_encoder( + backbone, + features, + False, # Set to true of you want to train from scratch, uses ImageNet weights + groups=1, + expand=False, + exportable=False, + hooks=hooks[backbone], + use_readout=readout, + ) + + self.scratch.refinenet1 = _make_fusion_block(features, use_bn) + self.scratch.refinenet2 = _make_fusion_block(features, use_bn) + self.scratch.refinenet3 = _make_fusion_block(features, use_bn) + self.scratch.refinenet4 = _make_fusion_block(features, use_bn) + + self.scratch.output_conv = head + + + def forward(self, x): + if self.channels_last == True: + x.contiguous(memory_format=torch.channels_last) + + layer_1, layer_2, layer_3, layer_4 = forward_vit(self.pretrained, x) + + layer_1_rn = self.scratch.layer1_rn(layer_1) + layer_2_rn = self.scratch.layer2_rn(layer_2) + layer_3_rn = self.scratch.layer3_rn(layer_3) + layer_4_rn = self.scratch.layer4_rn(layer_4) + + path_4 = self.scratch.refinenet4(layer_4_rn) + path_3 = self.scratch.refinenet3(path_4, layer_3_rn) + path_2 = self.scratch.refinenet2(path_3, layer_2_rn) + path_1 = self.scratch.refinenet1(path_2, layer_1_rn) + + out = self.scratch.output_conv(path_1) + + return out + + +class DPTDepthModel(DPT): + def __init__(self, path=None, non_negative=True, **kwargs): + features = kwargs["features"] if "features" in kwargs else 256 + + head = nn.Sequential( + nn.Conv2d(features, features // 2, kernel_size=3, stride=1, padding=1), + Interpolate(scale_factor=2, mode="bilinear", align_corners=True), + nn.Conv2d(features // 2, 32, kernel_size=3, stride=1, padding=1), + nn.ReLU(True), + nn.Conv2d(32, 1, kernel_size=1, stride=1, padding=0), + nn.ReLU(True) if non_negative else nn.Identity(), + nn.Identity(), + ) + + super().__init__(head, **kwargs) + + if path is not None: + self.load(path) + + def forward(self, x): + return super().forward(x).squeeze(dim=1) + diff --git a/ldm/modules/midas/midas/midas_net.py b/ldm/modules/midas/midas/midas_net.py new file mode 100644 index 0000000000000000000000000000000000000000..8a954977800b0a0f48807e80fa63041910e33c1f --- /dev/null +++ b/ldm/modules/midas/midas/midas_net.py @@ -0,0 +1,76 @@ +"""MidashNet: Network for monocular depth estimation trained by mixing several datasets. +This file contains code that is adapted from +https://github.com/thomasjpfan/pytorch_refinenet/blob/master/pytorch_refinenet/refinenet/refinenet_4cascade.py +""" +import torch +import torch.nn as nn + +from .base_model import BaseModel +from .blocks import FeatureFusionBlock, Interpolate, _make_encoder + + +class MidasNet(BaseModel): + """Network for monocular depth estimation. + """ + + def __init__(self, path=None, features=256, non_negative=True): + """Init. + + Args: + path (str, optional): Path to saved model. Defaults to None. + features (int, optional): Number of features. Defaults to 256. + backbone (str, optional): Backbone network for encoder. Defaults to resnet50 + """ + print("Loading weights: ", path) + + super(MidasNet, self).__init__() + + use_pretrained = False if path is None else True + + self.pretrained, self.scratch = _make_encoder(backbone="resnext101_wsl", features=features, use_pretrained=use_pretrained) + + self.scratch.refinenet4 = FeatureFusionBlock(features) + self.scratch.refinenet3 = FeatureFusionBlock(features) + self.scratch.refinenet2 = FeatureFusionBlock(features) + self.scratch.refinenet1 = FeatureFusionBlock(features) + + self.scratch.output_conv = nn.Sequential( + nn.Conv2d(features, 128, kernel_size=3, stride=1, padding=1), + Interpolate(scale_factor=2, mode="bilinear"), + nn.Conv2d(128, 32, kernel_size=3, stride=1, padding=1), + nn.ReLU(True), + nn.Conv2d(32, 1, kernel_size=1, stride=1, padding=0), + nn.ReLU(True) if non_negative else nn.Identity(), + ) + + if path: + self.load(path) + + def forward(self, x): + """Forward pass. + + Args: + x (tensor): input data (image) + + Returns: + tensor: depth + """ + + layer_1 = self.pretrained.layer1(x) + layer_2 = self.pretrained.layer2(layer_1) + layer_3 = self.pretrained.layer3(layer_2) + layer_4 = self.pretrained.layer4(layer_3) + + layer_1_rn = self.scratch.layer1_rn(layer_1) + layer_2_rn = self.scratch.layer2_rn(layer_2) + layer_3_rn = self.scratch.layer3_rn(layer_3) + layer_4_rn = self.scratch.layer4_rn(layer_4) + + path_4 = self.scratch.refinenet4(layer_4_rn) + path_3 = self.scratch.refinenet3(path_4, layer_3_rn) + path_2 = self.scratch.refinenet2(path_3, layer_2_rn) + path_1 = self.scratch.refinenet1(path_2, layer_1_rn) + + out = self.scratch.output_conv(path_1) + + return torch.squeeze(out, dim=1) diff --git a/ldm/modules/midas/midas/midas_net_custom.py b/ldm/modules/midas/midas/midas_net_custom.py new file mode 100644 index 0000000000000000000000000000000000000000..50e4acb5e53d5fabefe3dde16ab49c33c2b7797c --- /dev/null +++ b/ldm/modules/midas/midas/midas_net_custom.py @@ -0,0 +1,128 @@ +"""MidashNet: Network for monocular depth estimation trained by mixing several datasets. +This file contains code that is adapted from +https://github.com/thomasjpfan/pytorch_refinenet/blob/master/pytorch_refinenet/refinenet/refinenet_4cascade.py +""" +import torch +import torch.nn as nn + +from .base_model import BaseModel +from .blocks import FeatureFusionBlock, FeatureFusionBlock_custom, Interpolate, _make_encoder + + +class MidasNet_small(BaseModel): + """Network for monocular depth estimation. + """ + + def __init__(self, path=None, features=64, backbone="efficientnet_lite3", non_negative=True, exportable=True, channels_last=False, align_corners=True, + blocks={'expand': True}): + """Init. + + Args: + path (str, optional): Path to saved model. Defaults to None. + features (int, optional): Number of features. Defaults to 256. + backbone (str, optional): Backbone network for encoder. Defaults to resnet50 + """ + print("Loading weights: ", path) + + super(MidasNet_small, self).__init__() + + use_pretrained = False if path else True + + self.channels_last = channels_last + self.blocks = blocks + self.backbone = backbone + + self.groups = 1 + + features1=features + features2=features + features3=features + features4=features + self.expand = False + if "expand" in self.blocks and self.blocks['expand'] == True: + self.expand = True + features1=features + features2=features*2 + features3=features*4 + features4=features*8 + + self.pretrained, self.scratch = _make_encoder(self.backbone, features, use_pretrained, groups=self.groups, expand=self.expand, exportable=exportable) + + self.scratch.activation = nn.ReLU(False) + + self.scratch.refinenet4 = FeatureFusionBlock_custom(features4, self.scratch.activation, deconv=False, bn=False, expand=self.expand, align_corners=align_corners) + self.scratch.refinenet3 = FeatureFusionBlock_custom(features3, self.scratch.activation, deconv=False, bn=False, expand=self.expand, align_corners=align_corners) + self.scratch.refinenet2 = FeatureFusionBlock_custom(features2, self.scratch.activation, deconv=False, bn=False, expand=self.expand, align_corners=align_corners) + self.scratch.refinenet1 = FeatureFusionBlock_custom(features1, self.scratch.activation, deconv=False, bn=False, align_corners=align_corners) + + + self.scratch.output_conv = nn.Sequential( + nn.Conv2d(features, features//2, kernel_size=3, stride=1, padding=1, groups=self.groups), + Interpolate(scale_factor=2, mode="bilinear"), + nn.Conv2d(features//2, 32, kernel_size=3, stride=1, padding=1), + self.scratch.activation, + nn.Conv2d(32, 1, kernel_size=1, stride=1, padding=0), + nn.ReLU(True) if non_negative else nn.Identity(), + nn.Identity(), + ) + + if path: + self.load(path) + + + def forward(self, x): + """Forward pass. + + Args: + x (tensor): input data (image) + + Returns: + tensor: depth + """ + if self.channels_last==True: + print("self.channels_last = ", self.channels_last) + x.contiguous(memory_format=torch.channels_last) + + + layer_1 = self.pretrained.layer1(x) + layer_2 = self.pretrained.layer2(layer_1) + layer_3 = self.pretrained.layer3(layer_2) + layer_4 = self.pretrained.layer4(layer_3) + + layer_1_rn = self.scratch.layer1_rn(layer_1) + layer_2_rn = self.scratch.layer2_rn(layer_2) + layer_3_rn = self.scratch.layer3_rn(layer_3) + layer_4_rn = self.scratch.layer4_rn(layer_4) + + + path_4 = self.scratch.refinenet4(layer_4_rn) + path_3 = self.scratch.refinenet3(path_4, layer_3_rn) + path_2 = self.scratch.refinenet2(path_3, layer_2_rn) + path_1 = self.scratch.refinenet1(path_2, layer_1_rn) + + out = self.scratch.output_conv(path_1) + + return torch.squeeze(out, dim=1) + + + +def fuse_model(m): + prev_previous_type = nn.Identity() + prev_previous_name = '' + previous_type = nn.Identity() + previous_name = '' + for name, module in m.named_modules(): + if prev_previous_type == nn.Conv2d and previous_type == nn.BatchNorm2d and type(module) == nn.ReLU: + # print("FUSED ", prev_previous_name, previous_name, name) + torch.quantization.fuse_modules(m, [prev_previous_name, previous_name, name], inplace=True) + elif prev_previous_type == nn.Conv2d and previous_type == nn.BatchNorm2d: + # print("FUSED ", prev_previous_name, previous_name) + torch.quantization.fuse_modules(m, [prev_previous_name, previous_name], inplace=True) + # elif previous_type == nn.Conv2d and type(module) == nn.ReLU: + # print("FUSED ", previous_name, name) + # torch.quantization.fuse_modules(m, [previous_name, name], inplace=True) + + prev_previous_type = previous_type + prev_previous_name = previous_name + previous_type = type(module) + previous_name = name \ No newline at end of file diff --git a/ldm/modules/midas/midas/transforms.py b/ldm/modules/midas/midas/transforms.py new file mode 100644 index 0000000000000000000000000000000000000000..350cbc11662633ad7f8968eb10be2e7de6e384e9 --- /dev/null +++ b/ldm/modules/midas/midas/transforms.py @@ -0,0 +1,234 @@ +import numpy as np +import cv2 +import math + + +def apply_min_size(sample, size, image_interpolation_method=cv2.INTER_AREA): + """Rezise the sample to ensure the given size. Keeps aspect ratio. + + Args: + sample (dict): sample + size (tuple): image size + + Returns: + tuple: new size + """ + shape = list(sample["disparity"].shape) + + if shape[0] >= size[0] and shape[1] >= size[1]: + return sample + + scale = [0, 0] + scale[0] = size[0] / shape[0] + scale[1] = size[1] / shape[1] + + scale = max(scale) + + shape[0] = math.ceil(scale * shape[0]) + shape[1] = math.ceil(scale * shape[1]) + + # resize + sample["image"] = cv2.resize( + sample["image"], tuple(shape[::-1]), interpolation=image_interpolation_method + ) + + sample["disparity"] = cv2.resize( + sample["disparity"], tuple(shape[::-1]), interpolation=cv2.INTER_NEAREST + ) + sample["mask"] = cv2.resize( + sample["mask"].astype(np.float32), + tuple(shape[::-1]), + interpolation=cv2.INTER_NEAREST, + ) + sample["mask"] = sample["mask"].astype(bool) + + return tuple(shape) + + +class Resize(object): + """Resize sample to given size (width, height). + """ + + def __init__( + self, + width, + height, + resize_target=True, + keep_aspect_ratio=False, + ensure_multiple_of=1, + resize_method="lower_bound", + image_interpolation_method=cv2.INTER_AREA, + ): + """Init. + + Args: + width (int): desired output width + height (int): desired output height + resize_target (bool, optional): + True: Resize the full sample (image, mask, target). + False: Resize image only. + Defaults to True. + keep_aspect_ratio (bool, optional): + True: Keep the aspect ratio of the input sample. + Output sample might not have the given width and height, and + resize behaviour depends on the parameter 'resize_method'. + Defaults to False. + ensure_multiple_of (int, optional): + Output width and height is constrained to be multiple of this parameter. + Defaults to 1. + resize_method (str, optional): + "lower_bound": Output will be at least as large as the given size. + "upper_bound": Output will be at max as large as the given size. (Output size might be smaller than given size.) + "minimal": Scale as least as possible. (Output size might be smaller than given size.) + Defaults to "lower_bound". + """ + self.__width = width + self.__height = height + + self.__resize_target = resize_target + self.__keep_aspect_ratio = keep_aspect_ratio + self.__multiple_of = ensure_multiple_of + self.__resize_method = resize_method + self.__image_interpolation_method = image_interpolation_method + + def constrain_to_multiple_of(self, x, min_val=0, max_val=None): + y = (np.round(x / self.__multiple_of) * self.__multiple_of).astype(int) + + if max_val is not None and y > max_val: + y = (np.floor(x / self.__multiple_of) * self.__multiple_of).astype(int) + + if y < min_val: + y = (np.ceil(x / self.__multiple_of) * self.__multiple_of).astype(int) + + return y + + def get_size(self, width, height): + # determine new height and width + scale_height = self.__height / height + scale_width = self.__width / width + + if self.__keep_aspect_ratio: + if self.__resize_method == "lower_bound": + # scale such that output size is lower bound + if scale_width > scale_height: + # fit width + scale_height = scale_width + else: + # fit height + scale_width = scale_height + elif self.__resize_method == "upper_bound": + # scale such that output size is upper bound + if scale_width < scale_height: + # fit width + scale_height = scale_width + else: + # fit height + scale_width = scale_height + elif self.__resize_method == "minimal": + # scale as least as possbile + if abs(1 - scale_width) < abs(1 - scale_height): + # fit width + scale_height = scale_width + else: + # fit height + scale_width = scale_height + else: + raise ValueError( + f"resize_method {self.__resize_method} not implemented" + ) + + if self.__resize_method == "lower_bound": + new_height = self.constrain_to_multiple_of( + scale_height * height, min_val=self.__height + ) + new_width = self.constrain_to_multiple_of( + scale_width * width, min_val=self.__width + ) + elif self.__resize_method == "upper_bound": + new_height = self.constrain_to_multiple_of( + scale_height * height, max_val=self.__height + ) + new_width = self.constrain_to_multiple_of( + scale_width * width, max_val=self.__width + ) + elif self.__resize_method == "minimal": + new_height = self.constrain_to_multiple_of(scale_height * height) + new_width = self.constrain_to_multiple_of(scale_width * width) + else: + raise ValueError(f"resize_method {self.__resize_method} not implemented") + + return (new_width, new_height) + + def __call__(self, sample): + width, height = self.get_size( + sample["image"].shape[1], sample["image"].shape[0] + ) + + # resize sample + sample["image"] = cv2.resize( + sample["image"], + (width, height), + interpolation=self.__image_interpolation_method, + ) + + if self.__resize_target: + if "disparity" in sample: + sample["disparity"] = cv2.resize( + sample["disparity"], + (width, height), + interpolation=cv2.INTER_NEAREST, + ) + + if "depth" in sample: + sample["depth"] = cv2.resize( + sample["depth"], (width, height), interpolation=cv2.INTER_NEAREST + ) + + sample["mask"] = cv2.resize( + sample["mask"].astype(np.float32), + (width, height), + interpolation=cv2.INTER_NEAREST, + ) + sample["mask"] = sample["mask"].astype(bool) + + return sample + + +class NormalizeImage(object): + """Normlize image by given mean and std. + """ + + def __init__(self, mean, std): + self.__mean = mean + self.__std = std + + def __call__(self, sample): + sample["image"] = (sample["image"] - self.__mean) / self.__std + + return sample + + +class PrepareForNet(object): + """Prepare sample for usage as network input. + """ + + def __init__(self): + pass + + def __call__(self, sample): + image = np.transpose(sample["image"], (2, 0, 1)) + sample["image"] = np.ascontiguousarray(image).astype(np.float32) + + if "mask" in sample: + sample["mask"] = sample["mask"].astype(np.float32) + sample["mask"] = np.ascontiguousarray(sample["mask"]) + + if "disparity" in sample: + disparity = sample["disparity"].astype(np.float32) + sample["disparity"] = np.ascontiguousarray(disparity) + + if "depth" in sample: + depth = sample["depth"].astype(np.float32) + sample["depth"] = np.ascontiguousarray(depth) + + return sample diff --git a/ldm/modules/midas/midas/vit.py b/ldm/modules/midas/midas/vit.py new file mode 100644 index 0000000000000000000000000000000000000000..ea46b1be88b261b0dec04f3da0256f5f66f88a74 --- /dev/null +++ b/ldm/modules/midas/midas/vit.py @@ -0,0 +1,491 @@ +import torch +import torch.nn as nn +import timm +import types +import math +import torch.nn.functional as F + + +class Slice(nn.Module): + def __init__(self, start_index=1): + super(Slice, self).__init__() + self.start_index = start_index + + def forward(self, x): + return x[:, self.start_index :] + + +class AddReadout(nn.Module): + def __init__(self, start_index=1): + super(AddReadout, self).__init__() + self.start_index = start_index + + def forward(self, x): + if self.start_index == 2: + readout = (x[:, 0] + x[:, 1]) / 2 + else: + readout = x[:, 0] + return x[:, self.start_index :] + readout.unsqueeze(1) + + +class ProjectReadout(nn.Module): + def __init__(self, in_features, start_index=1): + super(ProjectReadout, self).__init__() + self.start_index = start_index + + self.project = nn.Sequential(nn.Linear(2 * in_features, in_features), nn.GELU()) + + def forward(self, x): + readout = x[:, 0].unsqueeze(1).expand_as(x[:, self.start_index :]) + features = torch.cat((x[:, self.start_index :], readout), -1) + + return self.project(features) + + +class Transpose(nn.Module): + def __init__(self, dim0, dim1): + super(Transpose, self).__init__() + self.dim0 = dim0 + self.dim1 = dim1 + + def forward(self, x): + x = x.transpose(self.dim0, self.dim1) + return x + + +def forward_vit(pretrained, x): + b, c, h, w = x.shape + + glob = pretrained.model.forward_flex(x) + + layer_1 = pretrained.activations["1"] + layer_2 = pretrained.activations["2"] + layer_3 = pretrained.activations["3"] + layer_4 = pretrained.activations["4"] + + layer_1 = pretrained.act_postprocess1[0:2](layer_1) + layer_2 = pretrained.act_postprocess2[0:2](layer_2) + layer_3 = pretrained.act_postprocess3[0:2](layer_3) + layer_4 = pretrained.act_postprocess4[0:2](layer_4) + + unflatten = nn.Sequential( + nn.Unflatten( + 2, + torch.Size( + [ + h // pretrained.model.patch_size[1], + w // pretrained.model.patch_size[0], + ] + ), + ) + ) + + if layer_1.ndim == 3: + layer_1 = unflatten(layer_1) + if layer_2.ndim == 3: + layer_2 = unflatten(layer_2) + if layer_3.ndim == 3: + layer_3 = unflatten(layer_3) + if layer_4.ndim == 3: + layer_4 = unflatten(layer_4) + + layer_1 = pretrained.act_postprocess1[3 : len(pretrained.act_postprocess1)](layer_1) + layer_2 = pretrained.act_postprocess2[3 : len(pretrained.act_postprocess2)](layer_2) + layer_3 = pretrained.act_postprocess3[3 : len(pretrained.act_postprocess3)](layer_3) + layer_4 = pretrained.act_postprocess4[3 : len(pretrained.act_postprocess4)](layer_4) + + return layer_1, layer_2, layer_3, layer_4 + + +def _resize_pos_embed(self, posemb, gs_h, gs_w): + posemb_tok, posemb_grid = ( + posemb[:, : self.start_index], + posemb[0, self.start_index :], + ) + + gs_old = int(math.sqrt(len(posemb_grid))) + + posemb_grid = posemb_grid.reshape(1, gs_old, gs_old, -1).permute(0, 3, 1, 2) + posemb_grid = F.interpolate(posemb_grid, size=(gs_h, gs_w), mode="bilinear") + posemb_grid = posemb_grid.permute(0, 2, 3, 1).reshape(1, gs_h * gs_w, -1) + + posemb = torch.cat([posemb_tok, posemb_grid], dim=1) + + return posemb + + +def forward_flex(self, x): + b, c, h, w = x.shape + + pos_embed = self._resize_pos_embed( + self.pos_embed, h // self.patch_size[1], w // self.patch_size[0] + ) + + B = x.shape[0] + + if hasattr(self.patch_embed, "backbone"): + x = self.patch_embed.backbone(x) + if isinstance(x, (list, tuple)): + x = x[-1] # last feature if backbone outputs list/tuple of features + + x = self.patch_embed.proj(x).flatten(2).transpose(1, 2) + + if getattr(self, "dist_token", None) is not None: + cls_tokens = self.cls_token.expand( + B, -1, -1 + ) # stole cls_tokens impl from Phil Wang, thanks + dist_token = self.dist_token.expand(B, -1, -1) + x = torch.cat((cls_tokens, dist_token, x), dim=1) + else: + cls_tokens = self.cls_token.expand( + B, -1, -1 + ) # stole cls_tokens impl from Phil Wang, thanks + x = torch.cat((cls_tokens, x), dim=1) + + x = x + pos_embed + x = self.pos_drop(x) + + for blk in self.blocks: + x = blk(x) + + x = self.norm(x) + + return x + + +activations = {} + + +def get_activation(name): + def hook(model, input, output): + activations[name] = output + + return hook + + +def get_readout_oper(vit_features, features, use_readout, start_index=1): + if use_readout == "ignore": + readout_oper = [Slice(start_index)] * len(features) + elif use_readout == "add": + readout_oper = [AddReadout(start_index)] * len(features) + elif use_readout == "project": + readout_oper = [ + ProjectReadout(vit_features, start_index) for out_feat in features + ] + else: + assert ( + False + ), "wrong operation for readout token, use_readout can be 'ignore', 'add', or 'project'" + + return readout_oper + + +def _make_vit_b16_backbone( + model, + features=[96, 192, 384, 768], + size=[384, 384], + hooks=[2, 5, 8, 11], + vit_features=768, + use_readout="ignore", + start_index=1, +): + pretrained = nn.Module() + + pretrained.model = model + pretrained.model.blocks[hooks[0]].register_forward_hook(get_activation("1")) + pretrained.model.blocks[hooks[1]].register_forward_hook(get_activation("2")) + pretrained.model.blocks[hooks[2]].register_forward_hook(get_activation("3")) + pretrained.model.blocks[hooks[3]].register_forward_hook(get_activation("4")) + + pretrained.activations = activations + + readout_oper = get_readout_oper(vit_features, features, use_readout, start_index) + + # 32, 48, 136, 384 + pretrained.act_postprocess1 = nn.Sequential( + readout_oper[0], + Transpose(1, 2), + nn.Unflatten(2, torch.Size([size[0] // 16, size[1] // 16])), + nn.Conv2d( + in_channels=vit_features, + out_channels=features[0], + kernel_size=1, + stride=1, + padding=0, + ), + nn.ConvTranspose2d( + in_channels=features[0], + out_channels=features[0], + kernel_size=4, + stride=4, + padding=0, + bias=True, + dilation=1, + groups=1, + ), + ) + + pretrained.act_postprocess2 = nn.Sequential( + readout_oper[1], + Transpose(1, 2), + nn.Unflatten(2, torch.Size([size[0] // 16, size[1] // 16])), + nn.Conv2d( + in_channels=vit_features, + out_channels=features[1], + kernel_size=1, + stride=1, + padding=0, + ), + nn.ConvTranspose2d( + in_channels=features[1], + out_channels=features[1], + kernel_size=2, + stride=2, + padding=0, + bias=True, + dilation=1, + groups=1, + ), + ) + + pretrained.act_postprocess3 = nn.Sequential( + readout_oper[2], + Transpose(1, 2), + nn.Unflatten(2, torch.Size([size[0] // 16, size[1] // 16])), + nn.Conv2d( + in_channels=vit_features, + out_channels=features[2], + kernel_size=1, + stride=1, + padding=0, + ), + ) + + pretrained.act_postprocess4 = nn.Sequential( + readout_oper[3], + Transpose(1, 2), + nn.Unflatten(2, torch.Size([size[0] // 16, size[1] // 16])), + nn.Conv2d( + in_channels=vit_features, + out_channels=features[3], + kernel_size=1, + stride=1, + padding=0, + ), + nn.Conv2d( + in_channels=features[3], + out_channels=features[3], + kernel_size=3, + stride=2, + padding=1, + ), + ) + + pretrained.model.start_index = start_index + pretrained.model.patch_size = [16, 16] + + # We inject this function into the VisionTransformer instances so that + # we can use it with interpolated position embeddings without modifying the library source. + pretrained.model.forward_flex = types.MethodType(forward_flex, pretrained.model) + pretrained.model._resize_pos_embed = types.MethodType( + _resize_pos_embed, pretrained.model + ) + + return pretrained + + +def _make_pretrained_vitl16_384(pretrained, use_readout="ignore", hooks=None): + model = timm.create_model("vit_large_patch16_384", pretrained=pretrained) + + hooks = [5, 11, 17, 23] if hooks == None else hooks + return _make_vit_b16_backbone( + model, + features=[256, 512, 1024, 1024], + hooks=hooks, + vit_features=1024, + use_readout=use_readout, + ) + + +def _make_pretrained_vitb16_384(pretrained, use_readout="ignore", hooks=None): + model = timm.create_model("vit_base_patch16_384", pretrained=pretrained) + + hooks = [2, 5, 8, 11] if hooks == None else hooks + return _make_vit_b16_backbone( + model, features=[96, 192, 384, 768], hooks=hooks, use_readout=use_readout + ) + + +def _make_pretrained_deitb16_384(pretrained, use_readout="ignore", hooks=None): + model = timm.create_model("vit_deit_base_patch16_384", pretrained=pretrained) + + hooks = [2, 5, 8, 11] if hooks == None else hooks + return _make_vit_b16_backbone( + model, features=[96, 192, 384, 768], hooks=hooks, use_readout=use_readout + ) + + +def _make_pretrained_deitb16_distil_384(pretrained, use_readout="ignore", hooks=None): + model = timm.create_model( + "vit_deit_base_distilled_patch16_384", pretrained=pretrained + ) + + hooks = [2, 5, 8, 11] if hooks == None else hooks + return _make_vit_b16_backbone( + model, + features=[96, 192, 384, 768], + hooks=hooks, + use_readout=use_readout, + start_index=2, + ) + + +def _make_vit_b_rn50_backbone( + model, + features=[256, 512, 768, 768], + size=[384, 384], + hooks=[0, 1, 8, 11], + vit_features=768, + use_vit_only=False, + use_readout="ignore", + start_index=1, +): + pretrained = nn.Module() + + pretrained.model = model + + if use_vit_only == True: + pretrained.model.blocks[hooks[0]].register_forward_hook(get_activation("1")) + pretrained.model.blocks[hooks[1]].register_forward_hook(get_activation("2")) + else: + pretrained.model.patch_embed.backbone.stages[0].register_forward_hook( + get_activation("1") + ) + pretrained.model.patch_embed.backbone.stages[1].register_forward_hook( + get_activation("2") + ) + + pretrained.model.blocks[hooks[2]].register_forward_hook(get_activation("3")) + pretrained.model.blocks[hooks[3]].register_forward_hook(get_activation("4")) + + pretrained.activations = activations + + readout_oper = get_readout_oper(vit_features, features, use_readout, start_index) + + if use_vit_only == True: + pretrained.act_postprocess1 = nn.Sequential( + readout_oper[0], + Transpose(1, 2), + nn.Unflatten(2, torch.Size([size[0] // 16, size[1] // 16])), + nn.Conv2d( + in_channels=vit_features, + out_channels=features[0], + kernel_size=1, + stride=1, + padding=0, + ), + nn.ConvTranspose2d( + in_channels=features[0], + out_channels=features[0], + kernel_size=4, + stride=4, + padding=0, + bias=True, + dilation=1, + groups=1, + ), + ) + + pretrained.act_postprocess2 = nn.Sequential( + readout_oper[1], + Transpose(1, 2), + nn.Unflatten(2, torch.Size([size[0] // 16, size[1] // 16])), + nn.Conv2d( + in_channels=vit_features, + out_channels=features[1], + kernel_size=1, + stride=1, + padding=0, + ), + nn.ConvTranspose2d( + in_channels=features[1], + out_channels=features[1], + kernel_size=2, + stride=2, + padding=0, + bias=True, + dilation=1, + groups=1, + ), + ) + else: + pretrained.act_postprocess1 = nn.Sequential( + nn.Identity(), nn.Identity(), nn.Identity() + ) + pretrained.act_postprocess2 = nn.Sequential( + nn.Identity(), nn.Identity(), nn.Identity() + ) + + pretrained.act_postprocess3 = nn.Sequential( + readout_oper[2], + Transpose(1, 2), + nn.Unflatten(2, torch.Size([size[0] // 16, size[1] // 16])), + nn.Conv2d( + in_channels=vit_features, + out_channels=features[2], + kernel_size=1, + stride=1, + padding=0, + ), + ) + + pretrained.act_postprocess4 = nn.Sequential( + readout_oper[3], + Transpose(1, 2), + nn.Unflatten(2, torch.Size([size[0] // 16, size[1] // 16])), + nn.Conv2d( + in_channels=vit_features, + out_channels=features[3], + kernel_size=1, + stride=1, + padding=0, + ), + nn.Conv2d( + in_channels=features[3], + out_channels=features[3], + kernel_size=3, + stride=2, + padding=1, + ), + ) + + pretrained.model.start_index = start_index + pretrained.model.patch_size = [16, 16] + + # We inject this function into the VisionTransformer instances so that + # we can use it with interpolated position embeddings without modifying the library source. + pretrained.model.forward_flex = types.MethodType(forward_flex, pretrained.model) + + # We inject this function into the VisionTransformer instances so that + # we can use it with interpolated position embeddings without modifying the library source. + pretrained.model._resize_pos_embed = types.MethodType( + _resize_pos_embed, pretrained.model + ) + + return pretrained + + +def _make_pretrained_vitb_rn50_384( + pretrained, use_readout="ignore", hooks=None, use_vit_only=False +): + model = timm.create_model("vit_base_resnet50_384", pretrained=pretrained) + + hooks = [0, 1, 8, 11] if hooks == None else hooks + return _make_vit_b_rn50_backbone( + model, + features=[256, 512, 768, 768], + size=[384, 384], + hooks=hooks, + use_vit_only=use_vit_only, + use_readout=use_readout, + ) diff --git a/ldm/modules/midas/utils.py b/ldm/modules/midas/utils.py new file mode 100644 index 0000000000000000000000000000000000000000..9a9d3b5b66370fa98da9e067ba53ead848ea9a59 --- /dev/null +++ b/ldm/modules/midas/utils.py @@ -0,0 +1,189 @@ +"""Utils for monoDepth.""" +import sys +import re +import numpy as np +import cv2 +import torch + + +def read_pfm(path): + """Read pfm file. + + Args: + path (str): path to file + + Returns: + tuple: (data, scale) + """ + with open(path, "rb") as file: + + color = None + width = None + height = None + scale = None + endian = None + + header = file.readline().rstrip() + if header.decode("ascii") == "PF": + color = True + elif header.decode("ascii") == "Pf": + color = False + else: + raise Exception("Not a PFM file: " + path) + + dim_match = re.match(r"^(\d+)\s(\d+)\s$", file.readline().decode("ascii")) + if dim_match: + width, height = list(map(int, dim_match.groups())) + else: + raise Exception("Malformed PFM header.") + + scale = float(file.readline().decode("ascii").rstrip()) + if scale < 0: + # little-endian + endian = "<" + scale = -scale + else: + # big-endian + endian = ">" + + data = np.fromfile(file, endian + "f") + shape = (height, width, 3) if color else (height, width) + + data = np.reshape(data, shape) + data = np.flipud(data) + + return data, scale + + +def write_pfm(path, image, scale=1): + """Write pfm file. + + Args: + path (str): pathto file + image (array): data + scale (int, optional): Scale. Defaults to 1. + """ + + with open(path, "wb") as file: + color = None + + if image.dtype.name != "float32": + raise Exception("Image dtype must be float32.") + + image = np.flipud(image) + + if len(image.shape) == 3 and image.shape[2] == 3: # color image + color = True + elif ( + len(image.shape) == 2 or len(image.shape) == 3 and image.shape[2] == 1 + ): # greyscale + color = False + else: + raise Exception("Image must have H x W x 3, H x W x 1 or H x W dimensions.") + + file.write("PF\n" if color else "Pf\n".encode()) + file.write("%d %d\n".encode() % (image.shape[1], image.shape[0])) + + endian = image.dtype.byteorder + + if endian == "<" or endian == "=" and sys.byteorder == "little": + scale = -scale + + file.write("%f\n".encode() % scale) + + image.tofile(file) + + +def read_image(path): + """Read image and output RGB image (0-1). + + Args: + path (str): path to file + + Returns: + array: RGB image (0-1) + """ + img = cv2.imread(path) + + if img.ndim == 2: + img = cv2.cvtColor(img, cv2.COLOR_GRAY2BGR) + + img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) / 255.0 + + return img + + +def resize_image(img): + """Resize image and make it fit for network. + + Args: + img (array): image + + Returns: + tensor: data ready for network + """ + height_orig = img.shape[0] + width_orig = img.shape[1] + + if width_orig > height_orig: + scale = width_orig / 384 + else: + scale = height_orig / 384 + + height = (np.ceil(height_orig / scale / 32) * 32).astype(int) + width = (np.ceil(width_orig / scale / 32) * 32).astype(int) + + img_resized = cv2.resize(img, (width, height), interpolation=cv2.INTER_AREA) + + img_resized = ( + torch.from_numpy(np.transpose(img_resized, (2, 0, 1))).contiguous().float() + ) + img_resized = img_resized.unsqueeze(0) + + return img_resized + + +def resize_depth(depth, width, height): + """Resize depth map and bring to CPU (numpy). + + Args: + depth (tensor): depth + width (int): image width + height (int): image height + + Returns: + array: processed depth + """ + depth = torch.squeeze(depth[0, :, :, :]).to("cpu") + + depth_resized = cv2.resize( + depth.numpy(), (width, height), interpolation=cv2.INTER_CUBIC + ) + + return depth_resized + +def write_depth(path, depth, bits=1): + """Write depth map to pfm and png file. + + Args: + path (str): filepath without extension + depth (array): depth + """ + write_pfm(path + ".pfm", depth.astype(np.float32)) + + depth_min = depth.min() + depth_max = depth.max() + + max_val = (2**(8*bits))-1 + + if depth_max - depth_min > np.finfo("float").eps: + out = max_val * (depth - depth_min) / (depth_max - depth_min) + else: + out = np.zeros(depth.shape, dtype=depth.type) + + if bits == 1: + cv2.imwrite(path + ".png", out.astype("uint8")) + elif bits == 2: + cv2.imwrite(path + ".png", out.astype("uint16")) + + return diff --git a/ldm/util.py b/ldm/util.py new file mode 100644 index 0000000000000000000000000000000000000000..9ede259d5e7876912724582cc06a71916f6f9b62 --- /dev/null +++ b/ldm/util.py @@ -0,0 +1,207 @@ +import importlib + +import torch +from torch import optim +import numpy as np + +from inspect import isfunction +from PIL import Image, ImageDraw, ImageFont + + +def autocast(f): + def do_autocast(*args, **kwargs): + with torch.cuda.amp.autocast(enabled=True, + dtype=torch.get_autocast_gpu_dtype(), + cache_enabled=torch.is_autocast_cache_enabled()): + return f(*args, **kwargs) + + return do_autocast + + +def log_txt_as_img(wh, xc, size=10): + # wh a tuple of (width, height) + # xc a list of captions to plot + b = len(xc) + txts = list() + for bi in range(b): + txt = Image.new("RGB", wh, color="white") + draw = ImageDraw.Draw(txt) + font = ImageFont.truetype('data/DejaVuSans.ttf', size=size) + nc = int(40 * (wh[0] / 256)) + lines = "\n".join(xc[bi][start:start + nc] for start in range(0, len(xc[bi]), nc)) + + try: + draw.text((0, 0), lines, fill="black", font=font) + except UnicodeEncodeError: + print("Cant encode string for logging. Skipping.") + + txt = np.array(txt).transpose(2, 0, 1) / 127.5 - 1.0 + txts.append(txt) + txts = np.stack(txts) + txts = torch.tensor(txts) + return txts + + +def ismap(x): + if not isinstance(x, torch.Tensor): + return False + return (len(x.shape) == 4) and (x.shape[1] > 3) + + +def isimage(x): + if not isinstance(x,torch.Tensor): + return False + return (len(x.shape) == 4) and (x.shape[1] == 3 or x.shape[1] == 1) + + +def exists(x): + return x is not None + + +def default(val, d): + if exists(val): + return val + return d() if isfunction(d) else d + + +def mean_flat(tensor): + """ + https://github.com/openai/guided-diffusion/blob/27c20a8fab9cb472df5d6bdd6c8d11c8f430b924/guided_diffusion/nn.py#L86 + Take the mean over all non-batch dimensions. + """ + return tensor.mean(dim=list(range(1, len(tensor.shape)))) + + +def count_params(model, verbose=False): + total_params = sum(p.numel() for p in model.parameters()) + if verbose: + print(f"{model.__class__.__name__} has {total_params*1.e-6:.2f} M params.") + return total_params + + +def instantiate_from_config(config): + if not "target" in config: + if config == '__is_first_stage__': + return None + elif config == "__is_unconditional__": + return None + raise KeyError("Expected key `target` to instantiate.") + return get_obj_from_str(config["target"])(**config.get("params", dict())) + + +def get_obj_from_str(string, reload=False): + module, cls = string.rsplit(".", 1) + if reload: + module_imp = importlib.import_module(module) + importlib.reload(module_imp) + return getattr(importlib.import_module(module, package=None), cls) + + +class AdamWwithEMAandWings(optim.Optimizer): + # credit to https://gist.github.com/crowsonkb/65f7265353f403714fce3b2595e0b298 + def __init__(self, params, lr=1.e-3, betas=(0.9, 0.999), eps=1.e-8, # TODO: check hyperparameters before using + weight_decay=1.e-2, amsgrad=False, ema_decay=0.9999, # ema decay to match previous code + ema_power=1., param_names=()): + """AdamW that saves EMA versions of the parameters.""" + if not 0.0 <= lr: + raise ValueError("Invalid learning rate: {}".format(lr)) + if not 0.0 <= eps: + raise ValueError("Invalid epsilon value: {}".format(eps)) + if not 0.0 <= betas[0] < 1.0: + raise ValueError("Invalid beta parameter at index 0: {}".format(betas[0])) + if not 0.0 <= betas[1] < 1.0: + raise ValueError("Invalid beta parameter at index 1: {}".format(betas[1])) + if not 0.0 <= weight_decay: + raise ValueError("Invalid weight_decay value: {}".format(weight_decay)) + if not 0.0 <= ema_decay <= 1.0: + raise ValueError("Invalid ema_decay value: {}".format(ema_decay)) + defaults = dict(lr=lr, betas=betas, eps=eps, + weight_decay=weight_decay, amsgrad=amsgrad, ema_decay=ema_decay, + ema_power=ema_power, param_names=param_names) + super().__init__(params, defaults) + + def __setstate__(self, state): + super().__setstate__(state) + for group in self.param_groups: + group.setdefault('amsgrad', False) + + @torch.no_grad() + def step(self, closure=None): + """Performs a single optimization step. + Args: + closure (callable, optional): A closure that reevaluates the model + and returns the loss. + """ + loss = None + if closure is not None: + with torch.enable_grad(): + loss = closure() + + for group in self.param_groups: + params_with_grad = [] + grads = [] + exp_avgs = [] + exp_avg_sqs = [] + ema_params_with_grad = [] + state_sums = [] + max_exp_avg_sqs = [] + state_steps = [] + amsgrad = group['amsgrad'] + beta1, beta2 = group['betas'] + ema_decay = group['ema_decay'] + ema_power = group['ema_power'] + + for p in group['params']: + if p.grad is None: + continue + params_with_grad.append(p) + if p.grad.is_sparse: + raise RuntimeError('AdamW does not support sparse gradients') + grads.append(p.grad) + + state = self.state[p] + + # State initialization + if len(state) == 0: + state['step'] = 0 + # Exponential moving average of gradient values + state['exp_avg'] = torch.zeros_like(p, memory_format=torch.preserve_format) + # Exponential moving average of squared gradient values + state['exp_avg_sq'] = torch.zeros_like(p, memory_format=torch.preserve_format) + if amsgrad: + # Maintains max of all exp. moving avg. of sq. grad. values + state['max_exp_avg_sq'] = torch.zeros_like(p, memory_format=torch.preserve_format) + # Exponential moving average of parameter values + state['param_exp_avg'] = p.detach().float().clone() + + exp_avgs.append(state['exp_avg']) + exp_avg_sqs.append(state['exp_avg_sq']) + ema_params_with_grad.append(state['param_exp_avg']) + + if amsgrad: + max_exp_avg_sqs.append(state['max_exp_avg_sq']) + + # update the steps for each param group update + state['step'] += 1 + # record the step after step update + state_steps.append(state['step']) + + optim._functional.adamw(params_with_grad, + grads, + exp_avgs, + exp_avg_sqs, + max_exp_avg_sqs, + state_steps, + amsgrad=amsgrad, + beta1=beta1, + beta2=beta2, + lr=group['lr'], + weight_decay=group['weight_decay'], + eps=group['eps'], + maximize=False) + + cur_ema_decay = min(ema_decay, 1 - state['step'] ** -ema_power) + for param, ema_param in zip(params_with_grad, ema_params_with_grad): + ema_param.mul_(cur_ema_decay).add_(param.float(), alpha=1 - cur_ema_decay) + + return loss \ No newline at end of file diff --git a/lora_diffusion/__init__.py b/lora_diffusion/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..286e4fecaaf7190bba2739bbc6e826a8969fece9 --- /dev/null +++ b/lora_diffusion/__init__.py @@ -0,0 +1,5 @@ +from .lora import * +from .dataset import * +from .utils import * +from .preprocess_files import * +from .lora_manager import * diff --git a/lora_diffusion/cli_lora_add.py b/lora_diffusion/cli_lora_add.py new file mode 100644 index 0000000000000000000000000000000000000000..fc7f7e4ace4253ba63a1631a304cf935a23b034a --- /dev/null +++ b/lora_diffusion/cli_lora_add.py @@ -0,0 +1,187 @@ +from typing import Literal, Union, Dict +import os +import shutil +import fire +from diffusers import StableDiffusionPipeline +from safetensors.torch import safe_open, save_file + +import torch +from .lora import ( + tune_lora_scale, + patch_pipe, + collapse_lora, + monkeypatch_remove_lora, +) +from .lora_manager import lora_join +from .to_ckpt_v2 import convert_to_ckpt + + +def _text_lora_path(path: str) -> str: + assert path.endswith(".pt"), "Only .pt files are supported" + return ".".join(path.split(".")[:-1] + ["text_encoder", "pt"]) + + +def add( + path_1: str, + path_2: str, + output_path: str, + alpha_1: float = 0.5, + alpha_2: float = 0.5, + mode: Literal[ + "lpl", + "upl", + "upl-ckpt-v2", + ] = "lpl", + with_text_lora: bool = False, +): + print("Lora Add, mode " + mode) + if mode == "lpl": + if path_1.endswith(".pt") and path_2.endswith(".pt"): + for _path_1, _path_2, opt in [(path_1, path_2, "unet")] + ( + [(_text_lora_path(path_1), _text_lora_path(path_2), "text_encoder")] + if with_text_lora + else [] + ): + print("Loading", _path_1, _path_2) + out_list = [] + if opt == "text_encoder": + if not os.path.exists(_path_1): + print(f"No text encoder found in {_path_1}, skipping...") + continue + if not os.path.exists(_path_2): + print(f"No text encoder found in {_path_1}, skipping...") + continue + + l1 = torch.load(_path_1) + l2 = torch.load(_path_2) + + l1pairs = zip(l1[::2], l1[1::2]) + l2pairs = zip(l2[::2], l2[1::2]) + + for (x1, y1), (x2, y2) in zip(l1pairs, l2pairs): + # print("Merging", x1.shape, y1.shape, x2.shape, y2.shape) + x1.data = alpha_1 * x1.data + alpha_2 * x2.data + y1.data = alpha_1 * y1.data + alpha_2 * y2.data + + out_list.append(x1) + out_list.append(y1) + + if opt == "unet": + + print("Saving merged UNET to", output_path) + torch.save(out_list, output_path) + + elif opt == "text_encoder": + print("Saving merged text encoder to", _text_lora_path(output_path)) + torch.save( + out_list, + _text_lora_path(output_path), + ) + + elif path_1.endswith(".safetensors") and path_2.endswith(".safetensors"): + safeloras_1 = safe_open(path_1, framework="pt", device="cpu") + safeloras_2 = safe_open(path_2, framework="pt", device="cpu") + + metadata = dict(safeloras_1.metadata()) + metadata.update(dict(safeloras_2.metadata())) + + ret_tensor = {} + + for keys in set(list(safeloras_1.keys()) + list(safeloras_2.keys())): + if keys.startswith("text_encoder") or keys.startswith("unet"): + + tens1 = safeloras_1.get_tensor(keys) + tens2 = safeloras_2.get_tensor(keys) + + tens = alpha_1 * tens1 + alpha_2 * tens2 + ret_tensor[keys] = tens + else: + if keys in safeloras_1.keys(): + + tens1 = safeloras_1.get_tensor(keys) + else: + tens1 = safeloras_2.get_tensor(keys) + + ret_tensor[keys] = tens1 + + save_file(ret_tensor, output_path, metadata) + + elif mode == "upl": + + print( + f"Merging UNET/CLIP from {path_1} with LoRA from {path_2} to {output_path}. Merging ratio : {alpha_1}." + ) + + loaded_pipeline = StableDiffusionPipeline.from_pretrained( + path_1, + ).to("cpu") + + patch_pipe(loaded_pipeline, path_2) + + collapse_lora(loaded_pipeline.unet, alpha_1) + collapse_lora(loaded_pipeline.text_encoder, alpha_1) + + monkeypatch_remove_lora(loaded_pipeline.unet) + monkeypatch_remove_lora(loaded_pipeline.text_encoder) + + loaded_pipeline.save_pretrained(output_path) + + elif mode == "upl-ckpt-v2": + + assert output_path.endswith(".ckpt"), "Only .ckpt files are supported" + name = os.path.basename(output_path)[0:-5] + + print( + f"You will be using {name} as the token in A1111 webui. Make sure {name} is unique enough token." + ) + + loaded_pipeline = StableDiffusionPipeline.from_pretrained( + path_1, + ).to("cpu") + + tok_dict = patch_pipe(loaded_pipeline, path_2, patch_ti=False) + + collapse_lora(loaded_pipeline.unet, alpha_1) + collapse_lora(loaded_pipeline.text_encoder, alpha_1) + + monkeypatch_remove_lora(loaded_pipeline.unet) + monkeypatch_remove_lora(loaded_pipeline.text_encoder) + + _tmp_output = output_path + ".tmp" + + loaded_pipeline.save_pretrained(_tmp_output) + convert_to_ckpt(_tmp_output, output_path, as_half=True) + # remove the tmp_output folder + shutil.rmtree(_tmp_output) + + keys = sorted(tok_dict.keys()) + tok_catted = torch.stack([tok_dict[k] for k in keys]) + ret = { + "string_to_token": {"*": torch.tensor(265)}, + "string_to_param": {"*": tok_catted}, + "name": name, + } + + torch.save(ret, output_path[:-5] + ".pt") + print( + f"Textual embedding saved as {output_path[:-5]}.pt, put it in the embedding folder and use it as {name} in A1111 repo, " + ) + elif mode == "ljl": + print("Using Join mode : alpha will not have an effect here.") + assert path_1.endswith(".safetensors") and path_2.endswith( + ".safetensors" + ), "Only .safetensors files are supported" + + safeloras_1 = safe_open(path_1, framework="pt", device="cpu") + safeloras_2 = safe_open(path_2, framework="pt", device="cpu") + + total_tensor, total_metadata, _, _ = lora_join([safeloras_1, safeloras_2]) + save_file(total_tensor, output_path, total_metadata) + + else: + print("Unknown mode", mode) + raise ValueError(f"Unknown mode {mode}") + + +def main(): + fire.Fire(add) diff --git a/lora_diffusion/cli_lora_pti.py b/lora_diffusion/cli_lora_pti.py new file mode 100644 index 0000000000000000000000000000000000000000..7de4bae1506d9959708f6af49893217810520f05 --- /dev/null +++ b/lora_diffusion/cli_lora_pti.py @@ -0,0 +1,1040 @@ +# Bootstrapped from: +# https://github.com/huggingface/diffusers/blob/main/examples/dreambooth/train_dreambooth.py + +import argparse +import hashlib +import inspect +import itertools +import math +import os +import random +import re +from pathlib import Path +from typing import Optional, List, Literal + +import torch +import torch.nn.functional as F +import torch.optim as optim +import torch.utils.checkpoint +from diffusers import ( + AutoencoderKL, + DDPMScheduler, + StableDiffusionPipeline, + UNet2DConditionModel, +) +from diffusers.optimization import get_scheduler +from huggingface_hub import HfFolder, Repository, whoami +from PIL import Image +from torch.utils.data import Dataset +from torchvision import transforms +from tqdm.auto import tqdm +from transformers import CLIPTextModel, CLIPTokenizer +import wandb +import fire + +from lora_diffusion import ( + PivotalTuningDatasetCapation, + extract_lora_ups_down, + inject_trainable_lora, + inject_trainable_lora_extended, + inspect_lora, + save_lora_weight, + save_all, + prepare_clip_model_sets, + evaluate_pipe, + UNET_EXTENDED_TARGET_REPLACE, +) + + +def get_models( + pretrained_model_name_or_path, + pretrained_vae_name_or_path, + revision, + placeholder_tokens: List[str], + initializer_tokens: List[str], + device="cuda:0", +): + + tokenizer = CLIPTokenizer.from_pretrained( + pretrained_model_name_or_path, + subfolder="tokenizer", + revision=revision, + ) + + text_encoder = CLIPTextModel.from_pretrained( + pretrained_model_name_or_path, + subfolder="text_encoder", + revision=revision, + ) + + placeholder_token_ids = [] + + for token, init_tok in zip(placeholder_tokens, initializer_tokens): + num_added_tokens = tokenizer.add_tokens(token) + if num_added_tokens == 0: + raise ValueError( + f"The tokenizer already contains the token {token}. Please pass a different" + " `placeholder_token` that is not already in the tokenizer." + ) + + placeholder_token_id = tokenizer.convert_tokens_to_ids(token) + + placeholder_token_ids.append(placeholder_token_id) + + # Load models and create wrapper for stable diffusion + + text_encoder.resize_token_embeddings(len(tokenizer)) + token_embeds = text_encoder.get_input_embeddings().weight.data + if init_tok.startswith(", e.g. + sigma_val = float(re.findall(r"", init_tok)[0]) + + token_embeds[placeholder_token_id] = ( + torch.randn_like(token_embeds[0]) * sigma_val + ) + print( + f"Initialized {token} with random noise (sigma={sigma_val}), empirically {token_embeds[placeholder_token_id].mean().item():.3f} +- {token_embeds[placeholder_token_id].std().item():.3f}" + ) + print(f"Norm : {token_embeds[placeholder_token_id].norm():.4f}") + + elif init_tok == "": + token_embeds[placeholder_token_id] = torch.zeros_like(token_embeds[0]) + else: + token_ids = tokenizer.encode(init_tok, add_special_tokens=False) + # Check if initializer_token is a single token or a sequence of tokens + if len(token_ids) > 1: + raise ValueError("The initializer token must be a single token.") + + initializer_token_id = token_ids[0] + token_embeds[placeholder_token_id] = token_embeds[initializer_token_id] + + vae = AutoencoderKL.from_pretrained( + pretrained_vae_name_or_path or pretrained_model_name_or_path, + subfolder=None if pretrained_vae_name_or_path else "vae", + revision=None if pretrained_vae_name_or_path else revision, + ) + unet = UNet2DConditionModel.from_pretrained( + pretrained_model_name_or_path, + subfolder="unet", + revision=revision, + ) + + return ( + text_encoder.to(device), + vae.to(device), + unet.to(device), + tokenizer, + placeholder_token_ids, + ) + + +@torch.no_grad() +def text2img_dataloader( + train_dataset, + train_batch_size, + tokenizer, + vae, + text_encoder, + cached_latents: bool = False, +): + + if cached_latents: + cached_latents_dataset = [] + for idx in tqdm(range(len(train_dataset))): + batch = train_dataset[idx] + # rint(batch) + latents = vae.encode( + batch["instance_images"].unsqueeze(0).to(dtype=vae.dtype).to(vae.device) + ).latent_dist.sample() + latents = latents * 0.18215 + batch["instance_images"] = latents.squeeze(0) + cached_latents_dataset.append(batch) + + def collate_fn(examples): + input_ids = [example["instance_prompt_ids"] for example in examples] + pixel_values = [example["instance_images"] for example in examples] + pixel_values = torch.stack(pixel_values) + pixel_values = pixel_values.to(memory_format=torch.contiguous_format).float() + + input_ids = tokenizer.pad( + {"input_ids": input_ids}, + padding="max_length", + max_length=tokenizer.model_max_length, + return_tensors="pt", + ).input_ids + + batch = { + "input_ids": input_ids, + "pixel_values": pixel_values, + } + + if examples[0].get("mask", None) is not None: + batch["mask"] = torch.stack([example["mask"] for example in examples]) + + return batch + + if cached_latents: + + train_dataloader = torch.utils.data.DataLoader( + cached_latents_dataset, + batch_size=train_batch_size, + shuffle=True, + collate_fn=collate_fn, + ) + + print("PTI : Using cached latent.") + + else: + train_dataloader = torch.utils.data.DataLoader( + train_dataset, + batch_size=train_batch_size, + shuffle=True, + collate_fn=collate_fn, + ) + + return train_dataloader + + +def inpainting_dataloader( + train_dataset, train_batch_size, tokenizer, vae, text_encoder +): + def collate_fn(examples): + input_ids = [example["instance_prompt_ids"] for example in examples] + pixel_values = [example["instance_images"] for example in examples] + mask_values = [example["instance_masks"] for example in examples] + masked_image_values = [ + example["instance_masked_images"] for example in examples + ] + + # Concat class and instance examples for prior preservation. + # We do this to avoid doing two forward passes. + if examples[0].get("class_prompt_ids", None) is not None: + input_ids += [example["class_prompt_ids"] for example in examples] + pixel_values += [example["class_images"] for example in examples] + mask_values += [example["class_masks"] for example in examples] + masked_image_values += [ + example["class_masked_images"] for example in examples + ] + + pixel_values = ( + torch.stack(pixel_values).to(memory_format=torch.contiguous_format).float() + ) + mask_values = ( + torch.stack(mask_values).to(memory_format=torch.contiguous_format).float() + ) + masked_image_values = ( + torch.stack(masked_image_values) + .to(memory_format=torch.contiguous_format) + .float() + ) + + input_ids = tokenizer.pad( + {"input_ids": input_ids}, + padding="max_length", + max_length=tokenizer.model_max_length, + return_tensors="pt", + ).input_ids + + batch = { + "input_ids": input_ids, + "pixel_values": pixel_values, + "mask_values": mask_values, + "masked_image_values": masked_image_values, + } + + if examples[0].get("mask", None) is not None: + batch["mask"] = torch.stack([example["mask"] for example in examples]) + + return batch + + train_dataloader = torch.utils.data.DataLoader( + train_dataset, + batch_size=train_batch_size, + shuffle=True, + collate_fn=collate_fn, + ) + + return train_dataloader + + +def loss_step( + batch, + unet, + vae, + text_encoder, + scheduler, + train_inpainting=False, + t_mutliplier=1.0, + mixed_precision=False, + mask_temperature=1.0, + cached_latents: bool = False, +): + weight_dtype = torch.float32 + if not cached_latents: + latents = vae.encode( + batch["pixel_values"].to(dtype=weight_dtype).to(unet.device) + ).latent_dist.sample() + latents = latents * 0.18215 + + if train_inpainting: + masked_image_latents = vae.encode( + batch["masked_image_values"].to(dtype=weight_dtype).to(unet.device) + ).latent_dist.sample() + masked_image_latents = masked_image_latents * 0.18215 + mask = F.interpolate( + batch["mask_values"].to(dtype=weight_dtype).to(unet.device), + scale_factor=1 / 8, + ) + else: + latents = batch["pixel_values"] + + if train_inpainting: + masked_image_latents = batch["masked_image_latents"] + mask = batch["mask_values"] + + noise = torch.randn_like(latents) + bsz = latents.shape[0] + + timesteps = torch.randint( + 0, + int(scheduler.config.num_train_timesteps * t_mutliplier), + (bsz,), + device=latents.device, + ) + timesteps = timesteps.long() + + noisy_latents = scheduler.add_noise(latents, noise, timesteps) + + if train_inpainting: + latent_model_input = torch.cat( + [noisy_latents, mask, masked_image_latents], dim=1 + ) + else: + latent_model_input = noisy_latents + + if mixed_precision: + with torch.cuda.amp.autocast(): + + encoder_hidden_states = text_encoder( + batch["input_ids"].to(text_encoder.device) + )[0] + + model_pred = unet( + latent_model_input, timesteps, encoder_hidden_states + ).sample + else: + + encoder_hidden_states = text_encoder( + batch["input_ids"].to(text_encoder.device) + )[0] + + model_pred = unet(latent_model_input, timesteps, encoder_hidden_states).sample + + if scheduler.config.prediction_type == "epsilon": + target = noise + elif scheduler.config.prediction_type == "v_prediction": + target = scheduler.get_velocity(latents, noise, timesteps) + else: + raise ValueError(f"Unknown prediction type {scheduler.config.prediction_type}") + + if batch.get("mask", None) is not None: + + mask = ( + batch["mask"] + .to(model_pred.device) + .reshape( + model_pred.shape[0], 1, model_pred.shape[2] * 8, model_pred.shape[3] * 8 + ) + ) + # resize to match model_pred + mask = F.interpolate( + mask.float(), + size=model_pred.shape[-2:], + mode="nearest", + ) + + mask = (mask + 0.01).pow(mask_temperature) + + mask = mask / mask.max() + + model_pred = model_pred * mask + + target = target * mask + + loss = ( + F.mse_loss(model_pred.float(), target.float(), reduction="none") + .mean([1, 2, 3]) + .mean() + ) + + return loss + + +def train_inversion( + unet, + vae, + text_encoder, + dataloader, + num_steps: int, + scheduler, + index_no_updates, + optimizer, + save_steps: int, + placeholder_token_ids, + placeholder_tokens, + save_path: str, + tokenizer, + lr_scheduler, + test_image_path: str, + cached_latents: bool, + accum_iter: int = 1, + log_wandb: bool = False, + wandb_log_prompt_cnt: int = 10, + class_token: str = "person", + train_inpainting: bool = False, + mixed_precision: bool = False, + clip_ti_decay: bool = True, +): + + progress_bar = tqdm(range(num_steps)) + progress_bar.set_description("Steps") + global_step = 0 + + # Original Emb for TI + orig_embeds_params = text_encoder.get_input_embeddings().weight.data.clone() + + if log_wandb: + preped_clip = prepare_clip_model_sets() + + index_updates = ~index_no_updates + loss_sum = 0.0 + + for epoch in range(math.ceil(num_steps / len(dataloader))): + unet.eval() + text_encoder.train() + for batch in dataloader: + + lr_scheduler.step() + + with torch.set_grad_enabled(True): + loss = ( + loss_step( + batch, + unet, + vae, + text_encoder, + scheduler, + train_inpainting=train_inpainting, + mixed_precision=mixed_precision, + cached_latents=cached_latents, + ) + / accum_iter + ) + + loss.backward() + loss_sum += loss.detach().item() + + if global_step % accum_iter == 0: + # print gradient of text encoder embedding + print( + text_encoder.get_input_embeddings() + .weight.grad[index_updates, :] + .norm(dim=-1) + .mean() + ) + optimizer.step() + optimizer.zero_grad() + + with torch.no_grad(): + + # normalize embeddings + if clip_ti_decay: + pre_norm = ( + text_encoder.get_input_embeddings() + .weight[index_updates, :] + .norm(dim=-1, keepdim=True) + ) + + lambda_ = min(1.0, 100 * lr_scheduler.get_last_lr()[0]) + text_encoder.get_input_embeddings().weight[ + index_updates + ] = F.normalize( + text_encoder.get_input_embeddings().weight[ + index_updates, : + ], + dim=-1, + ) * ( + pre_norm + lambda_ * (0.4 - pre_norm) + ) + print(pre_norm) + + current_norm = ( + text_encoder.get_input_embeddings() + .weight[index_updates, :] + .norm(dim=-1) + ) + + text_encoder.get_input_embeddings().weight[ + index_no_updates + ] = orig_embeds_params[index_no_updates] + + print(f"Current Norm : {current_norm}") + + global_step += 1 + progress_bar.update(1) + + logs = { + "loss": loss.detach().item(), + "lr": lr_scheduler.get_last_lr()[0], + } + progress_bar.set_postfix(**logs) + + if global_step % save_steps == 0: + save_all( + unet=unet, + text_encoder=text_encoder, + placeholder_token_ids=placeholder_token_ids, + placeholder_tokens=placeholder_tokens, + save_path=os.path.join( + save_path, f"step_inv_{global_step}.safetensors" + ), + save_lora=False, + ) + if log_wandb: + with torch.no_grad(): + pipe = StableDiffusionPipeline( + vae=vae, + text_encoder=text_encoder, + tokenizer=tokenizer, + unet=unet, + scheduler=scheduler, + safety_checker=None, + feature_extractor=None, + ) + + # open all images in test_image_path + images = [] + for file in os.listdir(test_image_path): + if ( + file.lower().endswith(".png") + or file.lower().endswith(".jpg") + or file.lower().endswith(".jpeg") + ): + images.append( + Image.open(os.path.join(test_image_path, file)) + ) + + wandb.log({"loss": loss_sum / save_steps}) + loss_sum = 0.0 + wandb.log( + evaluate_pipe( + pipe, + target_images=images, + class_token=class_token, + learnt_token="".join(placeholder_tokens), + n_test=wandb_log_prompt_cnt, + n_step=50, + clip_model_sets=preped_clip, + ) + ) + + if global_step >= num_steps: + return + + +def perform_tuning( + unet, + vae, + text_encoder, + dataloader, + num_steps, + scheduler, + optimizer, + save_steps: int, + placeholder_token_ids, + placeholder_tokens, + save_path, + lr_scheduler_lora, + lora_unet_target_modules, + lora_clip_target_modules, + mask_temperature, + out_name: str, + tokenizer, + test_image_path: str, + cached_latents: bool, + log_wandb: bool = False, + wandb_log_prompt_cnt: int = 10, + class_token: str = "person", + train_inpainting: bool = False, +): + + progress_bar = tqdm(range(num_steps)) + progress_bar.set_description("Steps") + global_step = 0 + + weight_dtype = torch.float16 + + unet.train() + text_encoder.train() + + if log_wandb: + preped_clip = prepare_clip_model_sets() + + loss_sum = 0.0 + + for epoch in range(math.ceil(num_steps / len(dataloader))): + for batch in dataloader: + lr_scheduler_lora.step() + + optimizer.zero_grad() + + loss = loss_step( + batch, + unet, + vae, + text_encoder, + scheduler, + train_inpainting=train_inpainting, + t_mutliplier=0.8, + mixed_precision=True, + mask_temperature=mask_temperature, + cached_latents=cached_latents, + ) + loss_sum += loss.detach().item() + + loss.backward() + torch.nn.utils.clip_grad_norm_( + itertools.chain(unet.parameters(), text_encoder.parameters()), 1.0 + ) + optimizer.step() + progress_bar.update(1) + logs = { + "loss": loss.detach().item(), + "lr": lr_scheduler_lora.get_last_lr()[0], + } + progress_bar.set_postfix(**logs) + + global_step += 1 + + if global_step % save_steps == 0: + save_all( + unet, + text_encoder, + placeholder_token_ids=placeholder_token_ids, + placeholder_tokens=placeholder_tokens, + save_path=os.path.join( + save_path, f"step_{global_step}.safetensors" + ), + target_replace_module_text=lora_clip_target_modules, + target_replace_module_unet=lora_unet_target_modules, + ) + moved = ( + torch.tensor(list(itertools.chain(*inspect_lora(unet).values()))) + .mean() + .item() + ) + + print("LORA Unet Moved", moved) + moved = ( + torch.tensor( + list(itertools.chain(*inspect_lora(text_encoder).values())) + ) + .mean() + .item() + ) + + print("LORA CLIP Moved", moved) + + if log_wandb: + with torch.no_grad(): + pipe = StableDiffusionPipeline( + vae=vae, + text_encoder=text_encoder, + tokenizer=tokenizer, + unet=unet, + scheduler=scheduler, + safety_checker=None, + feature_extractor=None, + ) + + # open all images in test_image_path + images = [] + for file in os.listdir(test_image_path): + if file.endswith(".png") or file.endswith(".jpg"): + images.append( + Image.open(os.path.join(test_image_path, file)) + ) + + wandb.log({"loss": loss_sum / save_steps}) + loss_sum = 0.0 + wandb.log( + evaluate_pipe( + pipe, + target_images=images, + class_token=class_token, + learnt_token="".join(placeholder_tokens), + n_test=wandb_log_prompt_cnt, + n_step=50, + clip_model_sets=preped_clip, + ) + ) + + if global_step >= num_steps: + break + + save_all( + unet, + text_encoder, + placeholder_token_ids=placeholder_token_ids, + placeholder_tokens=placeholder_tokens, + save_path=os.path.join(save_path, f"{out_name}.safetensors"), + target_replace_module_text=lora_clip_target_modules, + target_replace_module_unet=lora_unet_target_modules, + ) + + +def train( + instance_data_dir: str, + pretrained_model_name_or_path: str, + output_dir: str, + train_text_encoder: bool = True, + pretrained_vae_name_or_path: str = None, + revision: Optional[str] = None, + perform_inversion: bool = True, + use_template: Literal[None, "object", "style"] = None, + train_inpainting: bool = False, + placeholder_tokens: str = "", + placeholder_token_at_data: Optional[str] = None, + initializer_tokens: Optional[str] = None, + seed: int = 42, + resolution: int = 512, + color_jitter: bool = True, + train_batch_size: int = 1, + sample_batch_size: int = 1, + max_train_steps_tuning: int = 1000, + max_train_steps_ti: int = 1000, + save_steps: int = 100, + gradient_accumulation_steps: int = 4, + gradient_checkpointing: bool = False, + lora_rank: int = 4, + lora_unet_target_modules={"CrossAttention", "Attention", "GEGLU"}, + lora_clip_target_modules={"CLIPAttention"}, + lora_dropout_p: float = 0.0, + lora_scale: float = 1.0, + use_extended_lora: bool = False, + clip_ti_decay: bool = True, + learning_rate_unet: float = 1e-4, + learning_rate_text: float = 1e-5, + learning_rate_ti: float = 5e-4, + continue_inversion: bool = False, + continue_inversion_lr: Optional[float] = None, + use_face_segmentation_condition: bool = False, + cached_latents: bool = True, + use_mask_captioned_data: bool = False, + mask_temperature: float = 1.0, + scale_lr: bool = False, + lr_scheduler: str = "linear", + lr_warmup_steps: int = 0, + lr_scheduler_lora: str = "linear", + lr_warmup_steps_lora: int = 0, + weight_decay_ti: float = 0.00, + weight_decay_lora: float = 0.001, + use_8bit_adam: bool = False, + device="cuda:0", + extra_args: Optional[dict] = None, + log_wandb: bool = False, + wandb_log_prompt_cnt: int = 10, + wandb_project_name: str = "new_pti_project", + wandb_entity: str = "new_pti_entity", + proxy_token: str = "person", + enable_xformers_memory_efficient_attention: bool = False, + out_name: str = "final_lora", +): + torch.manual_seed(seed) + + if log_wandb: + wandb.init( + project=wandb_project_name, + entity=wandb_entity, + name=f"steps_{max_train_steps_ti}_lr_{learning_rate_ti}_{instance_data_dir.split('/')[-1]}", + reinit=True, + config={ + **(extra_args if extra_args is not None else {}), + }, + ) + + if output_dir is not None: + os.makedirs(output_dir, exist_ok=True) + # print(placeholder_tokens, initializer_tokens) + if len(placeholder_tokens) == 0: + placeholder_tokens = [] + print("PTI : Placeholder Tokens not given, using null token") + else: + placeholder_tokens = placeholder_tokens.split("|") + + assert ( + sorted(placeholder_tokens) == placeholder_tokens + ), f"Placeholder tokens should be sorted. Use something like {'|'.join(sorted(placeholder_tokens))}'" + + if initializer_tokens is None: + print("PTI : Initializer Tokens not given, doing random inits") + initializer_tokens = [""] * len(placeholder_tokens) + else: + initializer_tokens = initializer_tokens.split("|") + + assert len(initializer_tokens) == len( + placeholder_tokens + ), "Unequal Initializer token for Placeholder tokens." + + if proxy_token is not None: + class_token = proxy_token + class_token = "".join(initializer_tokens) + + if placeholder_token_at_data is not None: + tok, pat = placeholder_token_at_data.split("|") + token_map = {tok: pat} + + else: + token_map = {"DUMMY": "".join(placeholder_tokens)} + + print("PTI : Placeholder Tokens", placeholder_tokens) + print("PTI : Initializer Tokens", initializer_tokens) + + # get the models + text_encoder, vae, unet, tokenizer, placeholder_token_ids = get_models( + pretrained_model_name_or_path, + pretrained_vae_name_or_path, + revision, + placeholder_tokens, + initializer_tokens, + device=device, + ) + + noise_scheduler = DDPMScheduler.from_config( + pretrained_model_name_or_path, subfolder="scheduler" + ) + + if gradient_checkpointing: + unet.enable_gradient_checkpointing() + + if enable_xformers_memory_efficient_attention: + from diffusers.utils.import_utils import is_xformers_available + + if is_xformers_available(): + unet.enable_xformers_memory_efficient_attention() + else: + raise ValueError( + "xformers is not available. Make sure it is installed correctly" + ) + + if scale_lr: + unet_lr = learning_rate_unet * gradient_accumulation_steps * train_batch_size + text_encoder_lr = ( + learning_rate_text * gradient_accumulation_steps * train_batch_size + ) + ti_lr = learning_rate_ti * gradient_accumulation_steps * train_batch_size + else: + unet_lr = learning_rate_unet + text_encoder_lr = learning_rate_text + ti_lr = learning_rate_ti + + train_dataset = PivotalTuningDatasetCapation( + instance_data_root=instance_data_dir, + token_map=token_map, + use_template=use_template, + tokenizer=tokenizer, + size=resolution, + color_jitter=color_jitter, + use_face_segmentation_condition=use_face_segmentation_condition, + use_mask_captioned_data=use_mask_captioned_data, + train_inpainting=train_inpainting, + ) + + train_dataset.blur_amount = 200 + + if train_inpainting: + assert not cached_latents, "Cached latents not supported for inpainting" + + train_dataloader = inpainting_dataloader( + train_dataset, train_batch_size, tokenizer, vae, text_encoder + ) + else: + train_dataloader = text2img_dataloader( + train_dataset, + train_batch_size, + tokenizer, + vae, + text_encoder, + cached_latents=cached_latents, + ) + + index_no_updates = torch.arange(len(tokenizer)) != -1 + + for tok_id in placeholder_token_ids: + index_no_updates[tok_id] = False + + unet.requires_grad_(False) + vae.requires_grad_(False) + + params_to_freeze = itertools.chain( + text_encoder.text_model.encoder.parameters(), + text_encoder.text_model.final_layer_norm.parameters(), + text_encoder.text_model.embeddings.position_embedding.parameters(), + ) + for param in params_to_freeze: + param.requires_grad = False + + if cached_latents: + vae = None + # STEP 1 : Perform Inversion + if perform_inversion: + ti_optimizer = optim.AdamW( + text_encoder.get_input_embeddings().parameters(), + lr=ti_lr, + betas=(0.9, 0.999), + eps=1e-08, + weight_decay=weight_decay_ti, + ) + + lr_scheduler = get_scheduler( + lr_scheduler, + optimizer=ti_optimizer, + num_warmup_steps=lr_warmup_steps, + num_training_steps=max_train_steps_ti, + ) + + train_inversion( + unet, + vae, + text_encoder, + train_dataloader, + max_train_steps_ti, + cached_latents=cached_latents, + accum_iter=gradient_accumulation_steps, + scheduler=noise_scheduler, + index_no_updates=index_no_updates, + optimizer=ti_optimizer, + lr_scheduler=lr_scheduler, + save_steps=save_steps, + placeholder_tokens=placeholder_tokens, + placeholder_token_ids=placeholder_token_ids, + save_path=output_dir, + test_image_path=instance_data_dir, + log_wandb=log_wandb, + wandb_log_prompt_cnt=wandb_log_prompt_cnt, + class_token=class_token, + train_inpainting=train_inpainting, + mixed_precision=False, + tokenizer=tokenizer, + clip_ti_decay=clip_ti_decay, + ) + + del ti_optimizer + + # Next perform Tuning with LoRA: + if not use_extended_lora: + unet_lora_params, _ = inject_trainable_lora( + unet, + r=lora_rank, + target_replace_module=lora_unet_target_modules, + dropout_p=lora_dropout_p, + scale=lora_scale, + ) + else: + print("PTI : USING EXTENDED UNET!!!") + lora_unet_target_modules = ( + lora_unet_target_modules | UNET_EXTENDED_TARGET_REPLACE + ) + print("PTI : Will replace modules: ", lora_unet_target_modules) + + unet_lora_params, _ = inject_trainable_lora_extended( + unet, r=lora_rank, target_replace_module=lora_unet_target_modules + ) + print(f"PTI : has {len(unet_lora_params)} lora") + + print("PTI : Before training:") + inspect_lora(unet) + + params_to_optimize = [ + {"params": itertools.chain(*unet_lora_params), "lr": unet_lr}, + ] + + text_encoder.requires_grad_(False) + + if continue_inversion: + params_to_optimize += [ + { + "params": text_encoder.get_input_embeddings().parameters(), + "lr": continue_inversion_lr + if continue_inversion_lr is not None + else ti_lr, + } + ] + text_encoder.requires_grad_(True) + params_to_freeze = itertools.chain( + text_encoder.text_model.encoder.parameters(), + text_encoder.text_model.final_layer_norm.parameters(), + text_encoder.text_model.embeddings.position_embedding.parameters(), + ) + for param in params_to_freeze: + param.requires_grad = False + else: + text_encoder.requires_grad_(False) + if train_text_encoder: + text_encoder_lora_params, _ = inject_trainable_lora( + text_encoder, + target_replace_module=lora_clip_target_modules, + r=lora_rank, + ) + params_to_optimize += [ + { + "params": itertools.chain(*text_encoder_lora_params), + "lr": text_encoder_lr, + } + ] + inspect_lora(text_encoder) + + lora_optimizers = optim.AdamW(params_to_optimize, weight_decay=weight_decay_lora) + + unet.train() + if train_text_encoder: + text_encoder.train() + + train_dataset.blur_amount = 70 + + lr_scheduler_lora = get_scheduler( + lr_scheduler_lora, + optimizer=lora_optimizers, + num_warmup_steps=lr_warmup_steps_lora, + num_training_steps=max_train_steps_tuning, + ) + + perform_tuning( + unet, + vae, + text_encoder, + train_dataloader, + max_train_steps_tuning, + cached_latents=cached_latents, + scheduler=noise_scheduler, + optimizer=lora_optimizers, + save_steps=save_steps, + placeholder_tokens=placeholder_tokens, + placeholder_token_ids=placeholder_token_ids, + save_path=output_dir, + lr_scheduler_lora=lr_scheduler_lora, + lora_unet_target_modules=lora_unet_target_modules, + lora_clip_target_modules=lora_clip_target_modules, + mask_temperature=mask_temperature, + tokenizer=tokenizer, + out_name=out_name, + test_image_path=instance_data_dir, + log_wandb=log_wandb, + wandb_log_prompt_cnt=wandb_log_prompt_cnt, + class_token=class_token, + train_inpainting=train_inpainting, + ) + + +def main(): + fire.Fire(train) diff --git a/lora_diffusion/cli_pt_to_safetensors.py b/lora_diffusion/cli_pt_to_safetensors.py new file mode 100644 index 0000000000000000000000000000000000000000..9a4be40d6f950bc24b771db31d9c0e00934a5e71 --- /dev/null +++ b/lora_diffusion/cli_pt_to_safetensors.py @@ -0,0 +1,85 @@ +import os + +import fire +import torch +from lora_diffusion import ( + DEFAULT_TARGET_REPLACE, + TEXT_ENCODER_DEFAULT_TARGET_REPLACE, + UNET_DEFAULT_TARGET_REPLACE, + convert_loras_to_safeloras_with_embeds, + safetensors_available, +) + +_target_by_name = { + "unet": UNET_DEFAULT_TARGET_REPLACE, + "text_encoder": TEXT_ENCODER_DEFAULT_TARGET_REPLACE, +} + + +def convert(*paths, outpath, overwrite=False, **settings): + """ + Converts one or more pytorch Lora and/or Textual Embedding pytorch files + into a safetensor file. + + Pass all the input paths as arguments. Whether they are Textual Embedding + or Lora models will be auto-detected. + + For Lora models, their name will be taken from the path, i.e. + "lora_weight.pt" => unet + "lora_weight.text_encoder.pt" => text_encoder + + You can also set target_modules and/or rank by providing an argument prefixed + by the name. + + So a complete example might be something like: + + ``` + python -m lora_diffusion.cli_pt_to_safetensors lora_weight.* --outpath lora_weight.safetensor --unet.rank 8 + ``` + """ + modelmap = {} + embeds = {} + + if os.path.exists(outpath) and not overwrite: + raise ValueError( + f"Output path {outpath} already exists, and overwrite is not True" + ) + + for path in paths: + data = torch.load(path) + + if isinstance(data, dict): + print(f"Loading textual inversion embeds {data.keys()} from {path}") + embeds.update(data) + + else: + name_parts = os.path.split(path)[1].split(".") + name = name_parts[-2] if len(name_parts) > 2 else "unet" + + model_settings = { + "target_modules": _target_by_name.get(name, DEFAULT_TARGET_REPLACE), + "rank": 4, + } + + prefix = f"{name}." + + arg_settings = { k[len(prefix) :]: v for k, v in settings.items() if k.startswith(prefix) } + model_settings = { **model_settings, **arg_settings } + + print(f"Loading Lora for {name} from {path} with settings {model_settings}") + + modelmap[name] = ( + path, + model_settings["target_modules"], + model_settings["rank"], + ) + + convert_loras_to_safeloras_with_embeds(modelmap, embeds, outpath) + + +def main(): + fire.Fire(convert) + + +if __name__ == "__main__": + main() diff --git a/lora_diffusion/cli_svd.py b/lora_diffusion/cli_svd.py new file mode 100644 index 0000000000000000000000000000000000000000..cf52aa0b87314f86ac64f1ef7cd457a34fffabd7 --- /dev/null +++ b/lora_diffusion/cli_svd.py @@ -0,0 +1,146 @@ +import fire +from diffusers import StableDiffusionPipeline +import torch +import torch.nn as nn + +from .lora import ( + save_all, + _find_modules, + LoraInjectedConv2d, + LoraInjectedLinear, + inject_trainable_lora, + inject_trainable_lora_extended, +) + + +def _iter_lora(model): + for module in model.modules(): + if isinstance(module, LoraInjectedConv2d) or isinstance( + module, LoraInjectedLinear + ): + yield module + + +def overwrite_base(base_model, tuned_model, rank, clamp_quantile): + device = base_model.device + dtype = base_model.dtype + + for lor_base, lor_tune in zip(_iter_lora(base_model), _iter_lora(tuned_model)): + + if isinstance(lor_base, LoraInjectedLinear): + residual = lor_tune.linear.weight.data - lor_base.linear.weight.data + # SVD on residual + print("Distill Linear shape ", residual.shape) + residual = residual.float() + U, S, Vh = torch.linalg.svd(residual) + U = U[:, :rank] + S = S[:rank] + U = U @ torch.diag(S) + + Vh = Vh[:rank, :] + + dist = torch.cat([U.flatten(), Vh.flatten()]) + hi_val = torch.quantile(dist, clamp_quantile) + low_val = -hi_val + + U = U.clamp(low_val, hi_val) + Vh = Vh.clamp(low_val, hi_val) + + assert lor_base.lora_up.weight.shape == U.shape + assert lor_base.lora_down.weight.shape == Vh.shape + + lor_base.lora_up.weight.data = U.to(device=device, dtype=dtype) + lor_base.lora_down.weight.data = Vh.to(device=device, dtype=dtype) + + if isinstance(lor_base, LoraInjectedConv2d): + residual = lor_tune.conv.weight.data - lor_base.conv.weight.data + print("Distill Conv shape ", residual.shape) + + residual = residual.float() + residual = residual.flatten(start_dim=1) + + # SVD on residual + U, S, Vh = torch.linalg.svd(residual) + U = U[:, :rank] + S = S[:rank] + U = U @ torch.diag(S) + + Vh = Vh[:rank, :] + + dist = torch.cat([U.flatten(), Vh.flatten()]) + hi_val = torch.quantile(dist, clamp_quantile) + low_val = -hi_val + + U = U.clamp(low_val, hi_val) + Vh = Vh.clamp(low_val, hi_val) + + # U is (out_channels, rank) with 1x1 conv. So, + U = U.reshape(U.shape[0], U.shape[1], 1, 1) + # V is (rank, in_channels * kernel_size1 * kernel_size2) + # now reshape: + Vh = Vh.reshape( + Vh.shape[0], + lor_base.conv.in_channels, + lor_base.conv.kernel_size[0], + lor_base.conv.kernel_size[1], + ) + + assert lor_base.lora_up.weight.shape == U.shape + assert lor_base.lora_down.weight.shape == Vh.shape + + lor_base.lora_up.weight.data = U.to(device=device, dtype=dtype) + lor_base.lora_down.weight.data = Vh.to(device=device, dtype=dtype) + + +def svd_distill( + target_model: str, + base_model: str, + rank: int = 4, + clamp_quantile: float = 0.99, + device: str = "cuda:0", + save_path: str = "svd_distill.safetensors", +): + pipe_base = StableDiffusionPipeline.from_pretrained( + base_model, torch_dtype=torch.float16 + ).to(device) + + pipe_tuned = StableDiffusionPipeline.from_pretrained( + target_model, torch_dtype=torch.float16 + ).to(device) + + # Inject unet + _ = inject_trainable_lora_extended(pipe_base.unet, r=rank) + _ = inject_trainable_lora_extended(pipe_tuned.unet, r=rank) + + overwrite_base( + pipe_base.unet, pipe_tuned.unet, rank=rank, clamp_quantile=clamp_quantile + ) + + # Inject text encoder + _ = inject_trainable_lora( + pipe_base.text_encoder, r=rank, target_replace_module={"CLIPAttention"} + ) + _ = inject_trainable_lora( + pipe_tuned.text_encoder, r=rank, target_replace_module={"CLIPAttention"} + ) + + overwrite_base( + pipe_base.text_encoder, + pipe_tuned.text_encoder, + rank=rank, + clamp_quantile=clamp_quantile, + ) + + save_all( + unet=pipe_base.unet, + text_encoder=pipe_base.text_encoder, + placeholder_token_ids=None, + placeholder_tokens=None, + save_path=save_path, + save_lora=True, + save_ti=False, + ) + + +def main(): + fire.Fire(svd_distill) diff --git a/lora_diffusion/dataset.py b/lora_diffusion/dataset.py new file mode 100644 index 0000000000000000000000000000000000000000..f1c28fd719e12442ecd5100da588370a0e5617bc --- /dev/null +++ b/lora_diffusion/dataset.py @@ -0,0 +1,311 @@ +import random +from pathlib import Path +from typing import Dict, List, Optional, Tuple, Union + +from PIL import Image +from torch import zeros_like +from torch.utils.data import Dataset +from torchvision import transforms +import glob +from .preprocess_files import face_mask_google_mediapipe + +OBJECT_TEMPLATE = [ + "a photo of a {}", + "a rendering of a {}", + "a cropped photo of the {}", + "the photo of a {}", + "a photo of a clean {}", + "a photo of a dirty {}", + "a dark photo of the {}", + "a photo of my {}", + "a photo of the cool {}", + "a close-up photo of a {}", + "a bright photo of the {}", + "a cropped photo of a {}", + "a photo of the {}", + "a good photo of the {}", + "a photo of one {}", + "a close-up photo of the {}", + "a rendition of the {}", + "a photo of the clean {}", + "a rendition of a {}", + "a photo of a nice {}", + "a good photo of a {}", + "a photo of the nice {}", + "a photo of the small {}", + "a photo of the weird {}", + "a photo of the large {}", + "a photo of a cool {}", + "a photo of a small {}", +] + +STYLE_TEMPLATE = [ + "a painting in the style of {}", + "a rendering in the style of {}", + "a cropped painting in the style of {}", + "the painting in the style of {}", + "a clean painting in the style of {}", + "a dirty painting in the style of {}", + "a dark painting in the style of {}", + "a picture in the style of {}", + "a cool painting in the style of {}", + "a close-up painting in the style of {}", + "a bright painting in the style of {}", + "a cropped painting in the style of {}", + "a good painting in the style of {}", + "a close-up painting in the style of {}", + "a rendition in the style of {}", + "a nice painting in the style of {}", + "a small painting in the style of {}", + "a weird painting in the style of {}", + "a large painting in the style of {}", +] + +NULL_TEMPLATE = ["{}"] + +TEMPLATE_MAP = { + "object": OBJECT_TEMPLATE, + "style": STYLE_TEMPLATE, + "null": NULL_TEMPLATE, +} + + +def _randomset(lis): + ret = [] + for i in range(len(lis)): + if random.random() < 0.5: + ret.append(lis[i]) + return ret + + +def _shuffle(lis): + + return random.sample(lis, len(lis)) + + +def _get_cutout_holes( + height, + width, + min_holes=8, + max_holes=32, + min_height=16, + max_height=128, + min_width=16, + max_width=128, +): + holes = [] + for _n in range(random.randint(min_holes, max_holes)): + hole_height = random.randint(min_height, max_height) + hole_width = random.randint(min_width, max_width) + y1 = random.randint(0, height - hole_height) + x1 = random.randint(0, width - hole_width) + y2 = y1 + hole_height + x2 = x1 + hole_width + holes.append((x1, y1, x2, y2)) + return holes + + +def _generate_random_mask(image): + mask = zeros_like(image[:1]) + holes = _get_cutout_holes(mask.shape[1], mask.shape[2]) + for (x1, y1, x2, y2) in holes: + mask[:, y1:y2, x1:x2] = 1.0 + if random.uniform(0, 1) < 0.25: + mask.fill_(1.0) + masked_image = image * (mask < 0.5) + return mask, masked_image + + +class PivotalTuningDatasetCapation(Dataset): + """ + A dataset to prepare the instance and class images with the prompts for fine-tuning the model. + It pre-processes the images and the tokenizes prompts. + """ + + def __init__( + self, + instance_data_root, + tokenizer, + token_map: Optional[dict] = None, + use_template: Optional[str] = None, + size=512, + h_flip=True, + color_jitter=False, + resize=True, + use_mask_captioned_data=False, + use_face_segmentation_condition=False, + train_inpainting=False, + blur_amount: int = 70, + ): + self.size = size + self.tokenizer = tokenizer + self.resize = resize + self.train_inpainting = train_inpainting + + instance_data_root = Path(instance_data_root) + if not instance_data_root.exists(): + raise ValueError("Instance images root doesn't exists.") + + self.instance_images_path = [] + self.mask_path = [] + + assert not ( + use_mask_captioned_data and use_template + ), "Can't use both mask caption data and template." + + # Prepare the instance images + if use_mask_captioned_data: + src_imgs = glob.glob(str(instance_data_root) + "/*src.jpg") + for f in src_imgs: + idx = int(str(Path(f).stem).split(".")[0]) + mask_path = f"{instance_data_root}/{idx}.mask.png" + + if Path(mask_path).exists(): + self.instance_images_path.append(f) + self.mask_path.append(mask_path) + else: + print(f"Mask not found for {f}") + + self.captions = open(f"{instance_data_root}/caption.txt").readlines() + + else: + possibily_src_images = ( + glob.glob(str(instance_data_root) + "/*.jpg") + + glob.glob(str(instance_data_root) + "/*.png") + + glob.glob(str(instance_data_root) + "/*.jpeg") + ) + possibily_src_images = ( + set(possibily_src_images) + - set(glob.glob(str(instance_data_root) + "/*mask.png")) + - set([str(instance_data_root) + "/caption.txt"]) + ) + + self.instance_images_path = list(set(possibily_src_images)) + self.captions = [ + x.split("/")[-1].split(".")[0] for x in self.instance_images_path + ] + + assert ( + len(self.instance_images_path) > 0 + ), "No images found in the instance data root." + + self.instance_images_path = sorted(self.instance_images_path) + + self.use_mask = use_face_segmentation_condition or use_mask_captioned_data + self.use_mask_captioned_data = use_mask_captioned_data + + if use_face_segmentation_condition: + + for idx in range(len(self.instance_images_path)): + targ = f"{instance_data_root}/{idx}.mask.png" + # see if the mask exists + if not Path(targ).exists(): + print(f"Mask not found for {targ}") + + print( + "Warning : this will pre-process all the images in the instance data root." + ) + + if len(self.mask_path) > 0: + print( + "Warning : masks already exists, but will be overwritten." + ) + + masks = face_mask_google_mediapipe( + [ + Image.open(f).convert("RGB") + for f in self.instance_images_path + ] + ) + for idx, mask in enumerate(masks): + mask.save(f"{instance_data_root}/{idx}.mask.png") + + break + + for idx in range(len(self.instance_images_path)): + self.mask_path.append(f"{instance_data_root}/{idx}.mask.png") + + self.num_instance_images = len(self.instance_images_path) + self.token_map = token_map + + self.use_template = use_template + if use_template is not None: + self.templates = TEMPLATE_MAP[use_template] + + self._length = self.num_instance_images + + self.h_flip = h_flip + self.image_transforms = transforms.Compose( + [ + transforms.Resize( + size, interpolation=transforms.InterpolationMode.BILINEAR + ) + if resize + else transforms.Lambda(lambda x: x), + transforms.ColorJitter(0.1, 0.1) + if color_jitter + else transforms.Lambda(lambda x: x), + transforms.CenterCrop(size), + transforms.ToTensor(), + transforms.Normalize([0.5], [0.5]), + ] + ) + + self.blur_amount = blur_amount + + def __len__(self): + return self._length + + def __getitem__(self, index): + example = {} + instance_image = Image.open( + self.instance_images_path[index % self.num_instance_images] + ) + if not instance_image.mode == "RGB": + instance_image = instance_image.convert("RGB") + example["instance_images"] = self.image_transforms(instance_image) + + if self.train_inpainting: + ( + example["instance_masks"], + example["instance_masked_images"], + ) = _generate_random_mask(example["instance_images"]) + + if self.use_template: + assert self.token_map is not None + input_tok = list(self.token_map.values())[0] + + text = random.choice(self.templates).format(input_tok) + else: + text = self.captions[index % self.num_instance_images].strip() + + if self.token_map is not None: + for token, value in self.token_map.items(): + text = text.replace(token, value) + + print(text) + + if self.use_mask: + example["mask"] = ( + self.image_transforms( + Image.open(self.mask_path[index % self.num_instance_images]) + ) + * 0.5 + + 1.0 + ) + + if self.h_flip and random.random() > 0.5: + hflip = transforms.RandomHorizontalFlip(p=1) + + example["instance_images"] = hflip(example["instance_images"]) + if self.use_mask: + example["mask"] = hflip(example["mask"]) + + example["instance_prompt_ids"] = self.tokenizer( + text, + padding="do_not_pad", + truncation=True, + max_length=self.tokenizer.model_max_length, + ).input_ids + + return example diff --git a/lora_diffusion/lora.py b/lora_diffusion/lora.py new file mode 100644 index 0000000000000000000000000000000000000000..3133640c5c81a35b9f9aff04c5e0f9c5178efe26 --- /dev/null +++ b/lora_diffusion/lora.py @@ -0,0 +1,1076 @@ +import json +import math +from itertools import groupby +from typing import Callable, Dict, List, Optional, Set, Tuple, Type, Union + +import numpy as np +import PIL +import torch +import torch.nn as nn +import torch.nn.functional as F + +try: + from safetensors.torch import safe_open + from safetensors.torch import save_file as safe_save + + safetensors_available = True +except ImportError: + from .safe_open import safe_open + + def safe_save( + tensors: Dict[str, torch.Tensor], + filename: str, + metadata: Optional[Dict[str, str]] = None, + ) -> None: + raise EnvironmentError( + "Saving safetensors requires the safetensors library. Please install with pip or similar." + ) + + safetensors_available = False + + +class LoraInjectedLinear(nn.Module): + def __init__( + self, in_features, out_features, bias=False, r=4, dropout_p=0.1, scale=1.0 + ): + super().__init__() + + if r > min(in_features, out_features): + raise ValueError( + f"LoRA rank {r} must be less or equal than {min(in_features, out_features)}" + ) + self.r = r + self.linear = nn.Linear(in_features, out_features, bias) + self.lora_down = nn.Linear(in_features, r, bias=False) + self.dropout = nn.Dropout(dropout_p) + self.lora_up = nn.Linear(r, out_features, bias=False) + self.scale = scale + self.selector = nn.Identity() + + nn.init.normal_(self.lora_down.weight, std=1 / r) + nn.init.zeros_(self.lora_up.weight) + + def forward(self, input, scale: float = 1.0): + return ( + self.linear(input) + + self.dropout(self.lora_up(self.selector(self.lora_down(input)))) + * scale + ) + + def realize_as_lora(self): + return self.lora_up.weight.data * self.scale, self.lora_down.weight.data + + def set_selector_from_diag(self, diag: torch.Tensor): + # diag is a 1D tensor of size (r,) + assert diag.shape == (self.r,) + self.selector = nn.Linear(self.r, self.r, bias=False) + self.selector.weight.data = torch.diag(diag) + self.selector.weight.data = self.selector.weight.data.to( + self.lora_up.weight.device + ).to(self.lora_up.weight.dtype) + + +class LoraInjectedConv2d(nn.Module): + def __init__( + self, + in_channels: int, + out_channels: int, + kernel_size, + stride=1, + padding=0, + dilation=1, + groups: int = 1, + bias: bool = True, + r: int = 4, + dropout_p: float = 0.1, + scale: float = 1.0, + ): + super().__init__() + if r > min(in_channels, out_channels): + raise ValueError( + f"LoRA rank {r} must be less or equal than {min(in_channels, out_channels)}" + ) + self.r = r + self.conv = nn.Conv2d( + in_channels=in_channels, + out_channels=out_channels, + kernel_size=kernel_size, + stride=stride, + padding=padding, + dilation=dilation, + groups=groups, + bias=bias, + ) + + self.lora_down = nn.Conv2d( + in_channels=in_channels, + out_channels=r, + kernel_size=kernel_size, + stride=stride, + padding=padding, + dilation=dilation, + groups=groups, + bias=False, + ) + self.dropout = nn.Dropout(dropout_p) + self.lora_up = nn.Conv2d( + in_channels=r, + out_channels=out_channels, + kernel_size=1, + stride=1, + padding=0, + bias=False, + ) + self.selector = nn.Identity() + self.scale = scale + + nn.init.normal_(self.lora_down.weight, std=1 / r) + nn.init.zeros_(self.lora_up.weight) + + def forward(self, input, scale: float = 1.0): + return ( + self.conv(input) + + self.dropout(self.lora_up(self.selector(self.lora_down(input)))) + * scale + ) + + def realize_as_lora(self): + return self.lora_up.weight.data * self.scale, self.lora_down.weight.data + + def set_selector_from_diag(self, diag: torch.Tensor): + # diag is a 1D tensor of size (r,) + assert diag.shape == (self.r,) + self.selector = nn.Conv2d( + in_channels=self.r, + out_channels=self.r, + kernel_size=1, + stride=1, + padding=0, + bias=False, + ) + self.selector.weight.data = torch.diag(diag) + + # same device + dtype as lora_up + self.selector.weight.data = self.selector.weight.data.to( + self.lora_up.weight.device + ).to(self.lora_up.weight.dtype) + + +UNET_DEFAULT_TARGET_REPLACE = {"CrossAttention", "Attention", "GEGLU"} + +UNET_EXTENDED_TARGET_REPLACE = {"ResnetBlock2D", "CrossAttention", "Attention", "GEGLU"} + +TEXT_ENCODER_DEFAULT_TARGET_REPLACE = {"CLIPAttention"} + +TEXT_ENCODER_EXTENDED_TARGET_REPLACE = {"CLIPAttention"} + +DEFAULT_TARGET_REPLACE = UNET_DEFAULT_TARGET_REPLACE + +EMBED_FLAG = "" + + + +def _find_modules_v2( + model, + ancestor_class: Optional[Set[str]] = None, + search_class: List[Type[nn.Module]] = [nn.Linear], + exclude_children_of: Optional[List[Type[nn.Module]]] = [ + LoraInjectedLinear, + LoraInjectedConv2d, + ], +): + """ + Find all modules of a certain class (or union of classes) that are direct or + indirect descendants of other modules of a certain class (or union of classes). + + Returns all matching modules, along with the parent of those moduless and the + names they are referenced by. + """ + + # Get the targets we should replace all linears under + if ancestor_class is not None: + ancestors = ( + module + for module in model.modules() + if module.__class__.__name__ in ancestor_class + ) + else: + # this, incase you want to naively iterate over all modules. + ancestors = [module for module in model.modules()] + + # For each target find every linear_class module that isn't a child of a LoraInjectedLinear + for ancestor in ancestors: + for fullname, module in ancestor.named_modules(): + if any([isinstance(module, _class) for _class in search_class]): + # Find the direct parent if this is a descendant, not a child, of target + *path, name = fullname.split(".") + parent = ancestor + while path: + parent = parent.get_submodule(path.pop(0)) + # Skip this linear if it's a child of a LoraInjectedLinear + if exclude_children_of and any( + [isinstance(parent, _class) for _class in exclude_children_of] + ): + continue + # Otherwise, yield it + yield parent, name, module + +_find_modules = _find_modules_v2 + + +def inject_trainable_lora( + model: nn.Module, + target_replace_module: Set[str] = DEFAULT_TARGET_REPLACE, + r: int = 4, + loras=None, # path to lora .pt + verbose: bool = False, + dropout_p: float = 0.0, + scale: float = 1.0, +): + """ + inject lora into model, and returns lora parameter groups. + """ + + require_grad_params = [] + names = [] + + if loras != None: + loras = torch.load(loras) + + for _module, name, _child_module in _find_modules( + model, target_replace_module, search_class=[nn.Linear] + ): + weight = _child_module.weight + bias = _child_module.bias + if verbose: + print("LoRA Injection : injecting lora into ", name) + print("LoRA Injection : weight shape", weight.shape) + _tmp = LoraInjectedLinear( + _child_module.in_features, + _child_module.out_features, + _child_module.bias is not None, + r=r, + dropout_p=dropout_p, + scale=scale, + ) + _tmp.linear.weight = weight + if bias is not None: + _tmp.linear.bias = bias + + # switch the module + _tmp.to(_child_module.weight.device).to(_child_module.weight.dtype) + _module._modules[name] = _tmp + + require_grad_params.append(_module._modules[name].lora_up.parameters()) + require_grad_params.append(_module._modules[name].lora_down.parameters()) + + if loras != None: + _module._modules[name].lora_up.weight = loras.pop(0) + _module._modules[name].lora_down.weight = loras.pop(0) + + _module._modules[name].lora_up.weight.requires_grad = True + _module._modules[name].lora_down.weight.requires_grad = True + names.append(name) + + return require_grad_params, names + + +def inject_trainable_lora_extended( + model: nn.Module, + target_replace_module: Set[str] = UNET_EXTENDED_TARGET_REPLACE, + r: int = 4, + loras=None, # path to lora .pt +): + """ + inject lora into model, and returns lora parameter groups. + """ + + require_grad_params = [] + names = [] + + if loras != None: + loras = torch.load(loras) + + for _module, name, _child_module in _find_modules( + model, target_replace_module, search_class=[nn.Linear, nn.Conv2d] + ): + if _child_module.__class__ == nn.Linear: + weight = _child_module.weight + bias = _child_module.bias + _tmp = LoraInjectedLinear( + _child_module.in_features, + _child_module.out_features, + _child_module.bias is not None, + r=r, + ) + _tmp.linear.weight = weight + if bias is not None: + _tmp.linear.bias = bias + elif _child_module.__class__ == nn.Conv2d: + weight = _child_module.weight + bias = _child_module.bias + _tmp = LoraInjectedConv2d( + _child_module.in_channels, + _child_module.out_channels, + _child_module.kernel_size, + _child_module.stride, + _child_module.padding, + _child_module.dilation, + _child_module.groups, + _child_module.bias is not None, + r=r, + ) + + _tmp.conv.weight = weight + if bias is not None: + _tmp.conv.bias = bias + + # switch the module + _tmp.to(_child_module.weight.device).to(_child_module.weight.dtype) + if bias is not None: + _tmp.to(_child_module.bias.device).to(_child_module.bias.dtype) + + _module._modules[name] = _tmp + + require_grad_params.append(_module._modules[name].lora_up.parameters()) + require_grad_params.append(_module._modules[name].lora_down.parameters()) + + if loras != None: + _module._modules[name].lora_up.weight = loras.pop(0) + _module._modules[name].lora_down.weight = loras.pop(0) + + _module._modules[name].lora_up.weight.requires_grad = True + _module._modules[name].lora_down.weight.requires_grad = True + names.append(name) + + return require_grad_params, names + + +def extract_lora_ups_down(model, target_replace_module=DEFAULT_TARGET_REPLACE): + + loras = [] + + for _m, _n, _child_module in _find_modules( + model, + target_replace_module, + search_class=[LoraInjectedLinear, LoraInjectedConv2d], + ): + loras.append((_child_module.lora_up, _child_module.lora_down)) + + if len(loras) == 0: + raise ValueError("No lora injected.") + + return loras + + +def extract_lora_as_tensor( + model, target_replace_module=DEFAULT_TARGET_REPLACE, as_fp16=True +): + + loras = [] + + for _m, _n, _child_module in _find_modules( + model, + target_replace_module, + search_class=[LoraInjectedLinear, LoraInjectedConv2d], + ): + up, down = _child_module.realize_as_lora() + if as_fp16: + up = up.to(torch.float16) + down = down.to(torch.float16) + + loras.append((up, down)) + + if len(loras) == 0: + raise ValueError("No lora injected.") + + return loras + + +def save_lora_weight( + model, + path="./lora.pt", + target_replace_module=DEFAULT_TARGET_REPLACE, +): + weights = [] + for _up, _down in extract_lora_ups_down( + model, target_replace_module=target_replace_module + ): + weights.append(_up.weight.to("cpu").to(torch.float16)) + weights.append(_down.weight.to("cpu").to(torch.float16)) + + torch.save(weights, path) + + +def save_lora_as_json(model, path="./lora.json"): + weights = [] + for _up, _down in extract_lora_ups_down(model): + weights.append(_up.weight.detach().cpu().numpy().tolist()) + weights.append(_down.weight.detach().cpu().numpy().tolist()) + + import json + + with open(path, "w") as f: + json.dump(weights, f) + + +def save_safeloras_with_embeds( + modelmap: Dict[str, Tuple[nn.Module, Set[str]]] = {}, + embeds: Dict[str, torch.Tensor] = {}, + outpath="./lora.safetensors", +): + """ + Saves the Lora from multiple modules in a single safetensor file. + + modelmap is a dictionary of { + "module name": (module, target_replace_module) + } + """ + weights = {} + metadata = {} + + for name, (model, target_replace_module) in modelmap.items(): + metadata[name] = json.dumps(list(target_replace_module)) + + for i, (_up, _down) in enumerate( + extract_lora_as_tensor(model, target_replace_module) + ): + rank = _down.shape[0] + + metadata[f"{name}:{i}:rank"] = str(rank) + weights[f"{name}:{i}:up"] = _up + weights[f"{name}:{i}:down"] = _down + + for token, tensor in embeds.items(): + metadata[token] = EMBED_FLAG + weights[token] = tensor + + print(f"Saving weights to {outpath}") + safe_save(weights, outpath, metadata) + + +def save_safeloras( + modelmap: Dict[str, Tuple[nn.Module, Set[str]]] = {}, + outpath="./lora.safetensors", +): + return save_safeloras_with_embeds(modelmap=modelmap, outpath=outpath) + + +def convert_loras_to_safeloras_with_embeds( + modelmap: Dict[str, Tuple[str, Set[str], int]] = {}, + embeds: Dict[str, torch.Tensor] = {}, + outpath="./lora.safetensors", +): + """ + Converts the Lora from multiple pytorch .pt files into a single safetensor file. + + modelmap is a dictionary of { + "module name": (pytorch_model_path, target_replace_module, rank) + } + """ + + weights = {} + metadata = {} + + for name, (path, target_replace_module, r) in modelmap.items(): + metadata[name] = json.dumps(list(target_replace_module)) + + lora = torch.load(path) + for i, weight in enumerate(lora): + is_up = i % 2 == 0 + i = i // 2 + + if is_up: + metadata[f"{name}:{i}:rank"] = str(r) + weights[f"{name}:{i}:up"] = weight + else: + weights[f"{name}:{i}:down"] = weight + + for token, tensor in embeds.items(): + metadata[token] = EMBED_FLAG + weights[token] = tensor + + print(f"Saving weights to {outpath}") + safe_save(weights, outpath, metadata) + + +def convert_loras_to_safeloras( + modelmap: Dict[str, Tuple[str, Set[str], int]] = {}, + outpath="./lora.safetensors", +): + convert_loras_to_safeloras_with_embeds(modelmap=modelmap, outpath=outpath) + + +def parse_safeloras( + safeloras, +) -> Dict[str, Tuple[List[nn.parameter.Parameter], List[int], List[str]]]: + """ + Converts a loaded safetensor file that contains a set of module Loras + into Parameters and other information + + Output is a dictionary of { + "module name": ( + [list of weights], + [list of ranks], + target_replacement_modules + ) + } + """ + loras = {} + metadata = safeloras.metadata() + + get_name = lambda k: k.split(":")[0] + + keys = list(safeloras.keys()) + keys.sort(key=get_name) + + for name, module_keys in groupby(keys, get_name): + info = metadata.get(name) + + if not info: + raise ValueError( + f"Tensor {name} has no metadata - is this a Lora safetensor?" + ) + + # Skip Textual Inversion embeds + if info == EMBED_FLAG: + continue + + # Handle Loras + # Extract the targets + target = json.loads(info) + + # Build the result lists - Python needs us to preallocate lists to insert into them + module_keys = list(module_keys) + ranks = [4] * (len(module_keys) // 2) + weights = [None] * len(module_keys) + + for key in module_keys: + # Split the model name and index out of the key + _, idx, direction = key.split(":") + idx = int(idx) + + # Add the rank + ranks[idx] = int(metadata[f"{name}:{idx}:rank"]) + + # Insert the weight into the list + idx = idx * 2 + (1 if direction == "down" else 0) + weights[idx] = nn.parameter.Parameter(safeloras.get_tensor(key)) + + loras[name] = (weights, ranks, target) + + return loras + + +def parse_safeloras_embeds( + safeloras, +) -> Dict[str, torch.Tensor]: + """ + Converts a loaded safetensor file that contains Textual Inversion embeds into + a dictionary of embed_token: Tensor + """ + embeds = {} + metadata = safeloras.metadata() + + for key in safeloras.keys(): + # Only handle Textual Inversion embeds + meta = metadata.get(key) + if not meta or meta != EMBED_FLAG: + continue + + embeds[key] = safeloras.get_tensor(key) + + return embeds + + +def load_safeloras(path, device="cpu"): + safeloras = safe_open(path, framework="pt", device=device) + return parse_safeloras(safeloras) + + +def load_safeloras_embeds(path, device="cpu"): + safeloras = safe_open(path, framework="pt", device=device) + return parse_safeloras_embeds(safeloras) + + +def load_safeloras_both(path, device="cpu"): + safeloras = safe_open(path, framework="pt", device=device) + return parse_safeloras(safeloras), parse_safeloras_embeds(safeloras) + + +def collapse_lora(model, alpha=1.0): + + for _module, name, _child_module in _find_modules( + model, + UNET_EXTENDED_TARGET_REPLACE | TEXT_ENCODER_EXTENDED_TARGET_REPLACE, + search_class=[LoraInjectedLinear, LoraInjectedConv2d], + ): + + if isinstance(_child_module, LoraInjectedLinear): + print("Collapsing Lin Lora in", name) + + _child_module.linear.weight = nn.Parameter( + _child_module.linear.weight.data + + alpha + * ( + _child_module.lora_up.weight.data + @ _child_module.lora_down.weight.data + ) + .type(_child_module.linear.weight.dtype) + .to(_child_module.linear.weight.device) + ) + + else: + print("Collapsing Conv Lora in", name) + _child_module.conv.weight = nn.Parameter( + _child_module.conv.weight.data + + alpha + * ( + _child_module.lora_up.weight.data.flatten(start_dim=1) + @ _child_module.lora_down.weight.data.flatten(start_dim=1) + ) + .reshape(_child_module.conv.weight.data.shape) + .type(_child_module.conv.weight.dtype) + .to(_child_module.conv.weight.device) + ) + + +def monkeypatch_or_replace_lora( + model, + loras, + target_replace_module=DEFAULT_TARGET_REPLACE, + r: Union[int, List[int]] = 4, +): + for _module, name, _child_module in _find_modules( + model, target_replace_module, search_class=[nn.Linear, LoraInjectedLinear] + ): + _source = ( + _child_module.linear + if isinstance(_child_module, LoraInjectedLinear) + else _child_module + ) + + weight = _source.weight + bias = _source.bias + _tmp = LoraInjectedLinear( + _source.in_features, + _source.out_features, + _source.bias is not None, + r=r.pop(0) if isinstance(r, list) else r, + ) + _tmp.linear.weight = weight + + if bias is not None: + _tmp.linear.bias = bias + + # switch the module + _module._modules[name] = _tmp + + up_weight = loras.pop(0) + down_weight = loras.pop(0) + + _module._modules[name].lora_up.weight = nn.Parameter( + up_weight.type(weight.dtype) + ) + _module._modules[name].lora_down.weight = nn.Parameter( + down_weight.type(weight.dtype) + ) + + _module._modules[name].to(weight.device) + + +def monkeypatch_or_replace_lora_extended( + model, + loras, + target_replace_module=DEFAULT_TARGET_REPLACE, + r: Union[int, List[int]] = 4, +): + for _module, name, _child_module in _find_modules( + model, + target_replace_module, + search_class=[nn.Linear, LoraInjectedLinear, nn.Conv2d, LoraInjectedConv2d], + ): + + if (_child_module.__class__ == nn.Linear) or ( + _child_module.__class__ == LoraInjectedLinear + ): + if len(loras[0].shape) != 2: + continue + + _source = ( + _child_module.linear + if isinstance(_child_module, LoraInjectedLinear) + else _child_module + ) + + weight = _source.weight + bias = _source.bias + _tmp = LoraInjectedLinear( + _source.in_features, + _source.out_features, + _source.bias is not None, + r=r.pop(0) if isinstance(r, list) else r, + ) + _tmp.linear.weight = weight + + if bias is not None: + _tmp.linear.bias = bias + + elif (_child_module.__class__ == nn.Conv2d) or ( + _child_module.__class__ == LoraInjectedConv2d + ): + if len(loras[0].shape) != 4: + continue + _source = ( + _child_module.conv + if isinstance(_child_module, LoraInjectedConv2d) + else _child_module + ) + + weight = _source.weight + bias = _source.bias + _tmp = LoraInjectedConv2d( + _source.in_channels, + _source.out_channels, + _source.kernel_size, + _source.stride, + _source.padding, + _source.dilation, + _source.groups, + _source.bias is not None, + r=r.pop(0) if isinstance(r, list) else r, + ) + + _tmp.conv.weight = weight + + if bias is not None: + _tmp.conv.bias = bias + + # switch the module + _module._modules[name] = _tmp + + up_weight = loras.pop(0) + down_weight = loras.pop(0) + + _module._modules[name].lora_up.weight = nn.Parameter( + up_weight.type(weight.dtype) + ) + _module._modules[name].lora_down.weight = nn.Parameter( + down_weight.type(weight.dtype) + ) + + _module._modules[name].to(weight.device) + + +def monkeypatch_or_replace_safeloras(models, safeloras): + loras = parse_safeloras(safeloras) + + for name, (lora, ranks, target) in loras.items(): + model = getattr(models, name, None) + + if not model: + print(f"No model provided for {name}, contained in Lora") + continue + + monkeypatch_or_replace_lora_extended(model, lora, target, ranks) + + +def monkeypatch_remove_lora(model): + for _module, name, _child_module in _find_modules( + model, search_class=[LoraInjectedLinear, LoraInjectedConv2d] + ): + if isinstance(_child_module, LoraInjectedLinear): + _source = _child_module.linear + weight, bias = _source.weight, _source.bias + + _tmp = nn.Linear( + _source.in_features, _source.out_features, bias is not None + ) + + _tmp.weight = weight + if bias is not None: + _tmp.bias = bias + + else: + _source = _child_module.conv + weight, bias = _source.weight, _source.bias + + _tmp = nn.Conv2d( + in_channels=_source.in_channels, + out_channels=_source.out_channels, + kernel_size=_source.kernel_size, + stride=_source.stride, + padding=_source.padding, + dilation=_source.dilation, + groups=_source.groups, + bias=bias is not None, + ) + + _tmp.weight = weight + if bias is not None: + _tmp.bias = bias + + _module._modules[name] = _tmp + + +def monkeypatch_add_lora( + model, + loras, + target_replace_module=DEFAULT_TARGET_REPLACE, + alpha: float = 1.0, + beta: float = 1.0, +): + for _module, name, _child_module in _find_modules( + model, target_replace_module, search_class=[LoraInjectedLinear] + ): + weight = _child_module.linear.weight + + up_weight = loras.pop(0) + down_weight = loras.pop(0) + + _module._modules[name].lora_up.weight = nn.Parameter( + up_weight.type(weight.dtype).to(weight.device) * alpha + + _module._modules[name].lora_up.weight.to(weight.device) * beta + ) + _module._modules[name].lora_down.weight = nn.Parameter( + down_weight.type(weight.dtype).to(weight.device) * alpha + + _module._modules[name].lora_down.weight.to(weight.device) * beta + ) + + _module._modules[name].to(weight.device) + + +def tune_lora_scale(model, alpha: float = 1.0): + for _module in model.modules(): + if _module.__class__.__name__ in ["LoraInjectedLinear", "LoraInjectedConv2d"]: + _module.scale = alpha + + +def set_lora_diag(model, diag: torch.Tensor): + for _module in model.modules(): + if _module.__class__.__name__ in ["LoraInjectedLinear", "LoraInjectedConv2d"]: + _module.set_selector_from_diag(diag) + + +def _text_lora_path(path: str) -> str: + assert path.endswith(".pt"), "Only .pt files are supported" + return ".".join(path.split(".")[:-1] + ["text_encoder", "pt"]) + + +def _ti_lora_path(path: str) -> str: + assert path.endswith(".pt"), "Only .pt files are supported" + return ".".join(path.split(".")[:-1] + ["ti", "pt"]) + + +def apply_learned_embed_in_clip( + learned_embeds, + text_encoder, + tokenizer, + token: Optional[Union[str, List[str]]] = None, + idempotent=False, +): + if isinstance(token, str): + trained_tokens = [token] + elif isinstance(token, list): + assert len(learned_embeds.keys()) == len( + token + ), "The number of tokens and the number of embeds should be the same" + trained_tokens = token + else: + trained_tokens = list(learned_embeds.keys()) + + for token in trained_tokens: + print(token) + embeds = learned_embeds[token] + + # cast to dtype of text_encoder + dtype = text_encoder.get_input_embeddings().weight.dtype + num_added_tokens = tokenizer.add_tokens(token) + + i = 1 + if not idempotent: + while num_added_tokens == 0: + print(f"The tokenizer already contains the token {token}.") + token = f"{token[:-1]}-{i}>" + print(f"Attempting to add the token {token}.") + num_added_tokens = tokenizer.add_tokens(token) + i += 1 + elif num_added_tokens == 0 and idempotent: + print(f"The tokenizer already contains the token {token}.") + print(f"Replacing {token} embedding.") + + # resize the token embeddings + text_encoder.resize_token_embeddings(len(tokenizer)) + + # get the id for the token and assign the embeds + token_id = tokenizer.convert_tokens_to_ids(token) + text_encoder.get_input_embeddings().weight.data[token_id] = embeds + return token + + +def load_learned_embed_in_clip( + learned_embeds_path, + text_encoder, + tokenizer, + token: Optional[Union[str, List[str]]] = None, + idempotent=False, +): + learned_embeds = torch.load(learned_embeds_path) + apply_learned_embed_in_clip( + learned_embeds, text_encoder, tokenizer, token, idempotent + ) + + +def patch_pipe( + pipe, + maybe_unet_path, + token: Optional[str] = None, + r: int = 4, + patch_unet=True, + patch_text=True, + patch_ti=True, + idempotent_token=True, + unet_target_replace_module=DEFAULT_TARGET_REPLACE, + text_target_replace_module=TEXT_ENCODER_DEFAULT_TARGET_REPLACE, +): + if maybe_unet_path.endswith(".pt"): + # torch format + + if maybe_unet_path.endswith(".ti.pt"): + unet_path = maybe_unet_path[:-6] + ".pt" + elif maybe_unet_path.endswith(".text_encoder.pt"): + unet_path = maybe_unet_path[:-16] + ".pt" + else: + unet_path = maybe_unet_path + + ti_path = _ti_lora_path(unet_path) + text_path = _text_lora_path(unet_path) + + if patch_unet: + print("LoRA : Patching Unet") + monkeypatch_or_replace_lora( + pipe.unet, + torch.load(unet_path), + r=r, + target_replace_module=unet_target_replace_module, + ) + + if patch_text: + print("LoRA : Patching text encoder") + monkeypatch_or_replace_lora( + pipe.text_encoder, + torch.load(text_path), + target_replace_module=text_target_replace_module, + r=r, + ) + if patch_ti: + print("LoRA : Patching token input") + token = load_learned_embed_in_clip( + ti_path, + pipe.text_encoder, + pipe.tokenizer, + token=token, + idempotent=idempotent_token, + ) + + elif maybe_unet_path.endswith(".safetensors"): + safeloras = safe_open(maybe_unet_path, framework="pt", device="cpu") + monkeypatch_or_replace_safeloras(pipe, safeloras) + tok_dict = parse_safeloras_embeds(safeloras) + if patch_ti: + apply_learned_embed_in_clip( + tok_dict, + pipe.text_encoder, + pipe.tokenizer, + token=token, + idempotent=idempotent_token, + ) + return tok_dict + + +@torch.no_grad() +def inspect_lora(model): + moved = {} + + for name, _module in model.named_modules(): + if _module.__class__.__name__ in ["LoraInjectedLinear", "LoraInjectedConv2d"]: + ups = _module.lora_up.weight.data.clone() + downs = _module.lora_down.weight.data.clone() + + wght: torch.Tensor = ups.flatten(1) @ downs.flatten(1) + + dist = wght.flatten().abs().mean().item() + if name in moved: + moved[name].append(dist) + else: + moved[name] = [dist] + + return moved + + +def save_all( + unet, + text_encoder, + save_path, + placeholder_token_ids=None, + placeholder_tokens=None, + save_lora=True, + save_ti=True, + target_replace_module_text=TEXT_ENCODER_DEFAULT_TARGET_REPLACE, + target_replace_module_unet=DEFAULT_TARGET_REPLACE, + safe_form=True, +): + if not safe_form: + # save ti + if save_ti: + ti_path = _ti_lora_path(save_path) + learned_embeds_dict = {} + for tok, tok_id in zip(placeholder_tokens, placeholder_token_ids): + learned_embeds = text_encoder.get_input_embeddings().weight[tok_id] + print( + f"Current Learned Embeddings for {tok}:, id {tok_id} ", + learned_embeds[:4], + ) + learned_embeds_dict[tok] = learned_embeds.detach().cpu() + + torch.save(learned_embeds_dict, ti_path) + print("Ti saved to ", ti_path) + + # save text encoder + if save_lora: + + save_lora_weight( + unet, save_path, target_replace_module=target_replace_module_unet + ) + print("Unet saved to ", save_path) + + save_lora_weight( + text_encoder, + _text_lora_path(save_path), + target_replace_module=target_replace_module_text, + ) + print("Text Encoder saved to ", _text_lora_path(save_path)) + + else: + assert save_path.endswith( + ".safetensors" + ), f"Save path : {save_path} should end with .safetensors" + + loras = {} + embeds = {} + + if save_lora: + + loras["unet"] = (unet, target_replace_module_unet) + loras["text_encoder"] = (text_encoder, target_replace_module_text) + + if save_ti: + for tok, tok_id in zip(placeholder_tokens, placeholder_token_ids): + learned_embeds = text_encoder.get_input_embeddings().weight[tok_id] + print( + f"Current Learned Embeddings for {tok}:, id {tok_id} ", + learned_embeds[:4], + ) + embeds[tok] = learned_embeds.detach().cpu() + + save_safeloras_with_embeds(loras, embeds, save_path) diff --git a/lora_diffusion/lora_manager.py b/lora_diffusion/lora_manager.py new file mode 100644 index 0000000000000000000000000000000000000000..9d8306e43cc6e730f7b14f2ba546584fbf81adec --- /dev/null +++ b/lora_diffusion/lora_manager.py @@ -0,0 +1,144 @@ +from typing import List +import torch +from safetensors import safe_open +from diffusers import StableDiffusionPipeline +from .lora import ( + monkeypatch_or_replace_safeloras, + apply_learned_embed_in_clip, + set_lora_diag, + parse_safeloras_embeds, +) + + +def lora_join(lora_safetenors: list): + metadatas = [dict(safelora.metadata()) for safelora in lora_safetenors] + _total_metadata = {} + total_metadata = {} + total_tensor = {} + total_rank = 0 + ranklist = [] + for _metadata in metadatas: + rankset = [] + for k, v in _metadata.items(): + if k.endswith("rank"): + rankset.append(int(v)) + + assert len(set(rankset)) <= 1, "Rank should be the same per model" + if len(rankset) == 0: + rankset = [0] + + total_rank += rankset[0] + _total_metadata.update(_metadata) + ranklist.append(rankset[0]) + + # remove metadata about tokens + for k, v in _total_metadata.items(): + if v != "": + total_metadata[k] = v + + tensorkeys = set() + for safelora in lora_safetenors: + tensorkeys.update(safelora.keys()) + + for keys in tensorkeys: + if keys.startswith("text_encoder") or keys.startswith("unet"): + tensorset = [safelora.get_tensor(keys) for safelora in lora_safetenors] + + is_down = keys.endswith("down") + + if is_down: + _tensor = torch.cat(tensorset, dim=0) + assert _tensor.shape[0] == total_rank + else: + _tensor = torch.cat(tensorset, dim=1) + assert _tensor.shape[1] == total_rank + + total_tensor[keys] = _tensor + keys_rank = ":".join(keys.split(":")[:-1]) + ":rank" + total_metadata[keys_rank] = str(total_rank) + token_size_list = [] + for idx, safelora in enumerate(lora_safetenors): + tokens = [k for k, v in safelora.metadata().items() if v == ""] + for jdx, token in enumerate(sorted(tokens)): + + total_tensor[f""] = safelora.get_tensor(token) + total_metadata[f""] = "" + + print(f"Embedding {token} replaced to ") + + token_size_list.append(len(tokens)) + + return total_tensor, total_metadata, ranklist, token_size_list + + +class DummySafeTensorObject: + def __init__(self, tensor: dict, metadata): + self.tensor = tensor + self._metadata = metadata + + def keys(self): + return self.tensor.keys() + + def metadata(self): + return self._metadata + + def get_tensor(self, key): + return self.tensor[key] + + +class LoRAManager: + def __init__(self, lora_paths_list: List[str], pipe: StableDiffusionPipeline): + + self.lora_paths_list = lora_paths_list + self.pipe = pipe + self._setup() + + def _setup(self): + + self._lora_safetenors = [ + safe_open(path, framework="pt", device="cpu") + for path in self.lora_paths_list + ] + + ( + total_tensor, + total_metadata, + self.ranklist, + self.token_size_list, + ) = lora_join(self._lora_safetenors) + + self.total_safelora = DummySafeTensorObject(total_tensor, total_metadata) + + monkeypatch_or_replace_safeloras(self.pipe, self.total_safelora) + tok_dict = parse_safeloras_embeds(self.total_safelora) + + apply_learned_embed_in_clip( + tok_dict, + self.pipe.text_encoder, + self.pipe.tokenizer, + token=None, + idempotent=True, + ) + + def tune(self, scales): + + assert len(scales) == len( + self.ranklist + ), "Scale list should be the same length as ranklist" + + diags = [] + for scale, rank in zip(scales, self.ranklist): + diags = diags + [scale] * rank + + set_lora_diag(self.pipe.unet, torch.tensor(diags)) + + def prompt(self, prompt): + if prompt is not None: + for idx, tok_size in enumerate(self.token_size_list): + prompt = prompt.replace( + f"<{idx + 1}>", + "".join([f"" for jdx in range(tok_size)]), + ) + # TODO : Rescale LoRA + Text inputs based on prompt scale params + + return prompt diff --git a/lora_diffusion/preprocess_files.py b/lora_diffusion/preprocess_files.py new file mode 100644 index 0000000000000000000000000000000000000000..bedb89f54dd8ad2b2a5b8b3f3eb69ffb763d38b4 --- /dev/null +++ b/lora_diffusion/preprocess_files.py @@ -0,0 +1,327 @@ +# Have SwinIR upsample +# Have BLIP auto caption +# Have CLIPSeg auto mask concept + +from typing import List, Literal, Union, Optional, Tuple +import os +from PIL import Image, ImageFilter +import torch +import numpy as np +import fire +from tqdm import tqdm +import glob +from transformers import CLIPSegProcessor, CLIPSegForImageSegmentation + + +@torch.no_grad() +def swin_ir_sr( + images: List[Image.Image], + model_id: Literal[ + "caidas/swin2SR-classical-sr-x2-64", "caidas/swin2SR-classical-sr-x4-48" + ] = "caidas/swin2SR-classical-sr-x2-64", + target_size: Optional[Tuple[int, int]] = None, + device=torch.device("cuda:0" if torch.cuda.is_available() else "cpu"), + **kwargs, +) -> List[Image.Image]: + """ + Upscales images using SwinIR. Returns a list of PIL images. + """ + # So this is currently in main branch, so this can be used in the future I guess? + from transformers import Swin2SRForImageSuperResolution, Swin2SRImageProcessor + + model = Swin2SRForImageSuperResolution.from_pretrained( + model_id, + ).to(device) + processor = Swin2SRImageProcessor() + + out_images = [] + + for image in tqdm(images): + + ori_w, ori_h = image.size + if target_size is not None: + if ori_w >= target_size[0] and ori_h >= target_size[1]: + out_images.append(image) + continue + + inputs = processor(image, return_tensors="pt").to(device) + with torch.no_grad(): + outputs = model(**inputs) + + output = ( + outputs.reconstruction.data.squeeze().float().cpu().clamp_(0, 1).numpy() + ) + output = np.moveaxis(output, source=0, destination=-1) + output = (output * 255.0).round().astype(np.uint8) + output = Image.fromarray(output) + + out_images.append(output) + + return out_images + + +@torch.no_grad() +def clipseg_mask_generator( + images: List[Image.Image], + target_prompts: Union[List[str], str], + model_id: Literal[ + "CIDAS/clipseg-rd64-refined", "CIDAS/clipseg-rd16" + ] = "CIDAS/clipseg-rd64-refined", + device=torch.device("cuda:0" if torch.cuda.is_available() else "cpu"), + bias: float = 0.01, + temp: float = 1.0, + **kwargs, +) -> List[Image.Image]: + """ + Returns a greyscale mask for each image, where the mask is the probability of the target prompt being present in the image + """ + + if isinstance(target_prompts, str): + print( + f'Warning: only one target prompt "{target_prompts}" was given, so it will be used for all images' + ) + + target_prompts = [target_prompts] * len(images) + + processor = CLIPSegProcessor.from_pretrained(model_id) + model = CLIPSegForImageSegmentation.from_pretrained(model_id).to(device) + + masks = [] + + for image, prompt in tqdm(zip(images, target_prompts)): + + original_size = image.size + + inputs = processor( + text=[prompt, ""], + images=[image] * 2, + padding="max_length", + truncation=True, + return_tensors="pt", + ).to(device) + + outputs = model(**inputs) + + logits = outputs.logits + probs = torch.nn.functional.softmax(logits / temp, dim=0)[0] + probs = (probs + bias).clamp_(0, 1) + probs = 255 * probs / probs.max() + + # make mask greyscale + mask = Image.fromarray(probs.cpu().numpy()).convert("L") + + # resize mask to original size + mask = mask.resize(original_size) + + masks.append(mask) + + return masks + + +@torch.no_grad() +def blip_captioning_dataset( + images: List[Image.Image], + text: Optional[str] = None, + model_id: Literal[ + "Salesforce/blip-image-captioning-large", + "Salesforce/blip-image-captioning-base", + ] = "Salesforce/blip-image-captioning-large", + device=torch.device("cuda" if torch.cuda.is_available() else "cpu"), + **kwargs, +) -> List[str]: + """ + Returns a list of captions for the given images + """ + + from transformers import BlipProcessor, BlipForConditionalGeneration + + processor = BlipProcessor.from_pretrained(model_id) + model = BlipForConditionalGeneration.from_pretrained(model_id).to(device) + captions = [] + + for image in tqdm(images): + inputs = processor(image, text=text, return_tensors="pt").to("cuda") + out = model.generate( + **inputs, max_length=150, do_sample=True, top_k=50, temperature=0.7 + ) + caption = processor.decode(out[0], skip_special_tokens=True) + + captions.append(caption) + + return captions + + +def face_mask_google_mediapipe( + images: List[Image.Image], blur_amount: float = 80.0, bias: float = 0.05 +) -> List[Image.Image]: + """ + Returns a list of images with mask on the face parts. + """ + import mediapipe as mp + + mp_face_detection = mp.solutions.face_detection + + face_detection = mp_face_detection.FaceDetection( + model_selection=1, min_detection_confidence=0.5 + ) + + masks = [] + for image in tqdm(images): + + image = np.array(image) + + results = face_detection.process(image) + black_image = np.ones((image.shape[0], image.shape[1]), dtype=np.uint8) + + if results.detections: + + for detection in results.detections: + + x_min = int( + detection.location_data.relative_bounding_box.xmin * image.shape[1] + ) + y_min = int( + detection.location_data.relative_bounding_box.ymin * image.shape[0] + ) + width = int( + detection.location_data.relative_bounding_box.width * image.shape[1] + ) + height = int( + detection.location_data.relative_bounding_box.height + * image.shape[0] + ) + + # draw the colored rectangle + black_image[y_min : y_min + height, x_min : x_min + width] = 255 + + black_image = Image.fromarray(black_image) + masks.append(black_image) + + return masks + + +def _crop_to_square( + image: Image.Image, com: List[Tuple[int, int]], resize_to: Optional[int] = None +): + cx, cy = com + width, height = image.size + if width > height: + left_possible = max(cx - height / 2, 0) + left = min(left_possible, width - height) + right = left + height + top = 0 + bottom = height + else: + left = 0 + right = width + top_possible = max(cy - width / 2, 0) + top = min(top_possible, height - width) + bottom = top + width + + image = image.crop((left, top, right, bottom)) + + if resize_to: + image = image.resize((resize_to, resize_to), Image.Resampling.LANCZOS) + + return image + + +def _center_of_mass(mask: Image.Image): + """ + Returns the center of mass of the mask + """ + x, y = np.meshgrid(np.arange(mask.size[0]), np.arange(mask.size[1])) + + x_ = x * np.array(mask) + y_ = y * np.array(mask) + + x = np.sum(x_) / np.sum(mask) + y = np.sum(y_) / np.sum(mask) + + return x, y + + +def load_and_save_masks_and_captions( + files: Union[str, List[str]], + output_dir: str, + caption_text: Optional[str] = None, + target_prompts: Optional[Union[List[str], str]] = None, + target_size: int = 512, + crop_based_on_salience: bool = True, + use_face_detection_instead: bool = False, + temp: float = 1.0, + n_length: int = -1, +): + """ + Loads images from the given files, generates masks for them, and saves the masks and captions and upscale images + to output dir. + """ + os.makedirs(output_dir, exist_ok=True) + + # load images + if isinstance(files, str): + # check if it is a directory + if os.path.isdir(files): + # get all the .png .jpg in the directory + files = glob.glob(os.path.join(files, "*.png")) + glob.glob( + os.path.join(files, "*.jpg") + ) + + if len(files) == 0: + raise Exception( + f"No files found in {files}. Either {files} is not a directory or it does not contain any .png or .jpg files." + ) + if n_length == -1: + n_length = len(files) + files = sorted(files)[:n_length] + + images = [Image.open(file) for file in files] + + # captions + print(f"Generating {len(images)} captions...") + captions = blip_captioning_dataset(images, text=caption_text) + + if target_prompts is None: + target_prompts = captions + + print(f"Generating {len(images)} masks...") + if not use_face_detection_instead: + seg_masks = clipseg_mask_generator( + images=images, target_prompts=target_prompts, temp=temp + ) + else: + seg_masks = face_mask_google_mediapipe(images=images) + + # find the center of mass of the mask + if crop_based_on_salience: + coms = [_center_of_mass(mask) for mask in seg_masks] + else: + coms = [(image.size[0] / 2, image.size[1] / 2) for image in images] + # based on the center of mass, crop the image to a square + images = [ + _crop_to_square(image, com, resize_to=None) for image, com in zip(images, coms) + ] + + print(f"Upscaling {len(images)} images...") + # upscale images anyways + images = swin_ir_sr(images, target_size=(target_size, target_size)) + images = [ + image.resize((target_size, target_size), Image.Resampling.LANCZOS) + for image in images + ] + + seg_masks = [ + _crop_to_square(mask, com, resize_to=target_size) + for mask, com in zip(seg_masks, coms) + ] + with open(os.path.join(output_dir, "caption.txt"), "w") as f: + # save images and masks + for idx, (image, mask, caption) in enumerate(zip(images, seg_masks, captions)): + image.save(os.path.join(output_dir, f"{idx}.src.jpg"), quality=99) + mask.save(os.path.join(output_dir, f"{idx}.mask.png")) + + f.write(caption + "\n") + + +def main(): + fire.Fire(load_and_save_masks_and_captions) diff --git a/lora_diffusion/safe_open.py b/lora_diffusion/safe_open.py new file mode 100644 index 0000000000000000000000000000000000000000..77ada821b6dd22e1ea08f4c4eaf6c30a8d43161b --- /dev/null +++ b/lora_diffusion/safe_open.py @@ -0,0 +1,68 @@ +""" +Pure python version of Safetensors safe_open +From https://gist.github.com/Narsil/3edeec2669a5e94e4707aa0f901d2282 +""" + +import json +import mmap +import os + +import torch + + +class SafetensorsWrapper: + def __init__(self, metadata, tensors): + self._metadata = metadata + self._tensors = tensors + + def metadata(self): + return self._metadata + + def keys(self): + return self._tensors.keys() + + def get_tensor(self, k): + return self._tensors[k] + + +DTYPES = { + "F32": torch.float32, + "F16": torch.float16, + "BF16": torch.bfloat16, +} + + +def create_tensor(storage, info, offset): + dtype = DTYPES[info["dtype"]] + shape = info["shape"] + start, stop = info["data_offsets"] + return ( + torch.asarray(storage[start + offset : stop + offset], dtype=torch.uint8) + .view(dtype=dtype) + .reshape(shape) + ) + + +def safe_open(filename, framework="pt", device="cpu"): + if framework != "pt": + raise ValueError("`framework` must be 'pt'") + + with open(filename, mode="r", encoding="utf8") as file_obj: + with mmap.mmap(file_obj.fileno(), length=0, access=mmap.ACCESS_READ) as m: + header = m.read(8) + n = int.from_bytes(header, "little") + metadata_bytes = m.read(n) + metadata = json.loads(metadata_bytes) + + size = os.stat(filename).st_size + storage = torch.ByteStorage.from_file(filename, shared=False, size=size).untyped() + offset = n + 8 + + return SafetensorsWrapper( + metadata=metadata.get("__metadata__", {}), + tensors={ + name: create_tensor(storage, info, offset).to(device) + for name, info in metadata.items() + if name != "__metadata__" + }, + ) diff --git a/lora_diffusion/to_ckpt_v2.py b/lora_diffusion/to_ckpt_v2.py new file mode 100644 index 0000000000000000000000000000000000000000..15f3947118e3be01f7f68630a858dc95da220f2d --- /dev/null +++ b/lora_diffusion/to_ckpt_v2.py @@ -0,0 +1,232 @@ +# from https://gist.github.com/jachiam/8a5c0b607e38fcc585168b90c686eb05 +# Script for converting a HF Diffusers saved pipeline to a Stable Diffusion checkpoint. +# *Only* converts the UNet, VAE, and Text Encoder. +# Does not convert optimizer state or any other thing. +# Written by jachiam +import argparse +import os.path as osp + +import torch + + +# =================# +# UNet Conversion # +# =================# + +unet_conversion_map = [ + # (stable-diffusion, HF Diffusers) + ("time_embed.0.weight", "time_embedding.linear_1.weight"), + ("time_embed.0.bias", "time_embedding.linear_1.bias"), + ("time_embed.2.weight", "time_embedding.linear_2.weight"), + ("time_embed.2.bias", "time_embedding.linear_2.bias"), + ("input_blocks.0.0.weight", "conv_in.weight"), + ("input_blocks.0.0.bias", "conv_in.bias"), + ("out.0.weight", "conv_norm_out.weight"), + ("out.0.bias", "conv_norm_out.bias"), + ("out.2.weight", "conv_out.weight"), + ("out.2.bias", "conv_out.bias"), +] + +unet_conversion_map_resnet = [ + # (stable-diffusion, HF Diffusers) + ("in_layers.0", "norm1"), + ("in_layers.2", "conv1"), + ("out_layers.0", "norm2"), + ("out_layers.3", "conv2"), + ("emb_layers.1", "time_emb_proj"), + ("skip_connection", "conv_shortcut"), +] + +unet_conversion_map_layer = [] +# hardcoded number of downblocks and resnets/attentions... +# would need smarter logic for other networks. +for i in range(4): + # loop over downblocks/upblocks + + for j in range(2): + # loop over resnets/attentions for downblocks + hf_down_res_prefix = f"down_blocks.{i}.resnets.{j}." + sd_down_res_prefix = f"input_blocks.{3*i + j + 1}.0." + unet_conversion_map_layer.append((sd_down_res_prefix, hf_down_res_prefix)) + + if i < 3: + # no attention layers in down_blocks.3 + hf_down_atn_prefix = f"down_blocks.{i}.attentions.{j}." + sd_down_atn_prefix = f"input_blocks.{3*i + j + 1}.1." + unet_conversion_map_layer.append((sd_down_atn_prefix, hf_down_atn_prefix)) + + for j in range(3): + # loop over resnets/attentions for upblocks + hf_up_res_prefix = f"up_blocks.{i}.resnets.{j}." + sd_up_res_prefix = f"output_blocks.{3*i + j}.0." + unet_conversion_map_layer.append((sd_up_res_prefix, hf_up_res_prefix)) + + if i > 0: + # no attention layers in up_blocks.0 + hf_up_atn_prefix = f"up_blocks.{i}.attentions.{j}." + sd_up_atn_prefix = f"output_blocks.{3*i + j}.1." + unet_conversion_map_layer.append((sd_up_atn_prefix, hf_up_atn_prefix)) + + if i < 3: + # no downsample in down_blocks.3 + hf_downsample_prefix = f"down_blocks.{i}.downsamplers.0.conv." + sd_downsample_prefix = f"input_blocks.{3*(i+1)}.0.op." + unet_conversion_map_layer.append((sd_downsample_prefix, hf_downsample_prefix)) + + # no upsample in up_blocks.3 + hf_upsample_prefix = f"up_blocks.{i}.upsamplers.0." + sd_upsample_prefix = f"output_blocks.{3*i + 2}.{1 if i == 0 else 2}." + unet_conversion_map_layer.append((sd_upsample_prefix, hf_upsample_prefix)) + +hf_mid_atn_prefix = "mid_block.attentions.0." +sd_mid_atn_prefix = "middle_block.1." +unet_conversion_map_layer.append((sd_mid_atn_prefix, hf_mid_atn_prefix)) + +for j in range(2): + hf_mid_res_prefix = f"mid_block.resnets.{j}." + sd_mid_res_prefix = f"middle_block.{2*j}." + unet_conversion_map_layer.append((sd_mid_res_prefix, hf_mid_res_prefix)) + + +def convert_unet_state_dict(unet_state_dict): + # buyer beware: this is a *brittle* function, + # and correct output requires that all of these pieces interact in + # the exact order in which I have arranged them. + mapping = {k: k for k in unet_state_dict.keys()} + for sd_name, hf_name in unet_conversion_map: + mapping[hf_name] = sd_name + for k, v in mapping.items(): + if "resnets" in k: + for sd_part, hf_part in unet_conversion_map_resnet: + v = v.replace(hf_part, sd_part) + mapping[k] = v + for k, v in mapping.items(): + for sd_part, hf_part in unet_conversion_map_layer: + v = v.replace(hf_part, sd_part) + mapping[k] = v + new_state_dict = {v: unet_state_dict[k] for k, v in mapping.items()} + return new_state_dict + + +# ================# +# VAE Conversion # +# ================# + +vae_conversion_map = [ + # (stable-diffusion, HF Diffusers) + ("nin_shortcut", "conv_shortcut"), + ("norm_out", "conv_norm_out"), + ("mid.attn_1.", "mid_block.attentions.0."), +] + +for i in range(4): + # down_blocks have two resnets + for j in range(2): + hf_down_prefix = f"encoder.down_blocks.{i}.resnets.{j}." + sd_down_prefix = f"encoder.down.{i}.block.{j}." + vae_conversion_map.append((sd_down_prefix, hf_down_prefix)) + + if i < 3: + hf_downsample_prefix = f"down_blocks.{i}.downsamplers.0." + sd_downsample_prefix = f"down.{i}.downsample." + vae_conversion_map.append((sd_downsample_prefix, hf_downsample_prefix)) + + hf_upsample_prefix = f"up_blocks.{i}.upsamplers.0." + sd_upsample_prefix = f"up.{3-i}.upsample." + vae_conversion_map.append((sd_upsample_prefix, hf_upsample_prefix)) + + # up_blocks have three resnets + # also, up blocks in hf are numbered in reverse from sd + for j in range(3): + hf_up_prefix = f"decoder.up_blocks.{i}.resnets.{j}." + sd_up_prefix = f"decoder.up.{3-i}.block.{j}." + vae_conversion_map.append((sd_up_prefix, hf_up_prefix)) + +# this part accounts for mid blocks in both the encoder and the decoder +for i in range(2): + hf_mid_res_prefix = f"mid_block.resnets.{i}." + sd_mid_res_prefix = f"mid.block_{i+1}." + vae_conversion_map.append((sd_mid_res_prefix, hf_mid_res_prefix)) + + +vae_conversion_map_attn = [ + # (stable-diffusion, HF Diffusers) + ("norm.", "group_norm."), + ("q.", "query."), + ("k.", "key."), + ("v.", "value."), + ("proj_out.", "proj_attn."), +] + + +def reshape_weight_for_sd(w): + # convert HF linear weights to SD conv2d weights + return w.reshape(*w.shape, 1, 1) + + +def convert_vae_state_dict(vae_state_dict): + mapping = {k: k for k in vae_state_dict.keys()} + for k, v in mapping.items(): + for sd_part, hf_part in vae_conversion_map: + v = v.replace(hf_part, sd_part) + mapping[k] = v + for k, v in mapping.items(): + if "attentions" in k: + for sd_part, hf_part in vae_conversion_map_attn: + v = v.replace(hf_part, sd_part) + mapping[k] = v + new_state_dict = {v: vae_state_dict[k] for k, v in mapping.items()} + weights_to_convert = ["q", "k", "v", "proj_out"] + for k, v in new_state_dict.items(): + for weight_name in weights_to_convert: + if f"mid.attn_1.{weight_name}.weight" in k: + print(f"Reshaping {k} for SD format") + new_state_dict[k] = reshape_weight_for_sd(v) + return new_state_dict + + +# =========================# +# Text Encoder Conversion # +# =========================# +# pretty much a no-op + + +def convert_text_enc_state_dict(text_enc_dict): + return text_enc_dict + + +def convert_to_ckpt(model_path, checkpoint_path, as_half): + + assert model_path is not None, "Must provide a model path!" + + assert checkpoint_path is not None, "Must provide a checkpoint path!" + + unet_path = osp.join(model_path, "unet", "diffusion_pytorch_model.bin") + vae_path = osp.join(model_path, "vae", "diffusion_pytorch_model.bin") + text_enc_path = osp.join(model_path, "text_encoder", "pytorch_model.bin") + + # Convert the UNet model + unet_state_dict = torch.load(unet_path, map_location="cpu") + unet_state_dict = convert_unet_state_dict(unet_state_dict) + unet_state_dict = { + "model.diffusion_model." + k: v for k, v in unet_state_dict.items() + } + + # Convert the VAE model + vae_state_dict = torch.load(vae_path, map_location="cpu") + vae_state_dict = convert_vae_state_dict(vae_state_dict) + vae_state_dict = {"first_stage_model." + k: v for k, v in vae_state_dict.items()} + + # Convert the text encoder model + text_enc_dict = torch.load(text_enc_path, map_location="cpu") + text_enc_dict = convert_text_enc_state_dict(text_enc_dict) + text_enc_dict = { + "cond_stage_model.transformer." + k: v for k, v in text_enc_dict.items() + } + + # Put together new checkpoint + state_dict = {**unet_state_dict, **vae_state_dict, **text_enc_dict} + if as_half: + state_dict = {k: v.half() for k, v in state_dict.items()} + state_dict = {"state_dict": state_dict} + torch.save(state_dict, checkpoint_path) diff --git a/lora_diffusion/utils.py b/lora_diffusion/utils.py new file mode 100644 index 0000000000000000000000000000000000000000..d8a3410df7eb5f929a4e2ae662c0a1f563a3f760 --- /dev/null +++ b/lora_diffusion/utils.py @@ -0,0 +1,214 @@ +from typing import List, Union + +import torch +from PIL import Image +from transformers import ( + CLIPProcessor, + CLIPTextModelWithProjection, + CLIPTokenizer, + CLIPVisionModelWithProjection, +) + +from diffusers import StableDiffusionPipeline +from .lora import patch_pipe, tune_lora_scale, _text_lora_path, _ti_lora_path +import os +import glob +import math + +EXAMPLE_PROMPTS = [ + " swimming in a pool", + " at a beach with a view of seashore", + " in times square", + " wearing sunglasses", + " in a construction outfit", + " playing with a ball", + " wearing headphones", + " oil painting ghibli inspired", + " working on the laptop", + " with mountains and sunset in background", + "Painting of at a beach by artist claude monet", + " digital painting 3d render geometric style", + "A screaming ", + "A depressed ", + "A sleeping ", + "A sad ", + "A joyous ", + "A frowning ", + "A sculpture of ", + " near a pool", + " at a beach with a view of seashore", + " in a garden", + " in grand canyon", + " floating in ocean", + " and an armchair", + "A maple tree on the side of ", + " and an orange sofa", + " with chocolate cake on it", + " with a vase of rose flowers on it", + "A digital illustration of ", + "Georgia O'Keeffe style painting", + "A watercolor painting of on a beach", +] + + +def image_grid(_imgs, rows=None, cols=None): + + if rows is None and cols is None: + rows = cols = math.ceil(len(_imgs) ** 0.5) + + if rows is None: + rows = math.ceil(len(_imgs) / cols) + if cols is None: + cols = math.ceil(len(_imgs) / rows) + + w, h = _imgs[0].size + grid = Image.new("RGB", size=(cols * w, rows * h)) + grid_w, grid_h = grid.size + + for i, img in enumerate(_imgs): + grid.paste(img, box=(i % cols * w, i // cols * h)) + return grid + + +def text_img_alignment(img_embeds, text_embeds, target_img_embeds): + # evaluation inspired from textual inversion paper + # https://arxiv.org/abs/2208.01618 + + # text alignment + assert img_embeds.shape[0] == text_embeds.shape[0] + text_img_sim = (img_embeds * text_embeds).sum(dim=-1) / ( + img_embeds.norm(dim=-1) * text_embeds.norm(dim=-1) + ) + + # image alignment + img_embed_normalized = img_embeds / img_embeds.norm(dim=-1, keepdim=True) + + avg_target_img_embed = ( + (target_img_embeds / target_img_embeds.norm(dim=-1, keepdim=True)) + .mean(dim=0) + .unsqueeze(0) + .repeat(img_embeds.shape[0], 1) + ) + + img_img_sim = (img_embed_normalized * avg_target_img_embed).sum(dim=-1) + + return { + "text_alignment_avg": text_img_sim.mean().item(), + "image_alignment_avg": img_img_sim.mean().item(), + "text_alignment_all": text_img_sim.tolist(), + "image_alignment_all": img_img_sim.tolist(), + } + + +def prepare_clip_model_sets(eval_clip_id: str = "openai/clip-vit-large-patch14"): + text_model = CLIPTextModelWithProjection.from_pretrained(eval_clip_id) + tokenizer = CLIPTokenizer.from_pretrained(eval_clip_id) + vis_model = CLIPVisionModelWithProjection.from_pretrained(eval_clip_id) + processor = CLIPProcessor.from_pretrained(eval_clip_id) + + return text_model, tokenizer, vis_model, processor + + +def evaluate_pipe( + pipe, + target_images: List[Image.Image], + class_token: str = "", + learnt_token: str = "", + guidance_scale: float = 5.0, + seed=0, + clip_model_sets=None, + eval_clip_id: str = "openai/clip-vit-large-patch14", + n_test: int = 10, + n_step: int = 50, +): + + if clip_model_sets is not None: + text_model, tokenizer, vis_model, processor = clip_model_sets + else: + text_model, tokenizer, vis_model, processor = prepare_clip_model_sets( + eval_clip_id + ) + + images = [] + img_embeds = [] + text_embeds = [] + for prompt in EXAMPLE_PROMPTS[:n_test]: + prompt = prompt.replace("", learnt_token) + torch.manual_seed(seed) + with torch.autocast("cuda"): + img = pipe( + prompt, num_inference_steps=n_step, guidance_scale=guidance_scale + ).images[0] + images.append(img) + + # image + inputs = processor(images=img, return_tensors="pt") + img_embed = vis_model(**inputs).image_embeds + img_embeds.append(img_embed) + + prompt = prompt.replace(learnt_token, class_token) + # prompts + inputs = tokenizer([prompt], padding=True, return_tensors="pt") + outputs = text_model(**inputs) + text_embed = outputs.text_embeds + text_embeds.append(text_embed) + + # target images + inputs = processor(images=target_images, return_tensors="pt") + target_img_embeds = vis_model(**inputs).image_embeds + + img_embeds = torch.cat(img_embeds, dim=0) + text_embeds = torch.cat(text_embeds, dim=0) + + return text_img_alignment(img_embeds, text_embeds, target_img_embeds) + + +def visualize_progress( + path_alls: Union[str, List[str]], + prompt: str, + model_id: str = "runwayml/stable-diffusion-v1-5", + device="cuda:0", + patch_unet=True, + patch_text=True, + patch_ti=True, + unet_scale=1.0, + text_sclae=1.0, + num_inference_steps=50, + guidance_scale=5.0, + offset: int = 0, + limit: int = 10, + seed: int = 0, +): + + imgs = [] + if isinstance(path_alls, str): + alls = list(set(glob.glob(path_alls))) + + alls.sort(key=os.path.getmtime) + else: + alls = path_alls + + pipe = StableDiffusionPipeline.from_pretrained( + model_id, torch_dtype=torch.float16 + ).to(device) + + print(f"Found {len(alls)} checkpoints") + for path in alls[offset:limit]: + print(path) + + patch_pipe( + pipe, path, patch_unet=patch_unet, patch_text=patch_text, patch_ti=patch_ti + ) + + tune_lora_scale(pipe.unet, unet_scale) + tune_lora_scale(pipe.text_encoder, text_sclae) + + torch.manual_seed(seed) + image = pipe( + prompt, + num_inference_steps=num_inference_steps, + guidance_scale=guidance_scale, + ).images[0] + imgs.append(image) + + return imgs diff --git a/lora_diffusion/xformers_utils.py b/lora_diffusion/xformers_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..fdabf665e185147cfd0ef8662db48d05b94ea7f0 --- /dev/null +++ b/lora_diffusion/xformers_utils.py @@ -0,0 +1,70 @@ +import functools + +import torch +from diffusers.models.attention import BasicTransformerBlock +from diffusers.utils.import_utils import is_xformers_available + +from .lora import LoraInjectedLinear + +if is_xformers_available(): + import xformers + import xformers.ops +else: + xformers = None + + +@functools.cache +def test_xformers_backwards(size): + @torch.enable_grad() + def _grad(size): + q = torch.randn((1, 4, size), device="cuda") + k = torch.randn((1, 4, size), device="cuda") + v = torch.randn((1, 4, size), device="cuda") + + q = q.detach().requires_grad_() + k = k.detach().requires_grad_() + v = v.detach().requires_grad_() + + out = xformers.ops.memory_efficient_attention(q, k, v) + loss = out.sum(2).mean(0).sum() + + return torch.autograd.grad(loss, v) + + try: + _grad(size) + print(size, "pass") + return True + except Exception as e: + print(size, "fail") + return False + + +def set_use_memory_efficient_attention_xformers( + module: torch.nn.Module, valid: bool +) -> None: + def fn_test_dim_head(module: torch.nn.Module): + if isinstance(module, BasicTransformerBlock): + # dim_head isn't stored anywhere, so back-calculate + source = module.attn1.to_v + if isinstance(source, LoraInjectedLinear): + source = source.linear + + dim_head = source.out_features // module.attn1.heads + + result = test_xformers_backwards(dim_head) + + # If dim_head > dim_head_max, turn xformers off + if not result: + module.set_use_memory_efficient_attention_xformers(False) + + for child in module.children(): + fn_test_dim_head(child) + + if not is_xformers_available() and valid: + print("XFormers is not available. Skipping.") + return + + module.set_use_memory_efficient_attention_xformers(valid) + + if valid: + fn_test_dim_head(module) diff --git a/mist-webui.py b/mist-webui.py new file mode 100644 index 0000000000000000000000000000000000000000..add70219ee00fb106384f4bab9f292a0d05258aa --- /dev/null +++ b/mist-webui.py @@ -0,0 +1,77 @@ +import gradio as gr +from attacks.mist import update_args_with_config, main + +''' + TODO: + - SDXL + - model changing +''' + + +def process_image(eps, device, mode, resize, data_path, output_path, model_path, class_path, prompt, \ + class_prompt, max_train_steps, max_f_train_steps, max_adv_train_steps, lora_lr, pgd_lr, \ + rank, prior_loss_weight, fused_weight, constraint_mode, lpips_bound, lpips_weight): + + config = (eps, device, mode, resize, data_path, output_path, model_path, class_path, prompt, \ + class_prompt, max_train_steps, max_f_train_steps, max_adv_train_steps, lora_lr, pgd_lr, \ + rank, prior_loss_weight, fused_weight, constraint_mode, lpips_bound, lpips_weight) + args = None + args = update_args_with_config(args, config) + main(args) + +if __name__ == "__main__": + with gr.Blocks() as demo: + with gr.Column(): + gr.Image("MIST_logo.png", show_label=False) + with gr.Row(): + with gr.Column(): + eps = gr.Slider(0, 32, step=1, value=10, label='Strength', + info="Larger strength results in stronger but more visible defense.") + device = gr.Radio(["cpu", "gpu"], value="gpu", label="Device", + info="If you do not have good GPUs on your PC, choose 'CPU'.") + # precision = gr.Radio(["float16", "bfloat16"], value="bfloat16", label="Precision", + # info="Precision used in computing") + resize = gr.Checkbox(value=True, label="Resizing the output image to the original resolution") + mode = gr.Radio(["Mode 1", "Mode 2", "Mode 3"], value="Mode 1", label="Mode", + info="Two modes both work with different visualization.") + # model_type = gr.Radio(["Stable Diffusion", "SDXL"], value="Stable Diffusion", label="Target Model", + # info="Model used by imaginary copyright infringers") + data_path = gr.Textbox(label="Data Path", lines=1, placeholder="Path to your images") + output_path = gr.Textbox(label="Output Path", lines=1, placeholder="Path to store the outputs") + model_path = gr.Textbox(label="Target Model Path", lines=1, placeholder="Path to the target model") + class_path = gr.Textbox(label="Path to place contrast images ", lines=1, placeholder="Path to the target model") + prompt = gr.Textbox(label="Prompt", lines=1, placeholder="Describe your images") + + with gr.Accordion("Professional Setups", open=False): + class_prompt = gr.Textbox(label="Class prompt", lines=1, placeholder="Prompt for contrast images.") + max_train_steps = gr.Slider(1, 20, step=1, value=5, label='Epochs', + info="Training epochs of Mist-V2") + max_f_train_steps = gr.Slider(0, 30, step=1, value=10, label='LoRA Steps', + info="Training steps of LoRA in one epoch") + max_adv_train_steps = gr.Slider(0, 100, step=5, value=30, label='Attacking Steps', + info="Training steps of attacking in one epoch") + lora_lr = gr.Number(minimum=0.0, maximum=1.0, label="The learning rate of LoRA", value=0.0001) + pgd_lr = gr.Number(minimum=0.0, maximum=1.0, label="The learning rate of PGD", value=0.005) + rank = gr.Slider(4, 32, step=4, value=4, label='LoRA Ranks', + info="Ranks of LoRA (Bigger ranks need better GPUs)") + prior_loss_weight = gr.Number(minimum=0.0, maximum=1.0, label="The weight of prior loss", value=0.1) + fused_weight = gr.Number(minimum=0.0, maximum=1.0, label="The weight of vae loss", value=0.00001) + constraint_mode = gr.Radio(["Epsilon", "LPIPS"], value="Epsilon", label="Constraint Mode", + info="The mode to constraint the watermark") + lpips_bound = gr.Number(minimum=0.0, maximum=0.2, label="The LPIPS bound", value=0.1) + lpips_weight = gr.Number(minimum=0.0, maximum=1.0, label="The weight of LPIPI constraint", value=0.5) + + # inputs = [eps, device, precision, mode, model_type, original_resolution, data_path, \ + # output_path, model_path, prompt, max_f_train_steps, max_train_steps, max_adv_train_steps, lora_lr, pgd_lr, rank] + + inputs = [eps, device, mode, resize, data_path, output_path, model_path, class_path, prompt, \ + class_prompt, max_train_steps, max_f_train_steps, max_adv_train_steps, lora_lr, pgd_lr, \ + rank, prior_loss_weight, fused_weight, constraint_mode, lpips_bound, lpips_weight] + + + image_button = gr.Button("Mist") + + + image_button.click(process_image, inputs=inputs) + + demo.queue().launch(share=True) diff --git a/output/placeholder b/output/placeholder new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 0000000000000000000000000000000000000000..e60d41db4a78526996127df9707e146276876738 --- /dev/null +++ b/requirements.txt @@ -0,0 +1,24 @@ +torch==2.1.0 +torchvision==0.16.0 +diffusers==0.15.0 +transformers==4.26.0 +datasets==2.10.1 +accelerate==0.22.0 +gradio +ftfy +tensorboard +Jinja2 +tqdm +scipy +fire +wandb +safetensors +opencv-python +mediapipe +pynvml +cache +xformers +colorama +torchmetrics +lpips +--extra-index-url https://download.pytorch.org/whl/cu118 diff --git a/scripts/mist_sd1-5.sh b/scripts/mist_sd1-5.sh new file mode 100644 index 0000000000000000000000000000000000000000..27cfef92031c61f9a5b28f9a0c19d7f7220c9e7c --- /dev/null +++ b/scripts/mist_sd1-5.sh @@ -0,0 +1,21 @@ +export MODEL_NAME="stable-diffusion/stable-diffusion-1-5" +export INSTANCE_DIR="data/training/" +export OUTPUT_DIR="output/mist/" +export CLASS_DIR="data/class" + +accelerate launch attacks/mist.py \ + --cuda --low_vram_mode --resize \ + --pretrained_model_name_or_path=$MODEL_NAME \ + --instance_data_dir=$INSTANCE_DIR \ + --output_dir=$OUTPUT_DIR \ + --class_data_dir=$CLASS_DIR\ + --instance_prompt "an animated girl" \ + --class_prompt "a oil painting of a girl, high quality, master piece" \ + --mixed_precision bf16 \ + --max_train_steps 5 \ + --checkpointing_iterations 1 \ + --prior_loss_weight 0.1 \ + --pgd_alpha 0.005 \ + --pgd_eps 0.04 \ + --max_adv_train_steps 30 \ + --max_f_train_steps 10 \ \ No newline at end of file diff --git a/scripts/train_lora_sd1-5_15.sh b/scripts/train_lora_sd1-5_15.sh new file mode 100644 index 0000000000000000000000000000000000000000..5f8dcc1aca3be33c7ce3d953324503bcf880b22a --- /dev/null +++ b/scripts/train_lora_sd1-5_15.sh @@ -0,0 +1,19 @@ +export MODEL_NAME="stable-diffusion/stable-diffusion-1-5" +export INSTANCE_DIR="data/training/" +export OUTPUT_DIR="output/lora/" +export CLASS_DIR="data/lora_class" + +accelerate launch eval/train_dreambooth_lora_15.py \ + --pretrained_model_name_or_path=$MODEL_NAME \ + --instance_data_dir=$INSTANCE_DIR \ + --output_dir=$OUTPUT_DIR \ + --class_data_dir=$CLASS_DIR\ + --instance_prompt "an animated painting of a sks person, high quality, masterpiece" \ + --class_prompt "an animated painting of a person, high quality, masterpiece" \ + --resolution=512 \ + --train_batch_size=1 \ + --gradient_accumulation_steps=1 \ + --learning_rate=1e-4 \ + --scale_lr \ + --max_train_steps=2000 \ + --mixed_precision=bf16 \ \ No newline at end of file diff --git a/scripts/train_lora_sd1-5_adv_15.sh b/scripts/train_lora_sd1-5_adv_15.sh new file mode 100644 index 0000000000000000000000000000000000000000..eebdd7868727827aaf387817d461eafe1222e4c5 --- /dev/null +++ b/scripts/train_lora_sd1-5_adv_15.sh @@ -0,0 +1,19 @@ +export MODEL_NAME="stable-diffusion/stable-diffusion-1-5" +export INSTANCE_DIR="output/mist/" +export OUTPUT_DIR="output/lora/" +export CLASS_DIR="data/lora_class" + +accelerate launch eval/train_dreambooth_lora_15.py \ + --pretrained_model_name_or_path=$MODEL_NAME \ + --instance_data_dir=$INSTANCE_DIR \ + --output_dir=$OUTPUT_DIR \ + --class_data_dir=$CLASS_DIR\ + --instance_prompt "an animated painting of a sks person, high quality, masterpiece" \ + --class_prompt "an animated painting of a person, high quality, masterpiece" \ + --resolution=512 \ + --train_batch_size=1 \ + --gradient_accumulation_steps=1 \ + --learning_rate=1e-4 \ + --scale_lr \ + --max_train_steps=3000 \ + --mixed_precision=bf16 \ \ No newline at end of file diff --git a/stable-diffusion/placeholder.txt b/stable-diffusion/placeholder.txt new file mode 100644 index 0000000000000000000000000000000000000000..ecc39995c700113c6511def107835a210fe41218 --- /dev/null +++ b/stable-diffusion/placeholder.txt @@ -0,0 +1,9 @@ +structure: +- stable-diffusion-1-5 + - feature_extractor + - preprocessor_config.json + - safety_checker + - config.json + - pytorch_model.bin + ... +- stable-diffusion-2-1-base \ No newline at end of file