initial commit

.gitattributes

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz 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

DDCM_blind_face_image_restoration.py

@@ -0,0 +1,247 @@
+import os
+from functools import partial
+
+import cv2
+import gradio as gr
+import spaces
+from util.file import generate_binary_file, load_numpy_from_binary_bitwise
+import torch
+import yaml
+from util.basicsr_img_util import img2tensor, tensor2img
+from facexlib.utils.face_restoration_helper import FaceRestoreHelper
+from torchvision.transforms.functional import resize
+
+from guided_diffusion.gaussian_diffusion import create_sampler
+from guided_diffusion.swinir import SwinIR
+from guided_diffusion.unet import create_model
+
+
+def create_swinir_model(ckpt_path):
+    cfg = {
+        'in_channels': 3,
+        'out_channels': 3,
+        'embed_dim': 180,
+        'depths': [6, 6, 6, 6, 6, 6, 6, 6],
+        'num_heads': [6, 6, 6, 6, 6, 6, 6, 6],
+        'resi_connection': '1conv',
+        'sf': 8
+    }
+    mmse_model = SwinIR(
+        img_size=64,
+        patch_size=1,
+        in_chans=cfg['in_channels'],
+        num_out_ch=cfg['out_channels'],
+        embed_dim=cfg['embed_dim'],
+        depths=cfg['depths'],
+        num_heads=cfg['num_heads'],
+        window_size=8,
+        mlp_ratio=2,
+        sf=cfg['sf'],
+        img_range=1.0,
+        upsampler="nearest+conv",
+        resi_connection=cfg['resi_connection'],
+        unshuffle=True,
+        unshuffle_scale=8
+    )
+    ckpt = torch.load(ckpt_path, map_location="cpu")
+
+    if 'params_ema' in ckpt:
+        mmse_model.load_state_dict(ckpt['params_ema'])
+    else:
+        state_dict = ckpt['state_dict']
+        state_dict = {layer_name.replace('model.', ''): weights for layer_name, weights in
+                      state_dict.items()}
+        state_dict = {layer_name.replace('module.', ''): weights for layer_name, weights in
+                      state_dict.items()}
+        mmse_model.load_state_dict(state_dict)
+    for param in mmse_model.parameters():
+        param.requires_grad = False
+    return mmse_model
+
+
+ffhq_diffusion_model = "./guided_diffusion/iddpm_ffhq512_ema500000.pth"
+mmse_model_ckpt = "./guided_diffusion/swinir_restoration512_L1.pth"
+
+if not os.path.exists(ffhq_diffusion_model):
+    os.system(
+        "wget https://github.com/zsyOAOA/DifFace/releases/download/V1.0/iddpm_ffhq512_ema500000.pth -O ./guided_diffusion/iddpm_ffhq512_ema500000.pth"
+    )
+if not os.path.exists(mmse_model_ckpt):
+    os.system(
+        "wget https://github.com/zsyOAOA/DifFace/releases/download/V1.0/swinir_restoration512_L1.pth -O ./guided_diffusion/swinir_restoration512_L1.pth"
+    )
+
+
+def load_yaml(file_path: str) -> dict:
+    with open(file_path) as f:
+        config = yaml.load(f, Loader=yaml.FullLoader)
+    return config
+
+
+model_config = './guided_diffusion/ffhq512_model_config.yaml'
+diffusion_config = './guided_diffusion/diffusion_config.yaml'
+model_config = load_yaml(model_config)
+diffusion_config = load_yaml(diffusion_config)
+
+models = {
+    'main_model': create_model(**model_config),
+    'mmse_model': create_swinir_model('./guided_diffusion/swinir_restoration512_L1.pth')
+}
+models['main_model'].eval()
+models['mmse_model'].eval()
+
+
+@torch.no_grad()
+@spaces.GPU(duration=80)
+def generate_reconstruction(degraded_face_img, K, T, iqa_metric, iqa_coef, loaded_indices):
+    assert iqa_metric in ['niqe', 'clipiqa+', 'topiq_nr-face']
+    diffusion_config['timestep_respacing'] = T
+    sampler = create_sampler(**diffusion_config)
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    model = models['main_model'].to(device)
+    mmse_model = models['mmse_model'].to(device)
+
+    sample_fn = partial(sampler.p_sample_loop_blind_restoration, model=model, num_opt_noises=K,
+                        eta=1.0, iqa_metric=iqa_metric, iqa_coef=iqa_coef)
+
+    if degraded_face_img is not None:
+        mmse_img = mmse_model(degraded_face_img).clip(0, 1) * 2 - 1
+        x_start = torch.randn(mmse_img.shape, device=device)
+    else:
+        mmse_img = None
+        x_start = torch.randn(1, 3, 512, 512, device=device)
+    restored_face, indices = sample_fn(x_start=x_start, mmse_img=mmse_img, loaded_indices=loaded_indices)
+
+    return restored_face, indices
+
+
+def resize(img, size):
+    # From https://github.com/sczhou/CodeFormer/blob/master/facelib/utils/face_restoration_helper.py
+    h, w = img.shape[0:2]
+    scale = size / min(h, w)
+    h, w = int(h * scale), int(w * scale)
+    interp = cv2.INTER_AREA if scale < 1 else cv2.INTER_LINEAR
+    return cv2.resize(img, (w, h), interpolation=interp)
+
+
+@torch.no_grad()
+@spaces.GPU(duration=80)
+def enhance_faces(img, face_helper, has_aligned, K, T, iqa_metric, iqa_coef, loaded_indices):
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    face_helper.clean_all()
+    if has_aligned:  # The inputs are already aligned
+        img = cv2.resize(img, (512, 512), interpolation=cv2.INTER_LINEAR)
+        face_helper.cropped_faces = [img]
+    else:
+        face_helper.read_image(img)
+        face_helper.input_img = resize(face_helper.input_img, 640)
+        face_helper.get_face_landmarks_5(only_center_face=False, eye_dist_threshold=5)
+        face_helper.align_warp_face()
+    if len(face_helper.cropped_faces) == 0:
+        raise gr.Error("Could not identify any face in the image.")
+    if has_aligned and len(face_helper.cropped_faces) > 1:
+        raise gr.Error(
+            "You marked that the input image is aligned, but multiple faces were detected."
+        )
+    restored_faces = []
+    generated_indices = []
+    for i, cropped_face in enumerate(face_helper.cropped_faces):
+        cropped_face_t = img2tensor(cropped_face / 255.0, bgr2rgb=True, float32=True)
+        cropped_face_t = cropped_face_t.unsqueeze(0).to(device)
+        cur_loaded_indices = loaded_indices[i] if loaded_indices is not None else None
+
+        output, indices = generate_reconstruction(
+            cropped_face_t,
+            K,
+            T,
+            iqa_metric,
+            iqa_coef,
+            cur_loaded_indices
+        )
+
+        restored_face = tensor2img(
+            output.to(torch.float32).squeeze(0), rgb2bgr=False, min_max=(-1, 1)
+        )
+
+        restored_face = restored_face.astype("uint8")
+        restored_faces.append(restored_face),
+        generated_indices.append(indices)
+    return restored_faces, generated_indices
+
+
+@torch.no_grad()
+@spaces.GPU()
+def decompress_face(K, T, iqa_metric, iqa_coef, loaded_indices):
+    assert loaded_indices is not None
+
+    output, indices = generate_reconstruction(
+        None,
+        K,
+        T,
+        iqa_metric,
+        iqa_coef,
+        loaded_indices
+    )
+
+    restored_face = tensor2img(
+        output.to(torch.float32).squeeze(0), rgb2bgr=False, min_max=(-1, 1)
+    ).astype("uint8")
+
+    return restored_face, loaded_indices
+
+@torch.no_grad()
+@spaces.GPU(duration=80)
+def inference(
+        img,
+        T,
+        K,
+        iqa_metric,
+        iqa_coef,
+        aligned,
+        bitstream=None,
+        progress=gr.Progress(track_tqdm=True),
+):
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+    iqa_metric_to_pyiqa_name = {
+        'NIQE': 'niqe',
+        'TOPIQ': 'topiq_nr-face',
+        'CLIP-IQA': 'clipiqa+'
+    }
+    iqa_metric = iqa_metric_to_pyiqa_name[iqa_metric]
+    indices = load_numpy_from_binary_bitwise(bitstream, K, T, 'ffhq', T)
+    if indices is not None:
+        indices = indices.to(device)
+
+    if img is not None:
+        img = cv2.imread(img, cv2.IMREAD_COLOR)
+        h, w = img.shape[0:2]
+        if h > 4500 or w > 4500:
+            raise gr.Error("Image size too large.")
+
+        face_helper = FaceRestoreHelper(
+            1,
+            face_size=512,
+            crop_ratio=(1, 1),
+            det_model="retinaface_resnet50",
+            save_ext="png",
+            use_parse=True,
+            device=device,
+            model_rootpath=None,
+        )
+
+        x, indices = enhance_faces(
+            img, face_helper, aligned, K=K, T=T, iqa_metric=iqa_metric, iqa_coef=iqa_coef,
+            loaded_indices=indices,
+        )
+    else:
+        x, indices = decompress_face(
+            K=K, T=T, iqa_metric=iqa_metric, iqa_coef=iqa_coef, loaded_indices=indices,
+        )
+
+    torch.cuda.empty_cache()
+
+    if bitstream is None:
+        indices = [generate_binary_file(index.numpy(), K, T, 'ffhq') for index in indices]
+        return x, indices
+    return x

README.md

@@ -0,0 +1,20 @@
+---
+title: Compressed Image Generation with Denoising Diffusion Codebook Models
+emoji: 📖
+colorFrom: blue
+colorTo: green
+sdk: gradio
+sdk_version: 5.14.0
+app_file: app.py
+pinned: false
+license: mit
+tags:
+  - image-generation
+  - blind-face-image-restoration
+  - image-compression
+  - text-to-image-generation
+  - compressed-image-generation
+short_description: Generate compressed images given different input conditions
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -0,0 +1,293 @@
+import gradio as gr
+from functools import partial
+import torch
+import spaces
+
+import DDCM_blind_face_image_restoration
+import latent_DDCM_CCFG
+import latent_DDCM_compression
+from latent_models import load_model
+import os
+# import transformers
+# transformers.utils.move_cache()
+
+
+if os.getenv("SPACES_ZERO_GPU") == "true":
+    os.environ["SPACES_ZERO_GPU"] = "1"
+
+
+avail_models = {'512x512': load_model('stabilityai/stable-diffusion-2-1-base', 1000, float16=True, device=torch.device("cpu"), compile=False)[0],
+                '768x768': load_model('stabilityai/stable-diffusion-2-1', 1000, float16=True, device=torch.device("cpu"), compile=False)[0]
+               }
+
+compression_func = partial(latent_DDCM_compression.main, avail_models=avail_models)
+
+
+def get_t_and_k_from_file_name(file_name):
+    T = int(file_name.split('T')[1].split('-')[0])
+    K = int(file_name.split('K')[1].split('-')[0])
+    model_type = file_name.split('M')[1].split('-')[0]
+    return T, K, model_type
+
+
+def ccfg(text_input, T, K, ccfg_scale, model_type, compressed_file_in=None):
+    return latent_DDCM_CCFG.main(text_input, T, K, min(ccfg_scale, K), model_type, compressed_file_in,
+                                 avail_models=avail_models)
+    # return latent_DDCM_CCFG.main(text_input, T, K, min(ccfg_scale, K), compressed_file_in)
+
+
+@spaces.GPU
+def decompress_given_bitstream(bitstream, method):
+    if bitstream is None:
+        gr.Error("Please provide a bit-stream file when performing decompression")
+    file_name = bitstream.name
+    T, K, model_type = get_t_and_k_from_file_name(file_name)
+    if method == 'compression':
+        return compression_func(None, T, K, model_type, bitstream)
+    elif method == 'blind':
+        return DDCM_blind_face_image_restoration.inference(None, T, K, 'NIQE', 1, True, bitstream)
+    elif method == 'ccfg':
+        return ccfg(None, T, K, -1, model_type, bitstream)
+    else:
+        raise NotImplementedError()
+
+
+def validate_K(K):
+    if (K & (K - 1)) != 0:
+        gr.Warning("For efficient bit usage, K should be a power of 2.")
+
+
+method_to_func = {
+    'compression': partial(decompress_given_bitstream, method='compression'),
+    'blind': partial(decompress_given_bitstream, method='blind'),
+    'ccfg': partial(decompress_given_bitstream, method='ccfg'),
+}
+
+title = "<div style='text-align: center; font-size: 36px; font-weight: bold;'>Compressed Image Generation with Denoising Diffusion Codebook Models</div>"
+intro = """
+<h3 style="margin-bottom: 10px; text-align: center;">
+    <a href="https://ohayonguy.github.io/">Guy Ohayon*</a>&nbsp;,&nbsp;
+    <a href="https://hilamanor.github.io/">Hila Manor*</a>&nbsp;,&nbsp;
+    <a href="https://tomer.net.technion.ac.il/">Tomer Michaeli</a>&nbsp;,&nbsp;
+    <a href="https://elad.cs.technion.ac.il/">Michael Elad</a>
+</h3>
+<p style="font-size: 12px; text-align: center; margin-bottom: 10px;">
+    * Equal contribution
+</p>
+<h4 style="margin-bottom: 10px; text-align: center;">
+    Technion - Israel Institute of Technology
+</h5>
+<h3 style="margin-bottom: 10px; text-align: center;">
+    <a href="https://www.arxiv.org/abs/2502.01189/">[Paper]</a>&nbsp;|&nbsp;
+    <a href="https://ddcm-2025.github.io/">[Project Page]</a>&nbsp;|&nbsp;
+    <a href="https://github.com/DDCM-2025/ddcm-compressed-image-generation/">[Code]</a>
+</h3>
+</br></br>
+Denoising Diffusion Codebook Models (DDCM) is a novel (and simple) generative approach based on any Denoising Diffusion Model (DDM), that is able to produce high-quality image samples along with their losslessly compressed bit-stream representations.
+DDCM can easily be utilized for perceptual image compression, as well as for solving a variety of compressed conditional generation tasks such as text-conditional image generation and image restoration, where each generated sample is accompanied by a compressed bit-stream.
+</br></br>
+The tabs below correspond to demos of different practical applications. Open each tab to see the application's specific instructions.
+</br></br>
+<b>Note: The demos below rely on relatively old pre-trained diffusion models such as Stable Diffusion 2.1, simply for the purpose of demonstrating the capabilities of DDCM. Feel free to implement our DDCM-based methods using newer diffusion models to further improve performance.</b>
+"""
+
+article = r"""
+If you find our work useful, please ⭐ our <a href='https://github.com/DDCM-2025/ddcm-compressed-image-generation' target='_blank'>GitHub repository</a>. Thanks!
+
+📝 **Citation**
+```bibtex
+@article{ohayon2025compressedimagegenerationdenoising,
+      title={Compressed Image Generation with Denoising Diffusion Codebook Models}, 
+      author={Guy Ohayon and Hila Manor and Tomer Michaeli and Michael Elad},
+      year={2025},
+      eprint={2502.01189},
+      journal={arXiv},
+      primaryClass={eess.IV},
+      url={https://arxiv.org/abs/2502.01189}, 
+}
+```
+
+📋 **License**
+This project is released under the <a rel="license" href="https://github.com/DDCM-2025/ddcm-compressed-image-generation/blob/master/LICENSE">MIT license</a>.
+
+📧 **Contact**
+If you have any questions, please feel free to contact us at <b>[email protected]</b> (Guy Ohayon) and <b>[email protected]</b> (Hila Manor).
+"""
+
+custom_css = """
+    .tabs button {
+        font-size: 21px !important;
+        font-weight: bold !important;
+    }
+"""
+
+with gr.Blocks(theme=gr.themes.Soft(), css=custom_css) as demo:
+    gr.HTML(title)
+    gr.HTML(intro)
+    # gr.Markdown("# Compressed Image Generation with Denoising Diffusion Codebook Models")
+
+    with gr.Tab("Image Compression"):
+        gr.Markdown(
+            "- To change the bit rate, modify the number of diffusion timesteps (T) and/or the codebook sizes (K).")
+        gr.Markdown("- The input image will be center-cropped and resized to the specified size (512x512 or 768x768).")
+        # gr.Markdown("#### Notes:")
+        # gr.Markdown('* Since our methods relies on Stable Diffusion, we resize the input image to 512512 pixels')
+
+        with gr.Row():
+            with gr.Column(scale=2):
+                input_image = gr.Image(label="Input image", scale=2, image_mode='RGB', type='pil')
+                with gr.Group():
+                    with gr.Row():
+                        T = gr.Number(label="Diffusion timesteps (T)", minimum=50, maximum=1000, value=1000, scale=2)
+                        K = gr.Number(label="Size of each codebook (K)", minimum=2, maximum=8192, value=2048, scale=3)
+                    with gr.Row():
+                        model_type = gr.Radio(["768x768", "512x512"], label="Image size", value="512x512")
+                compress = gr.Button("Compress image")
+
+            with gr.Column(scale=3):
+                decompressed_image = gr.Image(label="Decompressed image", scale=2)
+                compressed_file_out = gr.File(label="Compressed bit-stream (output)", scale=0)
+
+        compress.click(validate_K, inputs=[K]).then(compression_func, inputs=[input_image, T, K, model_type],
+                                                    outputs=[decompressed_image, compressed_file_out])
+
+        gr.Examples([
+            ["examples/compression/1.jpg", 1000, 256, '512x512'],
+            ["examples/compression/2.jpg", 1000, 256, '512x512'],
+            ["examples/compression/4.jpg", 1000, 256, '512x512'],
+            ["examples/compression/7.jpg", 1000, 256, '512x512'],
+            ["examples/compression/8.jpg", 1000, 256, '512x512'],
+            ["examples/compression/13.jpg", 1000, 256, '512x512'],
+            ["examples/compression/15.jpg", 1000, 256, '512x512'],
+            ["examples/compression/17.jpg", 1000, 256, '512x512'],
+            ["examples/compression/18.jpg", 1000, 256, '512x512'],
+            ["examples/compression/19.jpg", 1000, 256, '512x512'],
+            ["examples/compression/21.jpg", 1000, 256, '512x512'],
+            ["examples/compression/22.jpg", 1000, 256, '512x512'],
+            ["examples/compression/23.jpg", 1000, 256, '512x512'],
+        ],
+            inputs=[input_image, T, K, model_type],
+            outputs=[decompressed_image, compressed_file_out],
+            fn=compression_func,
+            cache_examples='lazy')
+
+        gr.Markdown("### Decompress a previously generated bit-stream")
+        with gr.Row():
+            with gr.Column(scale=2):
+                bitstream = gr.File(label="Compressed bit-stream (input)", scale=0)
+                decompress = gr.Button("Decompress image")
+
+            with gr.Column(scale=3):
+                decompressed_image = gr.Image(label="Decompressed image (from uploaded bit-stream)", scale=2)
+
+        decompress.click(method_to_func['compression'], inputs=bitstream, outputs=decompressed_image)
+
+    with gr.Tab("Real-World Face Image Restoration"):
+        gr.Markdown(  # "Restore any degraded face image. "
+            "Please mark if your input face image is already aligned. "
+            "If not, we will try to automatically detect, crop and align the faces, and raise an error if no faces are found. Expect better results if your input image is already aligned.")
+
+        with gr.Row():
+            with gr.Column(scale=2):
+                with gr.Group():
+                    input_image = gr.Image(label="Input image", scale=2, type='filepath')
+                    aligned = gr.Checkbox(label='Input face image is aligned')
+                with gr.Group():
+                    with gr.Row():
+                        T = gr.Number(label="Diffusion timesteps (T)", minimum=50, maximum=1000, value=1000)
+                        K = gr.Number(label="Size of each codebook (K)", minimum=2, maximum=8192, value=2048)
+                    iqa_metric = gr.Radio(['NIQE', 'TOPIQ', 'CLIP-IQA'], label='Perceptual quality measure to optimize',
+                                          value='NIQE')
+                    iqa_coef = gr.Number(
+                        label="Perception-distortion tradeoff coefficient (λ)",
+                        info="Higher -> better perceptual quality",
+                        # label="Coefficient controlling the perception-distortion tradeoff (higher means better perceptual quality)",
+                        minimum=0, maximum=1, value=1)
+                restore = gr.Button("Restore and compress")
+
+            with gr.Column(scale=3):
+                decompressed_image = gr.Gallery(label="Restored faces gallery", type="numpy", show_label=True,
+                                                format="png")
+                compressed_file_out = gr.File(label="Compressed bit-stream (output)", scale=0, file_count='multiple')
+
+        restore.click(validate_K, inputs=[K]).then(DDCM_blind_face_image_restoration.inference,
+                                                   inputs=[input_image, T, K, iqa_metric, iqa_coef, aligned],
+                                                   outputs=[decompressed_image, compressed_file_out])
+        gr.Examples([
+            ["examples/bfr/00000055.png", 1000, 4096, 'TOPIQ', 0.1, True],
+            ["examples/bfr/00000085.png", 1000, 4096, 'TOPIQ', 0.1, True],
+            ["examples/bfr/00000113.png", 1000, 4096, 'TOPIQ', 0.1, True],
+            ["examples/bfr/00000137.png", 1000, 4096, 'TOPIQ', 0.1, True],
+            ["examples/bfr/wider/0034.jpg", 1000, 4096, 'NIQE', 1, True],
+            ["examples/bfr/webphoto/00042_00.jpg", 1000, 4096, 'TOPIQ', 0.1, True],
+            ["examples/bfr/lfw/Ana_Palacio_0001_00.jpg", 1000, 4096, 'TOPIQ', 0.1, True],
+            ["examples/bfr/01.png", 1000, 4096, 'NIQE', 0.1, False],
+            ["examples/bfr/03.jpg", 1000, 4096, 'TOPIQ', 0.1, False],
+        ],
+            inputs=[input_image, T, K, iqa_metric, iqa_coef, aligned],
+            outputs=[decompressed_image, compressed_file_out],
+            fn=DDCM_blind_face_image_restoration.inference,
+            cache_examples='lazy')
+
+        gr.Markdown("### Decompress a previously generated bit-stream")
+        with gr.Row():
+            with gr.Column(scale=2):
+                bitstream = gr.File(label="Compressed bit-stream (input)", scale=0)
+                decompress = gr.Button("Decompress image")
+
+            with gr.Column(scale=3):
+                decompressed_image = gr.Image(label="Decompressed image (from uploaded bit-stream)", scale=2)
+
+        decompress.click(method_to_func['blind'], inputs=bitstream, outputs=decompressed_image)
+
+    with gr.Tab("Compressed Text-to-Image Generation"):
+        gr.Markdown(
+            "This application demonstrates the capabilities of our new *compressed* classifier-free guidance method, which *does not require the input condition for decompression*."
+            "  \n"  # newline
+            "Each image is generated along with its compressed bit-stream representation, and the input condition is implicitly encoded in the bit-stream.")
+        # gr.Markdown("### Generate an image and its compressed bit-stream given an input text prompt")
+        # gr.Markdown("#### Notes:")
+        # gr.Markdown("* The size of the generated image is 512x512")
+
+        with gr.Row():
+            with gr.Column(scale=2):
+                with gr.Group():
+                    text_input = gr.Textbox(label="Input text prompt", scale=1, value="An image of a dog")
+                    with gr.Row():
+                        T = gr.Number(label="Diffusion timesteps (T)", minimum=50, maximum=1000, value=1000, scale=1)
+                        K = gr.Number(label="Size of each codebook (K)", minimum=2, maximum=256, value=128, scale=1)
+                    K_tilde = gr.Number(label=r"Sub-sampled codebooks' sizes (K̃)", scale=1,
+                                        info="Behaves like a guidance scale", minimum=2, maximum=256, value=32)
+                    model_type = gr.Radio(["768x768", "512x512"], label="Image size", value="512x512")
+                button = gr.Button("Generate and compress")
+
+            with gr.Column(scale=3):
+                decompressed_image = gr.Image(label="Generated image", scale=2)
+                compressed_file_out = gr.File(label="Compressed bit-stream (output)", scale=0)
+
+        button.click(validate_K, inputs=[K]).then(ccfg, inputs=[text_input, T, K, K_tilde, model_type],
+                                                  outputs=[decompressed_image, compressed_file_out])
+
+        gr.Examples([
+            ["An image of a dog", 1000, 64, 4, '512x512'],
+            ["Rainbow over the mountains", 1000, 64, 4, '512x512'],
+            ["A cat playing soccer", 1000, 64, 4, '512x512'],
+        ],
+            inputs=[text_input, T, K, K_tilde, model_type],
+            outputs=[decompressed_image, compressed_file_out],
+            fn=ccfg,
+            cache_examples='lazy')
+        gr.Markdown("### Decompress a previously generated bit-stream")
+        with gr.Row():
+            with gr.Column(scale=2):
+                bitstream = gr.File(label="Compressed bit-stream (input)", scale=0)
+                button = gr.Button("Decompress")
+            with gr.Column(scale=3):
+                decompressed_image = gr.Image(label="Decompressed image (from uploaded bit-stream)", scale=2)
+        button.click(method_to_func['ccfg'], inputs=bitstream, outputs=decompressed_image)
+
+    gr.Markdown(article)
+
+demo.queue()
+demo.launch(state_session_capacity=500)
+

guided_diffusion/__init__.py

@@ -0,0 +1,3 @@
+"""
+Codebase for "Improved Denoising Diffusion Probabilistic Models".
+"""

guided_diffusion/condition_methods.py

@@ -0,0 +1,106 @@
+from abc import ABC, abstractmethod
+import torch
+
+__CONDITIONING_METHOD__ = {}
+
+def register_conditioning_method(name: str):
+    def wrapper(cls):
+        if __CONDITIONING_METHOD__.get(name, None):
+            raise NameError(f"Name {name} is already registered!")
+        __CONDITIONING_METHOD__[name] = cls
+        return cls
+    return wrapper
+
+def get_conditioning_method(name: str, operator, noiser, **kwargs):
+    if __CONDITIONING_METHOD__.get(name, None) is None:
+        raise NameError(f"Name {name} is not defined!")
+    return __CONDITIONING_METHOD__[name](operator=operator, noiser=noiser, **kwargs)
+
+    
+class ConditioningMethod(ABC):
+    def __init__(self, operator, noiser, **kwargs):
+        self.operator = operator
+        self.noiser = noiser
+    
+    def project(self, data, noisy_measurement, **kwargs):
+        return self.operator.project(data=data, measurement=noisy_measurement, **kwargs)
+    
+    def grad_and_value(self, x_prev, x_0_hat, measurement, **kwargs):
+        if self.noiser.__name__ == 'gaussian':
+            difference = measurement - self.operator.forward(x_0_hat, **kwargs)
+            norm = torch.linalg.norm(difference)
+            norm_grad = torch.autograd.grad(outputs=norm, inputs=x_prev)[0]
+        
+        elif self.noiser.__name__ == 'poisson':
+            Ax = self.operator.forward(x_0_hat, **kwargs)
+            difference = measurement-Ax
+            norm = torch.linalg.norm(difference) / measurement.abs()
+            norm = norm.mean()
+            norm_grad = torch.autograd.grad(outputs=norm, inputs=x_prev)[0]
+
+        else:
+            raise NotImplementedError
+             
+        return norm_grad, norm
+   
+    @abstractmethod
+    def conditioning(self, x_t, measurement, noisy_measurement=None, **kwargs):
+        pass
+    
+@register_conditioning_method(name='vanilla')
+class Identity(ConditioningMethod):
+    # just pass the input without conditioning
+    def conditioning(self, x_t):
+        return x_t
+    
+@register_conditioning_method(name='projection')
+class Projection(ConditioningMethod):
+    def conditioning(self, x_t, noisy_measurement, **kwargs):
+        x_t = self.project(data=x_t, noisy_measurement=noisy_measurement)
+        return x_t
+
+
+@register_conditioning_method(name='mcg')
+class ManifoldConstraintGradient(ConditioningMethod):
+    def __init__(self, operator, noiser, **kwargs):
+        super().__init__(operator, noiser)
+        self.scale = kwargs.get('scale', 1.0)
+        
+    def conditioning(self, x_prev, x_t, x_0_hat, measurement, noisy_measurement, **kwargs):
+        # posterior sampling
+        norm_grad, norm = self.grad_and_value(x_prev=x_prev, x_0_hat=x_0_hat, measurement=measurement, **kwargs)
+        x_t -= norm_grad * self.scale
+        
+        # projection
+        x_t = self.project(data=x_t, noisy_measurement=noisy_measurement, **kwargs)
+        return x_t, norm
+        
+@register_conditioning_method(name='ps')
+class PosteriorSampling(ConditioningMethod):
+    def __init__(self, operator, noiser, **kwargs):
+        super().__init__(operator, noiser)
+        self.scale = kwargs.get('scale', 1.0)
+
+    def conditioning(self, x_prev, x_t, x_0_hat, measurement, **kwargs):
+        norm_grad, norm = self.grad_and_value(x_prev=x_prev, x_0_hat=x_0_hat, measurement=measurement, **kwargs)
+        x_t -= norm_grad * self.scale
+        return x_t, norm
+        
+@register_conditioning_method(name='ps+')
+class PosteriorSamplingPlus(ConditioningMethod):
+    def __init__(self, operator, noiser, **kwargs):
+        super().__init__(operator, noiser)
+        self.num_sampling = kwargs.get('num_sampling', 5)
+        self.scale = kwargs.get('scale', 1.0)
+
+    def conditioning(self, x_prev, x_t, x_0_hat, measurement, **kwargs):
+        norm = 0
+        for _ in range(self.num_sampling):
+            # TODO: use noiser?
+            x_0_hat_noise = x_0_hat + 0.05 * torch.rand_like(x_0_hat)
+            difference = measurement - self.operator.forward(x_0_hat_noise)
+            norm += torch.linalg.norm(difference) / self.num_sampling
+        
+        norm_grad = torch.autograd.grad(outputs=norm, inputs=x_prev)[0]
+        x_t -= norm_grad * self.scale
+        return x_t, norm

guided_diffusion/diffusion_config.yaml

@@ -0,0 +1,9 @@
+sampler: ddim
+steps: 1000
+noise_schedule: linear
+model_mean_type: epsilon 
+model_var_type: learned_range
+dynamic_threshold: False
+clip_denoised: True
+rescale_timesteps: False
+timestep_respacing: 1000

guided_diffusion/ffhq512_model_config.yaml

@@ -0,0 +1,24 @@
+# Defaults for image training.
+
+image_size: 512
+num_channels: 32
+num_res_blocks: "1,2,2,2,2,3,4"
+learn_sigma: True
+class_cond: False
+conv_resample: True
+attention_resolutions: "32,16,8"
+num_head_channels: 64
+use_scale_shift_norm: True
+resblock_updown: False
+use_fp16: False
+use_checkpoint: False
+channel_mult: "1,2,4,8,8,16,16"
+num_heads: 1
+num_heads_upsample: -1
+dropout: 0.0
+dims: 2
+use_new_attention_order: False
+
+model_path: ./guided_diffusion/iddpm_ffhq512_ema500000.pth
+
+

guided_diffusion/fp16_util.py

@@ -0,0 +1,234 @@
+"""
+Helpers to train with 16-bit precision.
+"""
+
+import numpy as np
+import torch as th
+import torch.nn as nn
+from torch._utils import _flatten_dense_tensors, _unflatten_dense_tensors
+
+INITIAL_LOG_LOSS_SCALE = 20.0
+
+
+def convert_module_to_f16(l):
+    """
+    Convert primitive modules to float16.
+    """
+    if isinstance(l, (nn.Conv1d, nn.Conv2d, nn.Conv3d)):
+        l.weight.data = l.weight.data.half()
+        if l.bias is not None:
+            l.bias.data = l.bias.data.half()
+
+
+def convert_module_to_f32(l):
+    """
+    Convert primitive modules to float32, undoing convert_module_to_f16().
+    """
+    if isinstance(l, (nn.Conv1d, nn.Conv2d, nn.Conv3d)):
+        l.weight.data = l.weight.data.float()
+        if l.bias is not None:
+            l.bias.data = l.bias.data.float()
+
+
+def make_master_params(param_groups_and_shapes):
+    """
+    Copy model parameters into a (differently-shaped) list of full-precision
+    parameters.
+    """
+    master_params = []
+    for param_group, shape in param_groups_and_shapes:
+        master_param = nn.Parameter(
+            _flatten_dense_tensors(
+                [param.detach().float() for (_, param) in param_group]
+            ).view(shape)
+        )
+        master_param.requires_grad = True
+        master_params.append(master_param)
+    return master_params
+
+
+def model_grads_to_master_grads(param_groups_and_shapes, master_params):
+    """
+    Copy the gradients from the model parameters into the master parameters
+    from make_master_params().
+    """
+    for master_param, (param_group, shape) in zip(
+        master_params, param_groups_and_shapes
+    ):
+        master_param.grad = _flatten_dense_tensors(
+            [param_grad_or_zeros(param) for (_, param) in param_group]
+        ).view(shape)
+
+
+def master_params_to_model_params(param_groups_and_shapes, master_params):
+    """
+    Copy the master parameter data back into the model parameters.
+    """
+    # Without copying to a list, if a generator is passed, this will
+    # silently not copy any parameters.
+    for master_param, (param_group, _) in zip(master_params, param_groups_and_shapes):
+        for (_, param), unflat_master_param in zip(
+            param_group, unflatten_master_params(param_group, master_param.view(-1))
+        ):
+            param.detach().copy_(unflat_master_param)
+
+
+def unflatten_master_params(param_group, master_param):
+    return _unflatten_dense_tensors(master_param, [param for (_, param) in param_group])
+
+
+def get_param_groups_and_shapes(named_model_params):
+    named_model_params = list(named_model_params)
+    scalar_vector_named_params = (
+        [(n, p) for (n, p) in named_model_params if p.ndim <= 1],
+        (-1),
+    )
+    matrix_named_params = (
+        [(n, p) for (n, p) in named_model_params if p.ndim > 1],
+        (1, -1),
+    )
+    return [scalar_vector_named_params, matrix_named_params]
+
+
+def master_params_to_state_dict(
+    model, param_groups_and_shapes, master_params, use_fp16
+):
+    if use_fp16:
+        state_dict = model.state_dict()
+        for master_param, (param_group, _) in zip(
+            master_params, param_groups_and_shapes
+        ):
+            for (name, _), unflat_master_param in zip(
+                param_group, unflatten_master_params(param_group, master_param.view(-1))
+            ):
+                assert name in state_dict
+                state_dict[name] = unflat_master_param
+    else:
+        state_dict = model.state_dict()
+        for i, (name, _value) in enumerate(model.named_parameters()):
+            assert name in state_dict
+            state_dict[name] = master_params[i]
+    return state_dict
+
+
+def state_dict_to_master_params(model, state_dict, use_fp16):
+    if use_fp16:
+        named_model_params = [
+            (name, state_dict[name]) for name, _ in model.named_parameters()
+        ]
+        param_groups_and_shapes = get_param_groups_and_shapes(named_model_params)
+        master_params = make_master_params(param_groups_and_shapes)
+    else:
+        master_params = [state_dict[name] for name, _ in model.named_parameters()]
+    return master_params
+
+
+def zero_master_grads(master_params):
+    for param in master_params:
+        param.grad = None
+
+
+def zero_grad(model_params):
+    for param in model_params:
+        # Taken from https://pytorch.org/docs/stable/_modules/torch/optim/optimizer.html#Optimizer.add_param_group
+        if param.grad is not None:
+            param.grad.detach_()
+            param.grad.zero_()
+
+
+def param_grad_or_zeros(param):
+    if param.grad is not None:
+        return param.grad.data.detach()
+    else:
+        return th.zeros_like(param)
+
+
+class MixedPrecisionTrainer:
+    def __init__(
+        self,
+        *,
+        model,
+        use_fp16=False,
+        fp16_scale_growth=1e-3,
+        initial_lg_loss_scale=INITIAL_LOG_LOSS_SCALE,
+    ):
+        self.model = model
+        self.use_fp16 = use_fp16
+        self.fp16_scale_growth = fp16_scale_growth
+
+        self.model_params = list(self.model.parameters())
+        self.master_params = self.model_params
+        self.param_groups_and_shapes = None
+        self.lg_loss_scale = initial_lg_loss_scale
+
+        if self.use_fp16:
+            self.param_groups_and_shapes = get_param_groups_and_shapes(
+                self.model.named_parameters()
+            )
+            self.master_params = make_master_params(self.param_groups_and_shapes)
+            self.model.convert_to_fp16()
+
+    def zero_grad(self):
+        zero_grad(self.model_params)
+
+    def backward(self, loss: th.Tensor):
+        if self.use_fp16:
+            loss_scale = 2 ** self.lg_loss_scale
+            (loss * loss_scale).backward()
+        else:
+            loss.backward()
+
+    def optimize(self, opt: th.optim.Optimizer):
+        if self.use_fp16:
+            return self._optimize_fp16(opt)
+        else:
+            return self._optimize_normal(opt)
+
+    def _optimize_fp16(self, opt: th.optim.Optimizer):
+        logger.logkv_mean("lg_loss_scale", self.lg_loss_scale)
+        model_grads_to_master_grads(self.param_groups_and_shapes, self.master_params)
+        grad_norm, param_norm = self._compute_norms(grad_scale=2 ** self.lg_loss_scale)
+        if check_overflow(grad_norm):
+            self.lg_loss_scale -= 1
+            logger.log(f"Found NaN, decreased lg_loss_scale to {self.lg_loss_scale}")
+            zero_master_grads(self.master_params)
+            return False
+
+        logger.logkv_mean("grad_norm", grad_norm)
+        logger.logkv_mean("param_norm", param_norm)
+
+        self.master_params[0].grad.mul_(1.0 / (2 ** self.lg_loss_scale))
+        opt.step()
+        zero_master_grads(self.master_params)
+        master_params_to_model_params(self.param_groups_and_shapes, self.master_params)
+        self.lg_loss_scale += self.fp16_scale_growth
+        return True
+
+    def _optimize_normal(self, opt: th.optim.Optimizer):
+        grad_norm, param_norm = self._compute_norms()
+        logger.logkv_mean("grad_norm", grad_norm)
+        logger.logkv_mean("param_norm", param_norm)
+        opt.step()
+        return True
+
+    def _compute_norms(self, grad_scale=1.0):
+        grad_norm = 0.0
+        param_norm = 0.0
+        for p in self.master_params:
+            with th.no_grad():
+                param_norm += th.norm(p, p=2, dtype=th.float32).item() ** 2
+                if p.grad is not None:
+                    grad_norm += th.norm(p.grad, p=2, dtype=th.float32).item() ** 2
+        return np.sqrt(grad_norm) / grad_scale, np.sqrt(param_norm)
+
+    def master_params_to_state_dict(self, master_params):
+        return master_params_to_state_dict(
+            self.model, self.param_groups_and_shapes, master_params, self.use_fp16
+        )
+
+    def state_dict_to_master_params(self, state_dict):
+        return state_dict_to_master_params(self.model, state_dict, self.use_fp16)
+
+
+def check_overflow(value):
+    return (value == float("inf")) or (value == -float("inf")) or (value != value)

guided_diffusion/gaussian_diffusion.py

@@ -0,0 +1,864 @@
+import math
+import os
+# from functools import partial
+# from clip_fiqa.inference import get_model, compute_quality
+import matplotlib.pyplot as plt
+import numpy as np
+import torch
+from tqdm.auto import tqdm
+# from torchmetrics.multimodal import CLIPImageQualityAssessment
+import random
+# from torch.nn.functional import cosine_similarity
+import pyiqa
+
+from util.img_utils import clear_color
+from .posterior_mean_variance import get_mean_processor, get_var_processor
+
+
+def set_seed(seed):
+    torch.manual_seed(seed)
+    np.random.seed(seed)
+    random.seed(seed)
+    torch.cuda.manual_seed_all(seed)
+    # torch.backends.cudnn.deterministic = True
+    # torch.backends.cudnn.benchmark = False
+
+__SAMPLER__ = {}
+
+def register_sampler(name: str):
+    def wrapper(cls):
+        if __SAMPLER__.get(name, None):
+            raise NameError(f"Name {name} is already registered!") 
+        __SAMPLER__[name] = cls
+        return cls
+    return wrapper
+
+
+def get_sampler(name: str):
+    if __SAMPLER__.get(name, None) is None:
+        raise NameError(f"Name {name} is not defined!")
+    return __SAMPLER__[name]
+
+
+def create_sampler(sampler,
+                   steps,
+                   noise_schedule,
+                   model_mean_type,
+                   model_var_type,
+                   dynamic_threshold,
+                   clip_denoised,
+                   rescale_timesteps,
+                   timestep_respacing=""):
+    
+    sampler = get_sampler(name=sampler)
+    
+    betas = get_named_beta_schedule(noise_schedule, steps)
+    if not timestep_respacing:
+        timestep_respacing = [steps]
+         
+    return sampler(use_timesteps=space_timesteps(steps, timestep_respacing),
+                   betas=betas,
+                   model_mean_type=model_mean_type,
+                   model_var_type=model_var_type,
+                   dynamic_threshold=dynamic_threshold,
+                   clip_denoised=clip_denoised, 
+                   rescale_timesteps=rescale_timesteps)
+
+def compute_psnr(img1, img2):
+    """
+    Computes the Peak Signal-to-Noise Ratio (PSNR) between two images.
+    The images should have pixel values in the range [-1, 1].
+
+    Args:
+        img1 (torch.Tensor): The first image tensor (e.g., reference image).
+                             Shape: (N, C, H, W) or (C, H, W).
+        img2 (torch.Tensor): The second image tensor (e.g., generated image).
+                             Shape: same as img1.
+
+    Returns:
+        psnr (float): The computed PSNR value in decibels (dB).
+    """
+    # Ensure the input tensors are in the same shape
+    assert img1.shape == img2.shape, "Input images must have the same shape"
+
+    # Compute Mean Squared Error (MSE)
+    mse = torch.mean((img1 - img2) ** 2)
+
+    # Avoid division by zero in case of identical images
+    if mse == 0:
+        return float('inf')
+
+    # Maximum possible pixel value difference in the range [-1, 1] is 2
+    max_pixel_value = 2.0
+
+    # Compute PSNR
+    psnr = 20 * torch.log10(max_pixel_value / torch.sqrt(mse))
+
+    return psnr.item()
+
+class GaussianDiffusion:
+    def __init__(self,
+                 betas,
+                 model_mean_type,
+                 model_var_type,
+                 dynamic_threshold,
+                 clip_denoised,
+                 rescale_timesteps
+                 ):
+
+        # use float64 for accuracy.
+        betas = np.array(betas, dtype=np.float64)
+        self.betas = betas
+        assert self.betas.ndim == 1, "betas must be 1-D"
+        assert (0 < self.betas).all() and (self.betas <=1).all(), "betas must be in (0..1]"
+
+        self.num_timesteps = int(self.betas.shape[0])
+        self.rescale_timesteps = rescale_timesteps
+
+        alphas = 1.0 - self.betas
+        self.alphas = alphas
+        self.alphas_cumprod = np.cumprod(alphas, axis=0)
+        self.alphas_cumprod_prev = np.append(1.0, self.alphas_cumprod[:-1])
+        self.alphas_cumprod_next = np.append(self.alphas_cumprod[1:], 0.0)
+        assert self.alphas_cumprod_prev.shape == (self.num_timesteps,)
+
+        # calculations for diffusion q(x_t | x_{t-1}) and others
+        self.sqrt_alphas_cumprod = np.sqrt(self.alphas_cumprod)
+        self.sqrt_one_minus_alphas_cumprod = np.sqrt(1.0 - self.alphas_cumprod)
+        self.log_one_minus_alphas_cumprod = np.log(1.0 - self.alphas_cumprod)
+        self.sqrt_recip_alphas_cumprod = np.sqrt(1.0 / self.alphas_cumprod)
+        self.sqrt_recipm1_alphas_cumprod = np.sqrt(1.0 / self.alphas_cumprod - 1)
+
+        # calculations for posterior q(x_{t-1} | x_t, x_0)
+        self.posterior_variance = (
+            betas * (1.0 - self.alphas_cumprod_prev) / (1.0 - self.alphas_cumprod)
+        )
+        # log calculation clipped because the posterior variance is 0 at the
+        # beginning of the diffusion chain.
+        self.posterior_log_variance_clipped = np.log(
+            np.append(self.posterior_variance[1], self.posterior_variance[1:])
+        )
+        self.posterior_mean_coef1 = (
+            betas * np.sqrt(self.alphas_cumprod_prev) / (1.0 - self.alphas_cumprod)
+        )
+        self.posterior_mean_coef2 = (
+            (1.0 - self.alphas_cumprod_prev)
+            * np.sqrt(alphas)
+            / (1.0 - self.alphas_cumprod)
+        )
+
+        self.mean_processor = get_mean_processor(model_mean_type,
+                                                 betas=betas,
+                                                 dynamic_threshold=dynamic_threshold,
+                                                 clip_denoised=clip_denoised)    
+    
+        self.var_processor = get_var_processor(model_var_type,
+                                               betas=betas)
+
+    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_and_expand(self.sqrt_alphas_cumprod, t, x_start) * x_start
+        variance = extract_and_expand(1.0 - self.alphas_cumprod, t, x_start)
+        log_variance = extract_and_expand(self.log_one_minus_alphas_cumprod, t, x_start)
+
+        return mean, variance, log_variance
+
+    def q_sample(self, x_start, t):
+        """
+        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.
+        """
+        noise = torch.randn_like(x_start)
+        assert noise.shape == x_start.shape
+        
+        coef1 = extract_and_expand(self.sqrt_alphas_cumprod, t, x_start)
+        coef2 = extract_and_expand(self.sqrt_one_minus_alphas_cumprod, t, x_start)
+
+        return coef1 * x_start + coef2 * 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
+        coef1 = extract_and_expand(self.posterior_mean_coef1, t, x_start)
+        coef2 = extract_and_expand(self.posterior_mean_coef2, t, x_t)
+        posterior_mean = coef1 * x_start + coef2 * x_t
+        posterior_variance = extract_and_expand(self.posterior_variance, t, x_t)
+        posterior_log_variance_clipped = extract_and_expand(self.posterior_log_variance_clipped, t, x_t)
+
+        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
+
+    torch.no_grad()
+    def p_sample_loop_compression(self,
+                                  model,
+                                  x_start,
+                                  ref_img,
+                                  record,
+                                  save_root,
+                                  num_opt_noises,
+                                  num_random_noises,
+                                  loss_type,
+                                  decode_residual_gap,
+                                  fname,
+                                  eta,
+                                  num_best_opt_noises,
+                                  num_pursuit_noises,
+                                  num_pursuit_coef_bits,
+                                  random_opt_mse_noises):
+        """
+        The function used for sampling from noise.
+        """
+        assert num_best_opt_noises + num_random_noises > 0
+        # loss_fn_vgg = lpips.LPIPS(net='vgg').cuda()
+        # loss_fn_alex = lpips.LPIPS(net='alex').cuda()
+
+        set_seed(100000)
+        device = x_start.device
+        img = torch.randn(1 + random_opt_mse_noises, *x_start.shape[1:], device=device)
+
+        plt.imsave(os.path.join(save_root, f"progress/img_to_compress.png"), clear_color(ref_img))
+        best_indices_list = []
+        x_hat_0_list = []
+
+        pbar = tqdm(list(range(self.num_timesteps))[::-1])
+        num_noises_total = 0
+        num_steps_total = 0
+        for idx in pbar:
+            set_seed(idx)
+            time = torch.tensor([idx] * img.shape[0], device=device)
+            if len(x_hat_0_list) >= 2:
+                x_hat_0_list = x_hat_0_list[-decode_residual_gap:]
+                x_hat_0_list_tensor = torch.stack(x_hat_0_list, dim=0)
+
+                # TODO: think about different probs schedulings
+                probs = torch.linspace(0, 1, len(x_hat_0_list) - 1, device=device)
+                probs /= torch.sum(probs)
+
+                residual = torch.sum(probs.view(-1, 1) * (x_hat_0_list_tensor[1:] - x_hat_0_list_tensor[:-1]).view(len(x_hat_0_list) - 1, -1), dim=0)
+
+                new_noise = torch.randn(num_opt_noises, *img.shape[1:], device=device)
+                similarity = torch.matmul(new_noise.view(num_opt_noises, -1),
+                                          residual.view(-1, 1)).squeeze(1)
+                sorted_similarity, sorted_indices = torch.sort(similarity, descending=False)
+
+                noise = new_noise[sorted_indices][:num_best_opt_noises]
+                if num_random_noises > 0:
+                    noise = torch.cat((noise, torch.randn(num_random_noises, *img.shape[1:], device=device)), dim=0)
+
+            else:
+                noise = torch.randn(num_best_opt_noises + num_random_noises, *img.shape[1:], device=device)
+            num_noises_total += noise.shape[0]
+            num_steps_total += 1
+            # perceptual_loss_weight = (1 - (idx / len(pbar))) * lpips_loss_mult
+            out = self.p_sample(x=img,
+                                t=time,
+                                model=model,
+                                noise=noise,
+                                ref=ref_img,
+                                loss_type=loss_type,
+                                random_opt_mse_noises=random_opt_mse_noises,
+                                eta=eta,
+                                num_pursuit_noises=num_pursuit_noises,
+                                num_pursuit_coef_bits=num_pursuit_coef_bits)
+            best_idx = out['best_idx']
+            best_indices_list.append(best_idx.cpu().numpy())
+            # print(best_indices_list, '\n\n', flush=True)
+
+            img = out['sample']
+            x_0_hat = out['pred_xstart']
+            x_hat_0_list.append(x_0_hat[0].unsqueeze(0))
+            # chosen_noises_list.append(noise[best_idx])
+
+            # pbar.set_postfix({'distance': out['mse']}, refresh=False)
+            if record:
+                if idx % 50 == 0:
+                    plt.imsave(os.path.join(save_root, f"progress/x_0_hat_{str(idx).zfill(4)}.png"), clear_color(x_0_hat[0].unsqueeze(0).clip(-1, 1)))
+                    plt.imsave(os.path.join(save_root, f"progress/x_t_{str(idx).zfill(4)}.png"), clear_color(img[0].unsqueeze(0).clip(-1, 1)))
+                    plt.imsave(os.path.join(save_root, f"progress/noise_t_{str(idx).zfill(4)}.png"), clear_color(noise[0].unsqueeze(0).clip(-1, 1)))
+                    plt.imsave(os.path.join(save_root, f"progress/err_t_{str(idx).zfill(4)}.png"), clear_color((ref_img - x_0_hat)[0].unsqueeze(0)))
+            del noise
+
+        # lpips_vgg = loss_fn_vgg(img, ref_img).squeeze().item()
+        # lpips_alex = loss_fn_alex(img, ref_img).squeeze().item()
+        plt.imsave(os.path.join(save_root,
+                                f"progress/x_0_hat_final_psnr={compute_psnr(img[0].unsqueeze(0), ref_img)}_bpp={np.log2(num_noises_total / num_steps_total)}.png"),
+                   clear_color(img[0].unsqueeze(0)))
+        indices_save_folder =  os.path.join(save_root, 'best_indices')
+        os.makedirs(indices_save_folder, exist_ok=True)
+        np.save(os.path.join(indices_save_folder, os.path.splitext(os.path.basename(fname))[0] + '.bestindices'), np.array(best_indices_list))
+
+        return img
+
+    @torch.no_grad()
+    def p_sample_loop_blind_restoration(self,
+                                        model,
+                                        x_start,
+                                        mmse_img,
+                                        num_opt_noises,
+                                        iqa_metric,
+                                        iqa_coef,
+                                        eta,
+                                        loaded_indices):
+
+        assert iqa_metric == 'niqe' or iqa_metric == 'clipiqa+' or iqa_metric == 'topiq_nr-face'
+        iqa = pyiqa.create_metric(iqa_metric, device=x_start.device)
+        device = x_start.device
+
+        set_seed(100000)
+        img = torch.randn(2, *x_start.shape[1:], device=device)
+
+        pbar = tqdm(list(range(self.num_timesteps))[::-1])
+        next_idx = np.array([0, 1])
+        if loaded_indices is not None:
+            indices = loaded_indices
+            loaded_indices = torch.cat((loaded_indices, torch.tensor([0], device=device, dtype=loaded_indices.dtype)), dim=0)
+        else:
+            indices = []
+        for i, idx in enumerate(pbar):
+            set_seed(idx)
+
+
+            noise = torch.randn(num_opt_noises, *img.shape[1:], device=device)
+            if loaded_indices is None:
+                time = torch.tensor([idx] * img.shape[0], device=device)
+                out = self.p_sample(x=img,
+                                    t=time,
+                                    model=model,
+                                    noise=noise,
+                                    ref=mmse_img,
+                                    loss_type='dot_prod',
+                                    optimize_iqa=True,
+                                    eta=eta,
+                                    iqa=iqa,
+                                    iqa_coef=iqa_coef)
+                img = out['sample']
+                best_perceptual_idx_cur = out['best_perceptual_idx']
+                indices.append(next_idx[best_perceptual_idx_cur])
+                next_idx = out['best_idx']
+            else:
+                time = torch.tensor([idx], device=device)
+                if i == 0:
+                    img = img[loaded_indices[0]].unsqueeze(0)
+                out = self.p_sample(x=img,
+                                    t=time,
+                                    model=model,
+                                    noise=noise[loaded_indices[i+1]].unsqueeze(0),
+                                    ref=img,
+                                    loss_type='dot_prod',
+                                    optimize_iqa=False,
+                                    eta=eta,
+                                    iqa='niqe',
+                                    iqa_coef=0.0)
+                img = out['sample']
+
+
+        if type(indices) is list:
+            indices = torch.tensor(indices).flatten()
+        return img[0].unsqueeze(0), indices
+
+
+    @torch.no_grad()
+    def p_sample_loop_linear_restoration(self,
+                                        model,
+                                        x_start,
+                                        ref_img,
+                                        linear_operator,
+                                         y_n,
+                                         num_pursuit_noises,
+                                         num_pursuit_coef_bits,
+                                        record,
+                                        save_root,
+                                        num_opt_noises,
+                                        fname,
+                                        eta):
+        """
+        The function used for sampling from noise.
+        """
+
+        set_seed(100000)
+        device = x_start.device
+        img = torch.randn(1, *x_start.shape[1:], device=device)
+
+
+        pbar = tqdm(list(range(self.num_timesteps))[::-1])
+        for idx in pbar:
+            set_seed(idx)
+            time = torch.tensor([idx] * img.shape[0], device=device)
+
+            noise = torch.randn(num_opt_noises, *img.shape[1:], device=device)
+            # perceptual_loss_weight = (1 - (idx / len(pbar))) * lpips_loss_mult
+            out = self.p_sample(x=img,
+                                t=time,
+                                model=model,
+                                noise=noise,
+                                ref=ref_img,
+                                loss_type='mse',
+                                eta=eta,
+                                y_n=y_n,
+                                linear_operator=linear_operator,
+                                num_pursuit_noises=num_pursuit_noises,
+                                num_pursuit_coef_bits=num_pursuit_coef_bits,
+                                optimize_iqa=False,
+                                iqa=None,
+                                iqa_coef=None)
+            x_0_hat = out['pred_xstart']
+            img = out['sample']
+            # loss = (((x_0_hat - mmse_img) ** 2).mean()
+            #         - perceptual_quality_coef * clip_iqa((x_0_hat * 0.5 + 0.5).clip(0, 1)))
+
+            # pbar.set_postfix({'perceptual_quality': loss[best_perceptual_idx].item()}, refresh=False)
+            if record:
+                if idx % 50 == 0:
+                    plt.imsave(os.path.join(save_root, f"progress/x_0_hat_{str(idx).zfill(4)}.png"), clear_color(x_0_hat[0].unsqueeze(0).clip(-1, 1)))
+                    plt.imsave(os.path.join(save_root, f"progress/x_t_{str(idx).zfill(4)}.png"), clear_color(img[0].unsqueeze(0).clip(-1, 1)))
+
+
+        # plt.imsave(os.path.join(save_root,
+        #                         f"progress/x_0_hat_final_lpips-vgg={lpips_vgg:.4f}_lpips-alex"
+        #                         f"={lpips_alex:.4f}_psnr={compute_psnr(img[0].unsqueeze(0), ref_img)}_bpp={np.log2(num_noises_total / num_steps_total)}.png"),
+        #            clear_color(img[0].unsqueeze(0)))
+        # indices_save_folder =  os.path.join(save_root, 'best_indices')
+        # os.makedirs(indices_save_folder, exist_ok=True)
+        # np.save(os.path.join(indices_save_folder, os.path.splitext(os.path.basename(fname))[0] + '.bestindices'), np.array(best_indices_list))
+
+        return img
+    def p_sample(self, model, x, t, noise, ref, loss_type, eta=None):
+        raise NotImplementedError
+
+    def p_mean_variance(self, model, x, t):
+        model_output = model(x, self._scale_timesteps(t))
+        
+        # In the case of "learned" variance, model will give twice channels.
+        if model_output.shape[1] == 2 * x.shape[1]:
+            model_output, model_var_values = torch.split(model_output, x.shape[1], dim=1)
+        else:
+            # The name of variable is wrong. 
+            # This will just provide shape information, and 
+            # will not be used for calculating something important in variance.
+            model_var_values = model_output
+
+        model_mean, pred_xstart = self.mean_processor.get_mean_and_xstart(x, t, model_output)
+        model_variance, model_log_variance = self.var_processor.get_variance(model_var_values, t)
+
+        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 _scale_timesteps(self, t):
+        if self.rescale_timesteps:
+            return t.float() * (1000.0 / self.num_timesteps)
+        return t
+
+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.
+    If the stride is a string starting with "ddim", then the fixed striding
+    from the DDIM paper is used, and only one section is allowed.
+    :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"
+            )
+        section_counts = [int(x) for x in section_counts.split(",")]
+    elif isinstance(section_counts, int):
+        section_counts = [section_counts]
+    
+    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.timestep_map = []
+        self.original_num_steps = len(kwargs["betas"])
+
+        base_diffusion = GaussianDiffusion(**kwargs)  # pylint: disable=missing-kwoa
+        last_alpha_cumprod = 1.0
+        new_betas = []
+        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
+                self.timestep_map.append(i)
+        kwargs["betas"] = np.array(new_betas)
+        super().__init__(**kwargs)
+
+    def p_mean_variance(
+        self, model, *args, **kwargs
+    ):  # pylint: disable=signature-differs
+        return super().p_mean_variance(self._wrap_model(model), *args, **kwargs)
+
+    def training_losses(
+        self, model, *args, **kwargs
+    ):  # pylint: disable=signature-differs
+        return super().training_losses(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):
+        if isinstance(model, _WrappedModel):
+            return model
+        return _WrappedModel(
+            model, self.timestep_map, self.rescale_timesteps, self.original_num_steps
+        )
+
+    def _scale_timesteps(self, t):
+        # Scaling is done by the wrapped model.
+        return t
+
+
+class _WrappedModel:
+    def __init__(self, model, timestep_map, rescale_timesteps, original_num_steps):
+        self.model = model
+        self.timestep_map = timestep_map
+        self.rescale_timesteps = rescale_timesteps
+        self.original_num_steps = original_num_steps
+
+    def __call__(self, x, ts, **kwargs):
+        map_tensor = torch.tensor(self.timestep_map, device=ts.device, dtype=ts.dtype)
+        new_ts = map_tensor[ts]
+        if self.rescale_timesteps:
+            new_ts = new_ts.float() * (1000.0 / self.original_num_steps)
+        return self.model(x, new_ts, **kwargs)
+
+
+@register_sampler(name='ddpm')
+class DDPM(SpacedDiffusion):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+    def p_sample(self, model, x, t, noise, ref, perceptual_loss_weight, loss_type='mse', eta=None):
+        out = self.p_mean_variance(model, x, t)
+        pred_xstart = out['pred_xstart']
+
+        # if loss_type == 'mse':
+        #     loss = - ((pred_xstart + noise - ref).view(noise.shape[0], -1) ** 2).mean(1)
+        # elif loss_type == 'mse_alpha':
+        #     loss = - ((pred_xstart + torch.exp(0.5 * out['log_variance']) * noise - ref).view(noise.shape[0], -1) ** 2).mean(1)
+        if loss_type == 'dot_prod':
+            loss = torch.matmul(noise.view(noise.shape[0], -1), (ref - pred_xstart).view(pred_xstart.shape[0], -1).transpose(0, 1))
+        elif loss_type == 'mse':
+            #TODO: this is what we are doing! the dot product is an approximation of it!
+            sqrt_recip_alphas_cumprod = extract_and_expand(self.sqrt_recip_alphas_cumprod, t-1 if t[0] > 0 else torch.zeros_like(t), noise)
+            loss = - ((pred_xstart + sqrt_recip_alphas_cumprod * torch.exp(0.5 * out['log_variance']) * noise - ref).view(noise.shape[0], -1) ** 2).mean(1)
+        elif loss_type == 'l1':
+            sqrt_recip_alphas_cumprod = extract_and_expand(self.sqrt_recip_alphas_cumprod, t-1 if t[0] > 0 else torch.zeros_like(t), noise)
+            loss = - torch.abs(pred_xstart + sqrt_recip_alphas_cumprod * torch.exp(0.5 * out['log_variance']) * noise - ref).view(noise.shape[0], -1).mean(1)
+
+        # elif loss_type == 'ddpm_inversion':
+        #     sqrt_alphas_cumprod = extract_and_expand(self.sqrt_alphas_cumprod, t-1 if t[0] > 0 else torch.zeros_like(t), ref)
+        #     sqrt_one_minus_alphas_cumprod = extract_and_expand(self.sqrt_one_minus_alphas_cumprod, t-1 if t[0] > 0 else torch.zeros_like(t), ref)
+        #
+        #     forward_noise = torch.randn_like(ref)
+        #     loss = torch.matmul(noise.view(noise.shape[0], -1),
+        #                         (sqrt_alphas_cumprod * ref + sqrt_one_minus_alphas_cumprod * forward_noise - out['mean']).view(pred_xstart.shape[0], -1).transpose(0, 1))
+        #
+        #
+
+        else:
+            raise NotImplementedError()
+
+        best_idx = torch.argmax(loss)
+        samples = out['mean'] + torch.exp(0.5 * out['log_variance']) * noise[best_idx].unsqueeze(0)
+
+        return {'sample': samples if t[0] > 0 else pred_xstart,
+                'pred_xstart': pred_xstart,
+                'mse': loss[best_idx].item(),
+                'best_idx': best_idx}
+
+
+@register_sampler(name='ddim')
+class DDIM(SpacedDiffusion):
+    @torch.no_grad()
+    def p_sample(self, model, x, t, noise, ref, loss_type='mse', eta=0.0, iqa=None, iqa_coef=1.0,
+                 optimize_iqa=False, linear_operator=None, y_n=None, random_opt_mse_noises=0,
+                 num_pursuit_noises=1, num_pursuit_coef_bits=1,
+                 cond_fn=None,
+                 cls=None
+                 ):
+
+        out = self.p_mean_variance(model, x, t)
+        pred_xstart = out['pred_xstart']
+        best_perceptual_idx = None
+        if optimize_iqa:
+            assert not random_opt_mse_noises
+            coef_sign = 1 if iqa.lower_better else -1
+            if iqa.metric_name == 'topiq_nr-face':
+                assert not iqa.lower_better
+                # topiq_nr-face doesn't support a batch size larger than 1.
+                scores = []
+                for elem in pred_xstart:
+                    try:
+                        scores.append(iqa((elem.unsqueeze(0) * 0.5 + 0.5).clip(0, 1)).squeeze().view(1))
+                    except AssertionError:
+                        # no face detected...
+                        scores.append(torch.zeros(1, device=x.device))
+                scores = torch.stack(scores, dim=0).squeeze()
+                loss = (((ref - pred_xstart) ** 2).view(pred_xstart.shape[0], -1).mean(1) + coef_sign * iqa_coef * scores)
+            else:
+                loss = (((ref - pred_xstart) ** 2).view(pred_xstart.shape[0], -1).mean(1) + coef_sign * iqa_coef * iqa((pred_xstart * 0.5 + 0.5).clip(0, 1)).squeeze())
+            best_perceptual_idx = torch.argmin(loss)
+            out['pred_xstart'] = out['pred_xstart'][best_perceptual_idx].unsqueeze(0)
+            pred_xstart = pred_xstart[best_perceptual_idx].unsqueeze(0)
+            t = t[best_perceptual_idx]
+            x = x[best_perceptual_idx].unsqueeze(0)
+        elif random_opt_mse_noises > 0:
+            loss = (((ref - pred_xstart) ** 2).view(pred_xstart.shape[0], -1).mean(1))
+            best_mse_idx = torch.argmin(loss)
+            out['pred_xstart'] = out['pred_xstart'][best_mse_idx].unsqueeze(0)
+            pred_xstart = pred_xstart[best_mse_idx].unsqueeze(0)
+            t = t[best_mse_idx]
+            x = x[best_mse_idx].unsqueeze(0)
+
+        eps = self.predict_eps_from_x_start(x, t, out['pred_xstart'])
+        alpha_bar = extract_and_expand(self.alphas_cumprod, t, x)
+        alpha_bar_prev = extract_and_expand(self.alphas_cumprod_prev, t, x)
+        sigma = (
+                eta
+                * torch.sqrt((1 - alpha_bar_prev) / (1 - alpha_bar))
+                * torch.sqrt(1 - alpha_bar / alpha_bar_prev)
+        )
+        mean_pred = (
+                out["pred_xstart"] * torch.sqrt(alpha_bar_prev)
+                + torch.sqrt(1 - alpha_bar_prev - sigma ** 2) * eps
+        )
+        sample = mean_pred
+
+        if y_n is not None:
+            assert linear_operator is not None
+        y_n = ref if y_n is None else y_n
+
+        if not optimize_iqa and random_opt_mse_noises <= 0 and cond_fn is None:
+            if loss_type == 'dot_prod':
+                if linear_operator is None:
+                    compute_loss = lambda noise_cur: torch.matmul(noise_cur.view(noise_cur.shape[0], -1), (ref - pred_xstart).view(pred_xstart.shape[0], -1).transpose(0, 1))
+                else:
+                    compute_loss = lambda noise_cur: torch.matmul(linear_operator.forward(noise_cur).reshape(noise_cur.shape[0], -1), (y_n -  linear_operator.forward(pred_xstart)).reshape(pred_xstart.shape[0], -1).transpose(0, 1))
+            elif loss_type == 'mse':
+                if linear_operator is None:
+                    compute_loss = lambda noise_cur: - (((sigma / torch.sqrt(alpha_bar_prev)) * noise_cur + pred_xstart - y_n) ** 2).mean((1, 2, 3))
+                else:
+                    compute_loss = lambda noise_cur: - (((sigma / torch.sqrt(alpha_bar_prev))[:, :, :y_n.shape[2], :y_n.shape[3]] * linear_operator.forward(noise_cur) + linear_operator.forward(pred_xstart) - y_n) ** 2).mean((1, 2, 3))
+            else:
+                raise NotImplementedError()
+            # print("getting loss")
+            loss = compute_loss(noise)
+            best_idx = torch.argmax(loss)
+            best_noise = noise[best_idx]
+            best_loss = loss[best_idx]
+
+            if num_pursuit_noises > 1:
+                pursuit_coefs = np.linspace(0, 1, 2 ** num_pursuit_coef_bits + 1)[1:]
+
+                for _ in range(num_pursuit_noises - 1):
+                    next_best_noise = best_noise
+                    for pursuit_coef in pursuit_coefs:
+                        new_noise = best_noise.unsqueeze(0) * np.sqrt(pursuit_coef) + noise * np.sqrt(1 - pursuit_coef)
+                        new_noise /= new_noise.view(noise.shape[0], -1).std(1).view(noise.shape[0], 1, 1, 1)
+                        cur_loss = compute_loss(new_noise)
+                        cur_best_idx = torch.argmax(cur_loss)
+                        cur_best_loss = cur_loss[cur_best_idx]
+
+                        if cur_best_loss > best_loss:
+                            next_best_noise = new_noise[cur_best_idx]
+                            best_loss = cur_best_loss
+
+                    best_noise = next_best_noise
+
+            if t != 0:
+                sample += sigma * best_noise.unsqueeze(0)
+
+            return {'sample': sample if t[0] > 0 else pred_xstart,
+                    'pred_xstart': pred_xstart,
+                    'mse': loss[best_idx].item(),
+                    'best_idx': best_idx}
+        else:
+            if random_opt_mse_noises > 0 and not optimize_iqa:
+                num_rand_indices = random_opt_mse_noises
+            elif optimize_iqa and random_opt_mse_noises <= 0:
+                num_rand_indices = 1
+            elif cond_fn is not None:
+                num_rand_indices = 2
+            else:
+                raise NotImplementedError()
+            loss = torch.matmul(noise.view(noise.shape[0], -1),
+                                (ref - pred_xstart).view(pred_xstart.shape[0], -1).transpose(0, 1)).squeeze()
+            best_idx = torch.argmax(loss).reshape(1)
+            rand_idx = torch.randint(0, noise.shape[0], size=(num_rand_indices, ), device=best_idx.device).reshape(num_rand_indices)
+            best_and_rand_idx = torch.cat((best_idx, rand_idx), dim=0).flatten()
+            if t != 0:
+                sample = sample + sigma * noise[best_and_rand_idx]
+            return {'sample': sample,
+                    'pred_xstart': pred_xstart,
+                    'best_idx': best_and_rand_idx,
+                    'best_perceptual_idx': best_perceptual_idx}
+
+    def predict_eps_from_x_start(self, x_t, t, pred_xstart):
+        coef1 = extract_and_expand(self.sqrt_recip_alphas_cumprod, t, x_t)
+        coef2 = extract_and_expand(self.sqrt_recipm1_alphas_cumprod, t, x_t)
+        return (coef1 * x_t - pred_xstart) / coef2
+
+# =================
+# Helper functions
+# =================
+
+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
+        beta_start = scale * 0.0001
+        beta_end = scale * 0.02
+        return np.linspace(
+            beta_start, beta_end, num_diffusion_timesteps, dtype=np.float64
+        )
+    elif schedule_name == "cosine":
+        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)
+
+# ================
+# Helper function
+# ================
+
+def extract_and_expand(array, time, target):
+    array = torch.from_numpy(array).to(target.device)[time].float()
+    while array.ndim < target.ndim:
+        array = array.unsqueeze(-1)
+    return array.expand_as(target)
+
+
+def expand_as(array, target):
+    if isinstance(array, np.ndarray):
+        array = torch.from_numpy(array)
+    elif isinstance(array, np.float):
+        array = torch.tensor([array])
+   
+    while array.ndim < target.ndim:
+        array = array.unsqueeze(-1)
+
+    return array.expand_as(target).to(target.device)
+
+
+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 = torch.from_numpy(arr).to(device=timesteps.device)[timesteps].float()
+    while len(res.shape) < len(broadcast_shape):
+        res = res[..., None]
+    return res.expand(broadcast_shape)

guided_diffusion/measurements.py

@@ -0,0 +1,314 @@
+'''This module handles task-dependent operations (A) and noises (n) to simulate a measurement y=Ax+n.'''
+
+from abc import ABC, abstractmethod
+from functools import partial
+import yaml
+from torch.nn import functional as F
+from torchvision import torch
+
+from util.resizer import Resizer
+from util.img_utils import Blurkernel, fft2_m
+
+
+# =================
+# Operation classes
+# =================
+
+__OPERATOR__ = {}
+
+def register_operator(name: str):
+    def wrapper(cls):
+        if __OPERATOR__.get(name, None):
+            raise NameError(f"Name {name} is already registered!")
+        __OPERATOR__[name] = cls
+        return cls
+    return wrapper
+
+
+def get_operator(name: str, **kwargs):
+    if __OPERATOR__.get(name, None) is None:
+        raise NameError(f"Name {name} is not defined.")
+    return __OPERATOR__[name](**kwargs)
+
+
+class LinearOperator(ABC):
+    @abstractmethod
+    def forward(self, data, **kwargs):
+        # calculate A * X
+        pass
+
+    @abstractmethod
+    def transpose(self, data, **kwargs):
+        # calculate A^T * X
+        pass
+    
+    def ortho_project(self, data, **kwargs):
+        # calculate (I - A^T * A)X
+        return data - self.transpose(self.forward(data, **kwargs), **kwargs)
+
+    def project(self, data, measurement, **kwargs):
+        # calculate (I - A^T * A)Y - AX
+        return self.ortho_project(measurement, **kwargs) - self.forward(data, **kwargs)
+
+
+@register_operator(name='noise')
+class DenoiseOperator(LinearOperator):
+    def __init__(self, device):
+        self.device = device
+    
+    def forward(self, data):
+        return data
+
+    def transpose(self, data):
+        return data
+    
+    def ortho_project(self, data):
+        return data
+
+    def project(self, data):
+        return data
+
+
+@register_operator(name='super_resolution')
+class SuperResolutionOperator(LinearOperator):
+    def __init__(self, in_shape, scale_factor, device):
+        self.device = device
+        self.up_sample = partial(F.interpolate, scale_factor=scale_factor)
+        self.down_sample = Resizer(in_shape, 1/scale_factor).to(device)
+
+    def forward(self, data, **kwargs):
+        return self.down_sample(data)
+
+    def transpose(self, data, **kwargs):
+        return self.up_sample(data)
+
+    def project(self, data, measurement, **kwargs):
+        return data - self.transpose(self.forward(data)) + self.transpose(measurement)
+
+
+
+@register_operator(name='motion_blur')
+class MotionBlurOperator(LinearOperator):
+    def __init__(self, kernel_size, intensity, device):
+        self.device = device
+        self.kernel_size = kernel_size
+        self.conv = Blurkernel(blur_type='motion',
+                               kernel_size=kernel_size,
+                               std=intensity,
+                               device=device).to(device)  # should we keep this device term?
+
+        self.kernel = Kernel(size=(kernel_size, kernel_size), intensity=intensity)
+        kernel = torch.tensor(self.kernel.kernelMatrix, dtype=torch.float32)
+        self.conv.update_weights(kernel)
+    
+    def forward(self, data, **kwargs):
+        # A^T * A 
+        return self.conv(data)
+
+    def transpose(self, data, **kwargs):
+        return data
+
+    def get_kernel(self):
+        kernel = self.kernel.kernelMatrix.type(torch.float32).to(self.device)
+        return kernel.view(1, 1, self.kernel_size, self.kernel_size)
+
+
+@register_operator(name='colorization')
+class ColorizationOperator(LinearOperator):
+    def __init__(self, device):
+        self.device = device
+
+    def forward(self, data, **kwargs):
+        return (1/3) * torch.sum(data, dim=1, keepdim=True)
+
+    def transpose(self, data, **kwargs):
+        return data
+
+
+
+@register_operator(name='gaussian_blur')
+class GaussialBlurOperator(LinearOperator):
+    def __init__(self, kernel_size, intensity, device):
+        self.device = device
+        self.kernel_size = kernel_size
+        self.conv = Blurkernel(blur_type='gaussian',
+                               kernel_size=kernel_size,
+                               std=intensity,
+                               device=device).to(device)
+        self.kernel = self.conv.get_kernel()
+        self.conv.update_weights(self.kernel.type(torch.float32))
+
+    def forward(self, data, **kwargs):
+        return self.conv(data)
+
+    def transpose(self, data, **kwargs):
+        return data
+
+    def get_kernel(self):
+        return self.kernel.view(1, 1, self.kernel_size, self.kernel_size)
+
+    def project(self, data, measurement, **kwargs):
+        # calculate (I - A^T * A)Y - AX
+        return data - self.forward(data, **kwargs) + measurement
+
+@register_operator(name='inpainting')
+class InpaintingOperator(LinearOperator):
+    '''This operator get pre-defined mask and return masked image.'''
+    def __init__(self, device):
+        self.device = device
+
+    def set_mask(self, mask):
+        self.mask = mask
+
+    def forward(self, data, **kwargs):
+        try:
+            return data * self.mask.to(self.device)
+        except:
+            raise ValueError("Require mask")
+    
+    def transpose(self, data, **kwargs):
+        return data
+
+    def ortho_project(self, data, **kwargs):
+        return data - self.forward(data, **kwargs)
+
+    def project(self, data, measurement, **kwargs):
+        return data - self.forward(data, **kwargs) + measurement
+
+
+class NonLinearOperator(ABC):
+    @abstractmethod
+    def forward(self, data, **kwargs):
+        pass
+
+    def project(self, data, measurement, **kwargs):
+        return data + measurement - self.forward(data) 
+
+@register_operator(name='phase_retrieval')
+class PhaseRetrievalOperator(NonLinearOperator):
+    def __init__(self, oversample, device):
+        self.pad = int((oversample / 8.0) * 256)
+        self.device = device
+        
+    def forward(self, data, **kwargs):
+        padded = F.pad(data, (self.pad, self.pad, self.pad, self.pad))
+        amplitude = fft2_m(padded).abs()
+        return amplitude
+
+@register_operator(name='nonlinear_blur')
+class NonlinearBlurOperator(NonLinearOperator):
+    def __init__(self, opt_yml_path, device):
+        self.device = device
+        self.blur_model = self.prepare_nonlinear_blur_model(opt_yml_path)     
+         
+    def prepare_nonlinear_blur_model(self, opt_yml_path):
+        '''
+        Nonlinear deblur requires external codes (bkse).
+        '''
+        from bkse.models.kernel_encoding.kernel_wizard import KernelWizard
+
+        with open(opt_yml_path, "r") as f:
+            opt = yaml.safe_load(f)["KernelWizard"]
+            model_path = opt["pretrained"]
+        blur_model = KernelWizard(opt)
+        blur_model.eval()
+        blur_model.load_state_dict(torch.load(model_path)) 
+        blur_model = blur_model.to(self.device)
+        return blur_model
+    
+    def forward(self, data, **kwargs):
+        random_kernel = torch.randn(1, 512, 2, 2).to(self.device) * 1.2
+        data = (data + 1.0) / 2.0  #[-1, 1] -> [0, 1]
+        blurred = self.blur_model.adaptKernel(data, kernel=random_kernel)
+        blurred = (blurred * 2.0 - 1.0).clamp(-1, 1) #[0, 1] -> [-1, 1]
+        return blurred
+
+# =============
+# Noise classes
+# =============
+
+
+__NOISE__ = {}
+
+def register_noise(name: str):
+    def wrapper(cls):
+        if __NOISE__.get(name, None):
+            raise NameError(f"Name {name} is already defined!")
+        __NOISE__[name] = cls
+        return cls
+    return wrapper
+
+def get_noise(name: str, **kwargs):
+    if __NOISE__.get(name, None) is None:
+        raise NameError(f"Name {name} is not defined.")
+    noiser = __NOISE__[name](**kwargs)
+    noiser.__name__ = name
+    return noiser
+
+class Noise(ABC):
+    def __call__(self, data):
+        return self.forward(data)
+    
+    @abstractmethod
+    def forward(self, data):
+        pass
+
+@register_noise(name='clean')
+class Clean(Noise):
+    def forward(self, data):
+        return data
+
+@register_noise(name='gaussian')
+class GaussianNoise(Noise):
+    def __init__(self, sigma):
+        self.sigma = sigma
+    
+    def forward(self, data):
+        return data + torch.randn_like(data, device=data.device) * self.sigma * 2
+
+
+@register_noise(name='poisson')
+class PoissonNoise(Noise):
+    def __init__(self, rate):
+        self.rate = rate
+
+    def forward(self, data):
+        '''
+        Follow skimage.util.random_noise.
+        '''
+
+        # TODO: set one version of poisson
+       
+        # version 3 (stack-overflow)
+        import numpy as np
+        data = (data + 1.0) / 2.0
+        data = data.clamp(0, 1)
+        device = data.device
+        data = data.detach().cpu()
+        data = torch.from_numpy(np.random.poisson(data * 255.0 * self.rate) / 255.0 / self.rate)
+        data = data * 2.0 - 1.0
+        data = data.clamp(-1, 1)
+        return data.to(device)
+
+        # version 2 (skimage)
+        # if data.min() < 0:
+        #     low_clip = -1
+        # else:
+        #     low_clip = 0
+
+    
+        # # Determine unique values in iamge & calculate the next power of two
+        # vals = torch.Tensor([len(torch.unique(data))])
+        # vals = 2 ** torch.ceil(torch.log2(vals))
+        # vals = vals.to(data.device)
+
+        # if low_clip == -1:
+        #     old_max = data.max()
+        #     data = (data + 1.0) / (old_max + 1.0)
+
+        # data = torch.poisson(data * vals) / float(vals)
+
+        # if low_clip == -1:
+        #     data = data * (old_max + 1.0) - 1.0
+       
+        # return data.clamp(low_clip, 1.0)

guided_diffusion/nn.py

@@ -0,0 +1,170 @@
+"""
+Various utilities for neural networks.
+"""
+
+import math
+
+import torch as th
+import torch.nn as nn
+
+
+# PyTorch 1.7 has SiLU, but we support PyTorch 1.5.
+class SiLU(nn.Module):
+    def forward(self, x):
+        return x * th.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}")
+
+
+def update_ema(target_params, source_params, rate=0.99):
+    """
+    Update target parameters to be closer to those of source parameters using
+    an exponential moving average.
+
+    :param target_params: the target parameter sequence.
+    :param source_params: the source parameter sequence.
+    :param rate: the EMA rate (closer to 1 means slower).
+    """
+    for targ, src in zip(target_params, source_params):
+        targ.detach().mul_(rate).add_(src, alpha=1 - rate)
+
+
+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)
+
+
+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) / half
+    ).to(device=timesteps.device)
+    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 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(th.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:])
+        with th.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 th.enable_grad():
+            # 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 = th.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

guided_diffusion/posterior_mean_variance.py

@@ -0,0 +1,264 @@
+from abc import ABC, abstractmethod
+
+import numpy as np
+import torch
+
+from util.img_utils import dynamic_thresholding
+
+
+
+# ====================
+# Model Mean Processor
+# ====================
+
+__MODEL_MEAN_PROCESSOR__ = {}
+
+def register_mean_processor(name: str):
+    def wrapper(cls):
+        if __MODEL_MEAN_PROCESSOR__.get(name, None):
+            raise NameError(f"Name {name} is already registerd.")
+        __MODEL_MEAN_PROCESSOR__[name] = cls
+        return cls
+    return wrapper
+
+def get_mean_processor(name: str, **kwargs):
+    if __MODEL_MEAN_PROCESSOR__.get(name, None) is None:
+        raise NameError(f"Name {name} is not defined.") 
+    return __MODEL_MEAN_PROCESSOR__[name](**kwargs)
+
+class MeanProcessor(ABC):
+    """Predict x_start and calculate mean value"""
+    @abstractmethod
+    def __init__(self, betas, dynamic_threshold, clip_denoised):
+        self.dynamic_threshold = dynamic_threshold
+        self.clip_denoised = clip_denoised
+
+    @abstractmethod
+    def get_mean_and_xstart(self, x, t, model_output):
+        pass
+
+    def process_xstart(self, x):
+        if self.dynamic_threshold:
+            x = dynamic_thresholding(x, s=0.95)
+        if self.clip_denoised:
+            x = x.clamp(-1, 1)
+        return x
+
+@register_mean_processor(name='previous_x')
+class PreviousXMeanProcessor(MeanProcessor):
+    def __init__(self, betas, dynamic_threshold, clip_denoised):
+        super().__init__(betas, dynamic_threshold, clip_denoised)
+        alphas = 1.0 - betas
+        alphas_cumprod = np.cumprod(alphas, axis=0)
+        alphas_cumprod_prev = np.append(1.0, alphas_cumprod[:-1])
+
+        self.posterior_mean_coef1 = betas * np.sqrt(alphas_cumprod_prev) / (1.0-alphas_cumprod)
+        self.posterior_mean_coef2 = (1.0 - alphas_cumprod_prev) * np.sqrt(alphas) / (1.0 - alphas_cumprod)
+    
+    def predict_xstart(self, x_t, t, x_prev):
+        coef1 = extract_and_expand(1.0/self.posterior_mean_coef1, t, x_t)
+        coef2 = extract_and_expand(self.posterior_mean_coef2/self.posterior_mean_coef1, t, x_t)
+        return coef1 * x_prev - coef2 * x_t
+    
+    def get_mean_and_xstart(self, x, t, model_output):
+        mean = model_output
+        pred_xstart = self.process_xstart(self.predict_xstart(x, t, model_output))
+        return mean, pred_xstart
+
+@register_mean_processor(name='start_x')
+class StartXMeanProcessor(MeanProcessor):
+    def __init__(self, betas, dynamic_threshold, clip_denoised):
+        super().__init__(betas, dynamic_threshold, clip_denoised)
+        alphas = 1.0 - betas
+        alphas_cumprod = np.cumprod(alphas, axis=0)
+        alphas_cumprod_prev = np.append(1.0, alphas_cumprod[:-1])
+
+        self.posterior_mean_coef1 = betas * np.sqrt(alphas_cumprod_prev) / (1.0-alphas_cumprod)
+        self.posterior_mean_coef2 = (1.0 - alphas_cumprod_prev) * np.sqrt(alphas) / (1.0 - alphas_cumprod)
+
+    def q_posterior_mean(self, x_start, x_t, t):
+        """
+        Compute the mean of the diffusion posteriro:
+            q(x_{t-1} | x_t, x_0)
+        """
+        assert x_start.shape == x_t.shape
+        coef1 = extract_and_expand(self.posterior_mean_coef1, t, x_start)
+        coef2 = extract_and_expand(self.posterior_mean_coef2, t, x_t)
+
+        return coef1 * x_start + coef2 * x_t
+
+    def get_mean_and_xstart(self, x, t, model_output):
+        pred_xstart = self.process_xstart(model_output)
+        mean = self.q_posterior_mean(x_start=pred_xstart, x_t=x, t=t)
+
+        return mean, pred_xstart
+
+@register_mean_processor(name='epsilon')
+class EpsilonXMeanProcessor(MeanProcessor):
+    def __init__(self, betas, dynamic_threshold, clip_denoised):
+        super().__init__(betas, dynamic_threshold, clip_denoised)
+        alphas = 1.0 - betas
+        alphas_cumprod = np.cumprod(alphas, axis=0)
+        alphas_cumprod_prev = np.append(1.0, alphas_cumprod[:-1])
+        
+        self.sqrt_recip_alphas_cumprod = np.sqrt(1.0 / alphas_cumprod)
+        self.sqrt_recipm1_alphas_cumprod = np.sqrt(1.0 / alphas_cumprod - 1)
+        self.posterior_mean_coef1 = betas * np.sqrt(alphas_cumprod_prev) / (1.0-alphas_cumprod)
+        self.posterior_mean_coef2 = (1.0 - alphas_cumprod_prev) * np.sqrt(alphas) / (1.0 - alphas_cumprod)
+
+
+    def q_posterior_mean(self, x_start, x_t, t):
+        """
+        Compute the mean of the diffusion posteriro:
+            q(x_{t-1} | x_t, x_0)
+        """
+        assert x_start.shape == x_t.shape
+        coef1 = extract_and_expand(self.posterior_mean_coef1, t, x_start)
+        coef2 = extract_and_expand(self.posterior_mean_coef2, t, x_t)
+        return coef1 * x_start + coef2 * x_t
+    
+    def predict_xstart(self, x_t, t, eps):
+        coef1 = extract_and_expand(self.sqrt_recip_alphas_cumprod, t, x_t)
+        coef2 = extract_and_expand(self.sqrt_recipm1_alphas_cumprod, t, eps)
+        return coef1 * x_t - coef2 * eps
+
+    def get_mean_and_xstart(self, x, t, model_output):
+        pred_xstart = self.process_xstart(self.predict_xstart(x, t, model_output))
+        mean = self.q_posterior_mean(pred_xstart, x, t)
+
+        return mean, pred_xstart
+
+# =========================
+# Model Variance Processor
+# =========================
+
+__MODEL_VAR_PROCESSOR__ = {}
+
+def register_var_processor(name: str):
+    def wrapper(cls):
+        if __MODEL_VAR_PROCESSOR__.get(name, None):
+            raise NameError(f"Name {name} is already registerd.")
+        __MODEL_VAR_PROCESSOR__[name] = cls
+        return cls
+    return wrapper
+
+def get_var_processor(name: str, **kwargs):
+    if __MODEL_VAR_PROCESSOR__.get(name, None) is None:
+        raise NameError(f"Name {name} is not defined.") 
+    return __MODEL_VAR_PROCESSOR__[name](**kwargs)
+
+class VarianceProcessor(ABC):
+    @abstractmethod
+    def __init__(self, betas):
+        pass
+
+    @abstractmethod
+    def get_variance(self, x, t):
+        pass
+
+@register_var_processor(name='fixed_small')
+class FixedSmallVarianceProcessor(VarianceProcessor):
+    def __init__(self, betas):
+        alphas = 1.0 - betas
+        alphas_cumprod = np.cumprod(alphas, axis=0)
+        alphas_cumprod_prev = np.append(1.0, alphas_cumprod[:-1])
+        # calculations for posterior q(x_{t-1} | x_t, x_0)
+        self.posterior_variance = (
+            betas * (1.0 - alphas_cumprod_prev) / (1.0 - alphas_cumprod)
+        )
+
+    def get_variance(self, x, t):
+        model_variance = self.posterior_variance
+        model_log_variance = np.log(model_variance)
+
+        model_variance = extract_and_expand(model_variance, t, x)
+        model_log_variance = extract_and_expand(model_log_variance, t, x)
+
+        return model_variance, model_log_variance
+
+@register_var_processor(name='fixed_large')
+class FixedLargeVarianceProcessor(VarianceProcessor):
+    def __init__(self, betas):
+        self.betas = betas
+
+        alphas = 1.0 - betas
+        alphas_cumprod = np.cumprod(alphas, axis=0)
+        alphas_cumprod_prev = np.append(1.0, alphas_cumprod[:-1])
+        # calculations for posterior q(x_{t-1} | x_t, x_0)
+        self.posterior_variance = (
+            betas * (1.0 - alphas_cumprod_prev) / (1.0 - alphas_cumprod)
+        )
+
+    def get_variance(self, x, t):
+        model_variance = np.append(self.posterior_variance[1], self.betas[1:])
+        model_log_variance = np.log(model_variance)
+    
+        model_variance = extract_and_expand(model_variance, t, x)
+        model_log_variance = extract_and_expand(model_log_variance, t, x)
+
+        return model_variance, model_log_variance
+
+@register_var_processor(name='learned')
+class LearnedVarianceProcessor(VarianceProcessor):
+    def __init__(self, betas):
+        pass
+
+    def get_variance(self, x, t):
+        model_log_variance = x
+        model_variance = torch.exp(model_log_variance)
+        return model_variance, model_log_variance
+
+@register_var_processor(name='learned_range')
+class LearnedRangeVarianceProcessor(VarianceProcessor):
+    def __init__(self, betas):
+        self.betas = betas
+
+        alphas = 1.0 - betas
+        alphas_cumprod = np.cumprod(alphas, axis=0)
+        alphas_cumprod_prev = np.append(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)
+        )
+        # log calculation clipped because the posterior variance is 0 at the
+        # beginning of the diffusion chain.
+        self.posterior_log_variance_clipped = np.log(
+            np.append(posterior_variance[1], posterior_variance[1:])
+        )
+
+    def get_variance(self, x, t):
+        model_var_values = x
+        min_log = self.posterior_log_variance_clipped
+        max_log = np.log(self.betas)
+
+        min_log = extract_and_expand(min_log, t, x)
+        max_log = extract_and_expand(max_log, t, x)
+
+        # The model_var_values is [-1, 1] for [min_var, max_var]
+        frac = (model_var_values + 1.0) / 2.0
+        model_log_variance = frac * max_log + (1-frac) * min_log
+        model_variance = torch.exp(model_log_variance)
+        return model_variance, model_log_variance
+
+# ================
+# Helper function
+# ================
+
+def extract_and_expand(array, time, target):
+    array = torch.from_numpy(array).to(target.device)[time].float()
+    while array.ndim < target.ndim:
+        array = array.unsqueeze(-1)
+    return array.expand_as(target)
+
+
+def expand_as(array, target):
+    if isinstance(array, np.ndarray):
+        array = torch.from_numpy(array)
+    elif isinstance(array, np.float):
+        array = torch.tensor([array])
+   
+    while array.ndim < target.ndim:
+        array = array.unsqueeze(-1)
+
+    return array.expand_as(target).to(target.device)

guided_diffusion/swinir.py

@@ -0,0 +1,904 @@
+# -----------------------------------------------------------------------------------
+# SwinIR: Image Restoration Using Swin Transformer, https://arxiv.org/abs/2108.10257
+# Originally Written by Ze Liu, Modified by Jingyun Liang.
+# -----------------------------------------------------------------------------------
+# Borrowed from DifFace (https://github.com/zsyOAOA/DifFace/blob/master/models/swinir.py)
+
+import math
+from typing import Set
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import torch.utils.checkpoint as checkpoint
+from timm.models.layers import DropPath, to_2tuple, trunc_normal_
+
+
+class Mlp(nn.Module):
+    def __init__(self, in_features, hidden_features=None, out_features=None, act_layer=nn.GELU, drop=0.):
+        super().__init__()
+        out_features = out_features or in_features
+        hidden_features = hidden_features or in_features
+        self.fc1 = nn.Linear(in_features, hidden_features)
+        self.act = act_layer()
+        self.fc2 = nn.Linear(hidden_features, out_features)
+        self.drop = nn.Dropout(drop)
+
+    def forward(self, x):
+        x = self.fc1(x)
+        x = self.act(x)
+        x = self.drop(x)
+        x = self.fc2(x)
+        x = self.drop(x)
+        return x
+
+
+def window_partition(x, window_size):
+    """
+    Args:
+        x: (B, H, W, C)
+        window_size (int): window size
+
+    Returns:
+        windows: (num_windows*B, window_size, window_size, C)
+    """
+    B, H, W, C = x.shape
+    x = x.view(B, H // window_size, window_size, W // window_size, window_size, C)
+    windows = x.permute(0, 1, 3, 2, 4, 5).contiguous().view(-1, window_size, window_size, C)
+    return windows
+
+
+def window_reverse(windows, window_size, H, W):
+    """
+    Args:
+        windows: (num_windows*B, window_size, window_size, C)
+        window_size (int): Window size
+        H (int): Height of image
+        W (int): Width of image
+
+    Returns:
+        x: (B, H, W, C)
+    """
+    B = int(windows.shape[0] / (H * W / window_size / window_size))
+    x = windows.view(B, H // window_size, W // window_size, window_size, window_size, -1)
+    x = x.permute(0, 1, 3, 2, 4, 5).contiguous().view(B, H, W, -1)
+    return x
+
+
+class WindowAttention(nn.Module):
+    r""" Window based multi-head self attention (W-MSA) module with relative position bias.
+    It supports both of shifted and non-shifted window.
+
+    Args:
+        dim (int): Number of input channels.
+        window_size (tuple[int]): The height and width of the window.
+        num_heads (int): Number of attention heads.
+        qkv_bias (bool, optional):  If True, add a learnable bias to query, key, value. Default: True
+        qk_scale (float | None, optional): Override default qk scale of head_dim ** -0.5 if set
+        attn_drop (float, optional): Dropout ratio of attention weight. Default: 0.0
+        proj_drop (float, optional): Dropout ratio of output. Default: 0.0
+    """
+
+    def __init__(self, dim, window_size, num_heads, qkv_bias=True, qk_scale=None, attn_drop=0., proj_drop=0.):
+
+        super().__init__()
+        self.dim = dim
+        self.window_size = window_size  # Wh, Ww
+        self.num_heads = num_heads
+        head_dim = dim // num_heads
+        self.scale = qk_scale or head_dim ** -0.5
+
+        # define a parameter table of relative position bias
+        self.relative_position_bias_table = nn.Parameter(
+            torch.zeros((2 * window_size[0] - 1) * (2 * window_size[1] - 1), num_heads))  # 2*Wh-1 * 2*Ww-1, nH
+
+        # get pair-wise relative position index for each token inside the window
+        coords_h = torch.arange(self.window_size[0])
+        coords_w = torch.arange(self.window_size[1])
+        # coords = torch.stack(torch.meshgrid([coords_h, coords_w]))  # 2, Wh, Ww
+        # Fix: Pass indexing="ij" to avoid warning
+        coords = torch.stack(torch.meshgrid([coords_h, coords_w], indexing="ij"))  # 2, Wh, Ww
+        coords_flatten = torch.flatten(coords, 1)  # 2, Wh*Ww
+        relative_coords = coords_flatten[:, :, None] - coords_flatten[:, None, :]  # 2, Wh*Ww, Wh*Ww
+        relative_coords = relative_coords.permute(1, 2, 0).contiguous()  # Wh*Ww, Wh*Ww, 2
+        relative_coords[:, :, 0] += self.window_size[0] - 1  # shift to start from 0
+        relative_coords[:, :, 1] += self.window_size[1] - 1
+        relative_coords[:, :, 0] *= 2 * self.window_size[1] - 1
+        relative_position_index = relative_coords.sum(-1)  # Wh*Ww, Wh*Ww
+        self.register_buffer("relative_position_index", relative_position_index)
+
+        self.qkv = nn.Linear(dim, dim * 3, bias=qkv_bias)
+        self.attn_drop = nn.Dropout(attn_drop)
+        self.proj = nn.Linear(dim, dim)
+
+        self.proj_drop = nn.Dropout(proj_drop)
+
+        trunc_normal_(self.relative_position_bias_table, std=.02)
+        self.softmax = nn.Softmax(dim=-1)
+
+    def forward(self, x, mask=None):
+        """
+        Args:
+            x: input features with shape of (num_windows*B, N, C)
+            mask: (0/-inf) mask with shape of (num_windows, Wh*Ww, Wh*Ww) or None
+        """
+        B_, N, C = x.shape
+        qkv = self.qkv(x).reshape(B_, N, 3, self.num_heads, C // self.num_heads).permute(2, 0, 3, 1, 4)
+        q, k, v = qkv[0], qkv[1], qkv[2]  # make torchscript happy (cannot use tensor as tuple)
+
+        q = q * self.scale
+        attn = (q @ k.transpose(-2, -1))
+
+        relative_position_bias = self.relative_position_bias_table[self.relative_position_index.view(-1)].view(
+            self.window_size[0] * self.window_size[1], self.window_size[0] * self.window_size[1], -1)  # Wh*Ww,Wh*Ww,nH
+        relative_position_bias = relative_position_bias.permute(2, 0, 1).contiguous()  # nH, Wh*Ww, Wh*Ww
+        attn = attn + relative_position_bias.unsqueeze(0)
+
+        if mask is not None:
+            nW = mask.shape[0]
+            attn = attn.view(B_ // nW, nW, self.num_heads, N, N) + mask.unsqueeze(1).unsqueeze(0)
+            attn = attn.view(-1, self.num_heads, N, N)
+            attn = self.softmax(attn)
+        else:
+            attn = self.softmax(attn)
+
+        attn = self.attn_drop(attn)
+
+        x = (attn @ v).transpose(1, 2).reshape(B_, N, C)
+        x = self.proj(x)
+        x = self.proj_drop(x)
+        return x
+
+    def extra_repr(self) -> str:
+        return f'dim={self.dim}, window_size={self.window_size}, num_heads={self.num_heads}'
+
+    def flops(self, N):
+        # calculate flops for 1 window with token length of N
+        flops = 0
+        # qkv = self.qkv(x)
+        flops += N * self.dim * 3 * self.dim
+        # attn = (q @ k.transpose(-2, -1))
+        flops += self.num_heads * N * (self.dim // self.num_heads) * N
+        #  x = (attn @ v)
+        flops += self.num_heads * N * N * (self.dim // self.num_heads)
+        # x = self.proj(x)
+        flops += N * self.dim * self.dim
+        return flops
+
+
+class SwinTransformerBlock(nn.Module):
+    r""" Swin Transformer Block.
+
+    Args:
+        dim (int): Number of input channels.
+        input_resolution (tuple[int]): Input resulotion.
+        num_heads (int): Number of attention heads.
+        window_size (int): Window size.
+        shift_size (int): Shift size for SW-MSA.
+        mlp_ratio (float): Ratio of mlp hidden dim to embedding dim.
+        qkv_bias (bool, optional): If True, add a learnable bias to query, key, value. Default: True
+        qk_scale (float | None, optional): Override default qk scale of head_dim ** -0.5 if set.
+        drop (float, optional): Dropout rate. Default: 0.0
+        attn_drop (float, optional): Attention dropout rate. Default: 0.0
+        drop_path (float, optional): Stochastic depth rate. Default: 0.0
+        act_layer (nn.Module, optional): Activation layer. Default: nn.GELU
+        norm_layer (nn.Module, optional): Normalization layer.  Default: nn.LayerNorm
+    """
+
+    def __init__(self, dim, input_resolution, num_heads, window_size=7, shift_size=0,
+                 mlp_ratio=4., qkv_bias=True, qk_scale=None, drop=0., attn_drop=0., drop_path=0.,
+                 act_layer=nn.GELU, norm_layer=nn.LayerNorm):
+        super().__init__()
+        self.dim = dim
+        self.input_resolution = input_resolution
+        self.num_heads = num_heads
+        self.window_size = window_size
+        self.shift_size = shift_size
+        self.mlp_ratio = mlp_ratio
+        if min(self.input_resolution) <= self.window_size:
+            # if window size is larger than input resolution, we don't partition windows
+            self.shift_size = 0
+            self.window_size = min(self.input_resolution)
+        assert 0 <= self.shift_size < self.window_size, "shift_size must in 0-window_size"
+
+        self.norm1 = norm_layer(dim)
+        self.attn = WindowAttention(
+            dim, window_size=to_2tuple(self.window_size), num_heads=num_heads,
+            qkv_bias=qkv_bias, qk_scale=qk_scale, attn_drop=attn_drop, proj_drop=drop)
+
+        self.drop_path = DropPath(drop_path) if drop_path > 0. else nn.Identity()
+        self.norm2 = norm_layer(dim)
+        mlp_hidden_dim = int(dim * mlp_ratio)
+        self.mlp = Mlp(in_features=dim, hidden_features=mlp_hidden_dim, act_layer=act_layer, drop=drop)
+
+        if self.shift_size > 0:
+            attn_mask = self.calculate_mask(self.input_resolution)
+        else:
+            attn_mask = None
+
+        self.register_buffer("attn_mask", attn_mask)
+
+    def calculate_mask(self, x_size):
+        # calculate attention mask for SW-MSA
+        H, W = x_size
+        img_mask = torch.zeros((1, H, W, 1))  # 1 H W 1
+        h_slices = (slice(0, -self.window_size),
+                    slice(-self.window_size, -self.shift_size),
+                    slice(-self.shift_size, None))
+        w_slices = (slice(0, -self.window_size),
+                    slice(-self.window_size, -self.shift_size),
+                    slice(-self.shift_size, None))
+        cnt = 0
+        for h in h_slices:
+            for w in w_slices:
+                img_mask[:, h, w, :] = cnt
+                cnt += 1
+
+        mask_windows = window_partition(img_mask, self.window_size)  # nW, window_size, window_size, 1
+        mask_windows = mask_windows.view(-1, self.window_size * self.window_size)
+        attn_mask = mask_windows.unsqueeze(1) - mask_windows.unsqueeze(2)
+        attn_mask = attn_mask.masked_fill(attn_mask != 0, float(-100.0)).masked_fill(attn_mask == 0, float(0.0))
+
+        return attn_mask
+
+    def forward(self, x, x_size):
+        H, W = x_size
+        B, L, C = x.shape
+        # assert L == H * W, "input feature has wrong size"
+
+        shortcut = x
+        x = self.norm1(x)
+        x = x.view(B, H, W, C)
+
+        # cyclic shift
+        if self.shift_size > 0:
+            shifted_x = torch.roll(x, shifts=(-self.shift_size, -self.shift_size), dims=(1, 2))
+        else:
+            shifted_x = x
+
+        # partition windows
+        x_windows = window_partition(shifted_x, self.window_size)  # nW*B, window_size, window_size, C
+        x_windows = x_windows.view(-1, self.window_size * self.window_size, C)  # nW*B, window_size*window_size, C
+
+        # W-MSA/SW-MSA (to be compatible for testing on images whose shapes are the multiple of window size
+        if self.input_resolution == x_size:
+            attn_windows = self.attn(x_windows, mask=self.attn_mask)  # nW*B, window_size*window_size, C
+        else:
+            attn_windows = self.attn(x_windows, mask=self.calculate_mask(x_size).to(x.device))
+
+        # merge windows
+        attn_windows = attn_windows.view(-1, self.window_size, self.window_size, C)
+        shifted_x = window_reverse(attn_windows, self.window_size, H, W)  # B H' W' C
+
+        # reverse cyclic shift
+        if self.shift_size > 0:
+            x = torch.roll(shifted_x, shifts=(self.shift_size, self.shift_size), dims=(1, 2))
+        else:
+            x = shifted_x
+        x = x.view(B, H * W, C)
+
+        # FFN
+        x = shortcut + self.drop_path(x)
+        x = x + self.drop_path(self.mlp(self.norm2(x)))
+
+        return x
+
+    def extra_repr(self) -> str:
+        return f"dim={self.dim}, input_resolution={self.input_resolution}, num_heads={self.num_heads}, " \
+               f"window_size={self.window_size}, shift_size={self.shift_size}, mlp_ratio={self.mlp_ratio}"
+
+    def flops(self):
+        flops = 0
+        H, W = self.input_resolution
+        # norm1
+        flops += self.dim * H * W
+        # W-MSA/SW-MSA
+        nW = H * W / self.window_size / self.window_size
+        flops += nW * self.attn.flops(self.window_size * self.window_size)
+        # mlp
+        flops += 2 * H * W * self.dim * self.dim * self.mlp_ratio
+        # norm2
+        flops += self.dim * H * W
+        return flops
+
+
+class PatchMerging(nn.Module):
+    r""" Patch Merging Layer.
+
+    Args:
+        input_resolution (tuple[int]): Resolution of input feature.
+        dim (int): Number of input channels.
+        norm_layer (nn.Module, optional): Normalization layer.  Default: nn.LayerNorm
+    """
+
+    def __init__(self, input_resolution, dim, norm_layer=nn.LayerNorm):
+        super().__init__()
+        self.input_resolution = input_resolution
+        self.dim = dim
+        self.reduction = nn.Linear(4 * dim, 2 * dim, bias=False)
+        self.norm = norm_layer(4 * dim)
+
+    def forward(self, x):
+        """
+        x: B, H*W, C
+        """
+        H, W = self.input_resolution
+        B, L, C = x.shape
+        assert L == H * W, "input feature has wrong size"
+        assert H % 2 == 0 and W % 2 == 0, f"x size ({H}*{W}) are not even."
+
+        x = x.view(B, H, W, C)
+
+        x0 = x[:, 0::2, 0::2, :]  # B H/2 W/2 C
+        x1 = x[:, 1::2, 0::2, :]  # B H/2 W/2 C
+        x2 = x[:, 0::2, 1::2, :]  # B H/2 W/2 C
+        x3 = x[:, 1::2, 1::2, :]  # B H/2 W/2 C
+        x = torch.cat([x0, x1, x2, x3], -1)  # B H/2 W/2 4*C
+        x = x.view(B, -1, 4 * C)  # B H/2*W/2 4*C
+
+        x = self.norm(x)
+        x = self.reduction(x)
+
+        return x
+
+    def extra_repr(self) -> str:
+        return f"input_resolution={self.input_resolution}, dim={self.dim}"
+
+    def flops(self):
+        H, W = self.input_resolution
+        flops = H * W * self.dim
+        flops += (H // 2) * (W // 2) * 4 * self.dim * 2 * self.dim
+        return flops
+
+
+class BasicLayer(nn.Module):
+    """ A basic Swin Transformer layer for one stage.
+
+    Args:
+        dim (int): Number of input channels.
+        input_resolution (tuple[int]): Input resolution.
+        depth (int): Number of blocks.
+        num_heads (int): Number of attention heads.
+        window_size (int): Local window size.
+        mlp_ratio (float): Ratio of mlp hidden dim to embedding dim.
+        qkv_bias (bool, optional): If True, add a learnable bias to query, key, value. Default: True
+        qk_scale (float | None, optional): Override default qk scale of head_dim ** -0.5 if set.
+        drop (float, optional): Dropout rate. Default: 0.0
+        attn_drop (float, optional): Attention dropout rate. Default: 0.0
+        drop_path (float | tuple[float], optional): Stochastic depth rate. Default: 0.0
+        norm_layer (nn.Module, optional): Normalization layer. Default: nn.LayerNorm
+        downsample (nn.Module | None, optional): Downsample layer at the end of the layer. Default: None
+        use_checkpoint (bool): Whether to use checkpointing to save memory. Default: False.
+    """
+
+    def __init__(self, dim, input_resolution, depth, num_heads, window_size,
+                 mlp_ratio=4., qkv_bias=True, qk_scale=None, drop=0., attn_drop=0.,
+                 drop_path=0., norm_layer=nn.LayerNorm, downsample=None, use_checkpoint=False):
+
+        super().__init__()
+        self.dim = dim
+        self.input_resolution = input_resolution
+        self.depth = depth
+        self.use_checkpoint = use_checkpoint
+
+        # build blocks
+        self.blocks = nn.ModuleList([
+            SwinTransformerBlock(dim=dim, input_resolution=input_resolution,
+                                 num_heads=num_heads, window_size=window_size,
+                                 shift_size=0 if (i % 2 == 0) else window_size // 2,
+                                 mlp_ratio=mlp_ratio,
+                                 qkv_bias=qkv_bias, qk_scale=qk_scale,
+                                 drop=drop, attn_drop=attn_drop,
+                                 drop_path=drop_path[i] if isinstance(drop_path, list) else drop_path,
+                                 norm_layer=norm_layer)
+            for i in range(depth)])
+
+        # patch merging layer
+        if downsample is not None:
+            self.downsample = downsample(input_resolution, dim=dim, norm_layer=norm_layer)
+        else:
+            self.downsample = None
+
+    def forward(self, x, x_size):
+        for blk in self.blocks:
+            if self.use_checkpoint:
+                x = checkpoint.checkpoint(blk, x, x_size)
+            else:
+                x = blk(x, x_size)
+        if self.downsample is not None:
+            x = self.downsample(x)
+        return x
+
+    def extra_repr(self) -> str:
+        return f"dim={self.dim}, input_resolution={self.input_resolution}, depth={self.depth}"
+
+    def flops(self):
+        flops = 0
+        for blk in self.blocks:
+            flops += blk.flops()
+        if self.downsample is not None:
+            flops += self.downsample.flops()
+        return flops
+
+
+class RSTB(nn.Module):
+    """Residual Swin Transformer Block (RSTB).
+
+    Args:
+        dim (int): Number of input channels.
+        input_resolution (tuple[int]): Input resolution.
+        depth (int): Number of blocks.
+        num_heads (int): Number of attention heads.
+        window_size (int): Local window size.
+        mlp_ratio (float): Ratio of mlp hidden dim to embedding dim.
+        qkv_bias (bool, optional): If True, add a learnable bias to query, key, value. Default: True
+        qk_scale (float | None, optional): Override default qk scale of head_dim ** -0.5 if set.
+        drop (float, optional): Dropout rate. Default: 0.0
+        attn_drop (float, optional): Attention dropout rate. Default: 0.0
+        drop_path (float | tuple[float], optional): Stochastic depth rate. Default: 0.0
+        norm_layer (nn.Module, optional): Normalization layer. Default: nn.LayerNorm
+        downsample (nn.Module | None, optional): Downsample layer at the end of the layer. Default: None
+        use_checkpoint (bool): Whether to use checkpointing to save memory. Default: False.
+        img_size: Input image size.
+        patch_size: Patch size.
+        resi_connection: The convolutional block before residual connection.
+    """
+
+    def __init__(self, dim, input_resolution, depth, num_heads, window_size,
+                 mlp_ratio=4., qkv_bias=True, qk_scale=None, drop=0., attn_drop=0.,
+                 drop_path=0., norm_layer=nn.LayerNorm, downsample=None, use_checkpoint=False,
+                 img_size=224, patch_size=4, resi_connection='1conv'):
+        super(RSTB, self).__init__()
+
+        self.dim = dim
+        self.input_resolution = input_resolution
+
+        self.residual_group = BasicLayer(dim=dim,
+                                         input_resolution=input_resolution,
+                                         depth=depth,
+                                         num_heads=num_heads,
+                                         window_size=window_size,
+                                         mlp_ratio=mlp_ratio,
+                                         qkv_bias=qkv_bias, qk_scale=qk_scale,
+                                         drop=drop, attn_drop=attn_drop,
+                                         drop_path=drop_path,
+                                         norm_layer=norm_layer,
+                                         downsample=downsample,
+                                         use_checkpoint=use_checkpoint)
+
+        if resi_connection == '1conv':
+            self.conv = nn.Conv2d(dim, dim, 3, 1, 1)
+        elif resi_connection == '3conv':
+            # to save parameters and memory
+            self.conv = nn.Sequential(nn.Conv2d(dim, dim // 4, 3, 1, 1), nn.LeakyReLU(negative_slope=0.2, inplace=True),
+                                      nn.Conv2d(dim // 4, dim // 4, 1, 1, 0),
+                                      nn.LeakyReLU(negative_slope=0.2, inplace=True),
+                                      nn.Conv2d(dim // 4, dim, 3, 1, 1))
+
+        self.patch_embed = PatchEmbed(
+            img_size=img_size, patch_size=patch_size, in_chans=0, embed_dim=dim,
+            norm_layer=None)
+
+        self.patch_unembed = PatchUnEmbed(
+            img_size=img_size, patch_size=patch_size, in_chans=0, embed_dim=dim,
+            norm_layer=None)
+
+    def forward(self, x, x_size):
+        return self.patch_embed(self.conv(self.patch_unembed(self.residual_group(x, x_size), x_size))) + x
+
+    def flops(self):
+        flops = 0
+        flops += self.residual_group.flops()
+        H, W = self.input_resolution
+        flops += H * W * self.dim * self.dim * 9
+        flops += self.patch_embed.flops()
+        flops += self.patch_unembed.flops()
+
+        return flops
+
+
+class PatchEmbed(nn.Module):
+    r""" Image to Patch Embedding
+
+    Args:
+        img_size (int): Image size.  Default: 224.
+        patch_size (int): Patch token size. Default: 4.
+        in_chans (int): Number of input image channels. Default: 3.
+        embed_dim (int): Number of linear projection output channels. Default: 96.
+        norm_layer (nn.Module, optional): Normalization layer. Default: None
+    """
+
+    def __init__(self, img_size=224, patch_size=4, in_chans=3, embed_dim=96, norm_layer=None):
+        super().__init__()
+        img_size = to_2tuple(img_size)
+        patch_size = to_2tuple(patch_size)
+        patches_resolution = [img_size[0] // patch_size[0], img_size[1] // patch_size[1]]
+        self.img_size = img_size
+        self.patch_size = patch_size
+        self.patches_resolution = patches_resolution
+        self.num_patches = patches_resolution[0] * patches_resolution[1]
+
+        self.in_chans = in_chans
+        self.embed_dim = embed_dim
+
+        if norm_layer is not None:
+            self.norm = norm_layer(embed_dim)
+        else:
+            self.norm = None
+
+    def forward(self, x):
+        x = x.flatten(2).transpose(1, 2)  # B Ph*Pw C
+        if self.norm is not None:
+            x = self.norm(x)
+        return x
+
+    def flops(self):
+        flops = 0
+        H, W = self.img_size
+        if self.norm is not None:
+            flops += H * W * self.embed_dim
+        return flops
+
+
+class PatchUnEmbed(nn.Module):
+    r""" Image to Patch Unembedding
+
+    Args:
+        img_size (int): Image size.  Default: 224.
+        patch_size (int): Patch token size. Default: 4.
+        in_chans (int): Number of input image channels. Default: 3.
+        embed_dim (int): Number of linear projection output channels. Default: 96.
+        norm_layer (nn.Module, optional): Normalization layer. Default: None
+    """
+
+    def __init__(self, img_size=224, patch_size=4, in_chans=3, embed_dim=96, norm_layer=None):
+        super().__init__()
+        img_size = to_2tuple(img_size)
+        patch_size = to_2tuple(patch_size)
+        patches_resolution = [img_size[0] // patch_size[0], img_size[1] // patch_size[1]]
+        self.img_size = img_size
+        self.patch_size = patch_size
+        self.patches_resolution = patches_resolution
+        self.num_patches = patches_resolution[0] * patches_resolution[1]
+
+        self.in_chans = in_chans
+        self.embed_dim = embed_dim
+
+    def forward(self, x, x_size):
+        B, HW, C = x.shape
+        x = x.transpose(1, 2).view(B, self.embed_dim, x_size[0], x_size[1])  # B Ph*Pw C
+        return x
+
+    def flops(self):
+        flops = 0
+        return flops
+
+
+class Upsample(nn.Sequential):
+    """Upsample module.
+
+    Args:
+        scale (int): Scale factor. Supported scales: 2^n and 3.
+        num_feat (int): Channel number of intermediate features.
+    """
+
+    def __init__(self, scale, num_feat):
+        m = []
+        if (scale & (scale - 1)) == 0:  # scale = 2^n
+            for _ in range(int(math.log(scale, 2))):
+                m.append(nn.Conv2d(num_feat, 4 * num_feat, 3, 1, 1))
+                m.append(nn.PixelShuffle(2))
+        elif scale == 3:
+            m.append(nn.Conv2d(num_feat, 9 * num_feat, 3, 1, 1))
+            m.append(nn.PixelShuffle(3))
+        else:
+            raise ValueError(f'scale {scale} is not supported. ' 'Supported scales: 2^n and 3.')
+        super(Upsample, self).__init__(*m)
+
+
+class UpsampleOneStep(nn.Sequential):
+    """UpsampleOneStep module (the difference with Upsample is that it always only has 1conv + 1pixelshuffle)
+       Used in lightweight SR to save parameters.
+
+    Args:
+        scale (int): Scale factor. Supported scales: 2^n and 3.
+        num_feat (int): Channel number of intermediate features.
+
+    """
+
+    def __init__(self, scale, num_feat, num_out_ch, input_resolution=None):
+        self.num_feat = num_feat
+        self.input_resolution = input_resolution
+        m = []
+        m.append(nn.Conv2d(num_feat, (scale ** 2) * num_out_ch, 3, 1, 1))
+        m.append(nn.PixelShuffle(scale))
+        super(UpsampleOneStep, self).__init__(*m)
+
+    def flops(self):
+        H, W = self.input_resolution
+        flops = H * W * self.num_feat * 3 * 9
+        return flops
+
+
+class SwinIR(nn.Module):
+    r""" SwinIR
+        A PyTorch impl of : `SwinIR: Image Restoration Using Swin Transformer`, based on Swin Transformer.
+
+    Args:
+        img_size (int | tuple(int)): Input image size. Default 64
+        patch_size (int | tuple(int)): Patch size. Default: 1
+        in_chans (int): Number of input image channels. Default: 3
+        embed_dim (int): Patch embedding dimension. Default: 96
+        depths (tuple(int)): Depth of each Swin Transformer layer.
+        num_heads (tuple(int)): Number of attention heads in different layers.
+        window_size (int): Window size. Default: 7
+        mlp_ratio (float): Ratio of mlp hidden dim to embedding dim. Default: 4
+        qkv_bias (bool): If True, add a learnable bias to query, key, value. Default: True
+        qk_scale (float): Override default qk scale of head_dim ** -0.5 if set. Default: None
+        drop_rate (float): Dropout rate. Default: 0
+        attn_drop_rate (float): Attention dropout rate. Default: 0
+        drop_path_rate (float): Stochastic depth rate. Default: 0.1
+        norm_layer (nn.Module): Normalization layer. Default: nn.LayerNorm.
+        ape (bool): If True, add absolute position embedding to the patch embedding. Default: False
+        patch_norm (bool): If True, add normalization after patch embedding. Default: True
+        use_checkpoint (bool): Whether to use checkpointing to save memory. Default: False
+        sf: Upscale factor. 2/3/4/8 for image SR, 1 for denoising and compress artifact reduction
+        img_range: Image range. 1. or 255.
+        upsampler: The reconstruction reconstruction module. 'pixelshuffle'/'pixelshuffledirect'/'nearest+conv'/None
+        resi_connection: The convolutional block before residual connection. '1conv'/'3conv'
+    """
+
+    def __init__(
+            self,
+            img_size=64,
+            patch_size=1,
+            in_chans=3,
+            num_out_ch=3,
+            embed_dim=96,
+            depths=[6, 6, 6, 6],
+            num_heads=[6, 6, 6, 6],
+            window_size=7,
+            mlp_ratio=4.,
+            qkv_bias=True,
+            qk_scale=None,
+            drop_rate=0.,
+            attn_drop_rate=0.,
+            drop_path_rate=0.1,
+            norm_layer=nn.LayerNorm,
+            ape=False,
+            patch_norm=True,
+            use_checkpoint=False,
+            sf=4,
+            img_range=1.,
+            upsampler='',
+            resi_connection='1conv',
+            unshuffle=False,
+            unshuffle_scale=None,
+            hq_key: str = "jpg",
+            lq_key: str = "hint",
+            learning_rate: float = None,
+            weight_decay: float = None
+    ) -> "SwinIR":
+        super(SwinIR, self).__init__()
+        num_in_ch = in_chans * (unshuffle_scale ** 2) if unshuffle else in_chans
+        num_feat = 64
+        self.img_range = img_range
+        if in_chans == 3:
+            rgb_mean = (0.4488, 0.4371, 0.4040)
+            self.mean = torch.Tensor(rgb_mean).view(1, 3, 1, 1)
+        else:
+            self.mean = torch.zeros(1, 1, 1, 1)
+        self.upscale = sf
+        self.upsampler = upsampler
+        self.window_size = window_size
+        self.unshuffle_scale = unshuffle_scale
+        self.unshuffle = unshuffle
+
+        #####################################################################################################
+        ################################### 1, shallow feature extraction ###################################
+        if unshuffle:
+            assert unshuffle_scale is not None
+            self.conv_first = nn.Sequential(
+                nn.PixelUnshuffle(sf),
+                nn.Conv2d(num_in_ch, embed_dim, 3, 1, 1),
+            )
+        else:
+            self.conv_first = nn.Conv2d(num_in_ch, embed_dim, 3, 1, 1)
+
+        #####################################################################################################
+        ################################### 2, deep feature extraction ######################################
+        self.num_layers = len(depths)
+        self.embed_dim = embed_dim
+        self.ape = ape
+        self.patch_norm = patch_norm
+        self.num_features = embed_dim
+        self.mlp_ratio = mlp_ratio
+
+        # split image into non-overlapping patches
+        self.patch_embed = PatchEmbed(
+            img_size=img_size, patch_size=patch_size, in_chans=embed_dim, embed_dim=embed_dim,
+            norm_layer=norm_layer if self.patch_norm else None
+        )
+        num_patches = self.patch_embed.num_patches
+        patches_resolution = self.patch_embed.patches_resolution
+        self.patches_resolution = patches_resolution
+
+        # merge non-overlapping patches into image
+        self.patch_unembed = PatchUnEmbed(
+            img_size=img_size, patch_size=patch_size, in_chans=embed_dim, embed_dim=embed_dim,
+            norm_layer=norm_layer if self.patch_norm else None
+        )
+
+        # absolute position embedding
+        if self.ape:
+            self.absolute_pos_embed = nn.Parameter(torch.zeros(1, num_patches, embed_dim))
+            trunc_normal_(self.absolute_pos_embed, std=.02)
+
+        self.pos_drop = nn.Dropout(p=drop_rate)
+
+        # stochastic depth
+        dpr = [x.item() for x in torch.linspace(0, drop_path_rate, sum(depths))]  # stochastic depth decay rule
+
+        # build Residual Swin Transformer blocks (RSTB)
+        self.layers = nn.ModuleList()
+        for i_layer in range(self.num_layers):
+            layer = RSTB(
+                dim=embed_dim,
+                input_resolution=(patches_resolution[0], patches_resolution[1]),
+                depth=depths[i_layer],
+                num_heads=num_heads[i_layer],
+                window_size=window_size,
+                mlp_ratio=self.mlp_ratio,
+                qkv_bias=qkv_bias, qk_scale=qk_scale,
+                drop=drop_rate, attn_drop=attn_drop_rate,
+                drop_path=dpr[sum(depths[:i_layer]):sum(depths[:i_layer + 1])],  # no impact on SR results
+                norm_layer=norm_layer,
+                downsample=None,
+                use_checkpoint=use_checkpoint,
+                img_size=img_size,
+                patch_size=patch_size,
+                resi_connection=resi_connection
+            )
+            self.layers.append(layer)
+        self.norm = norm_layer(self.num_features)
+
+        # build the last conv layer in deep feature extraction
+        if resi_connection == '1conv':
+            self.conv_after_body = nn.Conv2d(embed_dim, embed_dim, 3, 1, 1)
+        elif resi_connection == '3conv':
+            # to save parameters and memory
+            self.conv_after_body = nn.Sequential(
+                nn.Conv2d(embed_dim, embed_dim // 4, 3, 1, 1),
+                nn.LeakyReLU(negative_slope=0.2, inplace=True),
+                nn.Conv2d(embed_dim // 4, embed_dim // 4, 1, 1, 0),
+                nn.LeakyReLU(negative_slope=0.2, inplace=True),
+                nn.Conv2d(embed_dim // 4, embed_dim, 3, 1, 1)
+            )
+
+        #####################################################################################################
+        ################################ 3, high quality image reconstruction ################################
+        if self.upsampler == 'pixelshuffle':
+            # for classical SR
+            self.conv_before_upsample = nn.Sequential(
+                nn.Conv2d(embed_dim, num_feat, 3, 1, 1),
+                nn.LeakyReLU(inplace=True)
+            )
+            self.upsample = Upsample(sf, num_feat)
+            self.conv_last = nn.Conv2d(num_feat, num_out_ch, 3, 1, 1)
+        elif self.upsampler == 'pixelshuffledirect':
+            # for lightweight SR (to save parameters)
+            self.upsample = UpsampleOneStep(
+                sf, embed_dim, num_out_ch,
+                (patches_resolution[0], patches_resolution[1])
+            )
+        elif self.upsampler == 'nearest+conv':
+            # for real-world SR (less artifacts)
+            self.conv_before_upsample = nn.Sequential(
+                nn.Conv2d(embed_dim, num_feat, 3, 1, 1),
+                nn.LeakyReLU(inplace=True)
+            )
+            self.conv_up1 = nn.Conv2d(num_feat, num_feat, 3, 1, 1)
+            if self.upscale == 4:
+                self.conv_up2 = nn.Conv2d(num_feat, num_feat, 3, 1, 1)
+            elif self.upscale == 8:
+                self.conv_up2 = nn.Conv2d(num_feat, num_feat, 3, 1, 1)
+                self.conv_up3 = nn.Conv2d(num_feat, num_feat, 3, 1, 1)
+            self.conv_hr = nn.Conv2d(num_feat, num_feat, 3, 1, 1)
+            self.conv_last = nn.Conv2d(num_feat, num_out_ch, 3, 1, 1)
+            self.lrelu = nn.LeakyReLU(negative_slope=0.2, inplace=True)
+        else:
+            # for image denoising and JPEG compression artifact reduction
+            self.conv_last = nn.Conv2d(embed_dim, num_out_ch, 3, 1, 1)
+
+        self.apply(self._init_weights)
+
+    def _init_weights(self, m: nn.Module) -> None:
+        if isinstance(m, nn.Linear):
+            trunc_normal_(m.weight, std=.02)
+            if isinstance(m, nn.Linear) and m.bias is not None:
+                nn.init.constant_(m.bias, 0)
+        elif isinstance(m, nn.LayerNorm):
+            nn.init.constant_(m.bias, 0)
+            nn.init.constant_(m.weight, 1.0)
+
+    # TODO: What's this ?
+    @torch.jit.ignore
+    def no_weight_decay(self) -> Set[str]:
+        return {'absolute_pos_embed'}
+
+    @torch.jit.ignore
+    def no_weight_decay_keywords(self) -> Set[str]:
+        return {'relative_position_bias_table'}
+
+    def check_image_size(self, x: torch.Tensor) -> torch.Tensor:
+        _, _, h, w = x.size()
+        mod_pad_h = (self.window_size - h % self.window_size) % self.window_size
+        mod_pad_w = (self.window_size - w % self.window_size) % self.window_size
+        x = F.pad(x, (0, mod_pad_w, 0, mod_pad_h), 'reflect')
+        return x
+
+    def forward_features(self, x: torch.Tensor) -> torch.Tensor:
+        x_size = (x.shape[2], x.shape[3])
+        x = self.patch_embed(x)
+        if self.ape:
+            x = x + self.absolute_pos_embed
+        x = self.pos_drop(x)
+
+        for layer in self.layers:
+            x = layer(x, x_size)
+
+        x = self.norm(x)  # B L C
+        x = self.patch_unembed(x, x_size)
+
+        return x
+
+    def forward(self, x: torch.Tensor, *args, **kwargs) -> torch.Tensor:
+        H, W = x.shape[2:]
+        x = self.check_image_size(x)
+
+        self.mean = self.mean.type_as(x)
+        x = (x - self.mean) * self.img_range
+
+        if self.upsampler == 'pixelshuffle':
+            # for classical SR
+            x = self.conv_first(x)
+            x = self.conv_after_body(self.forward_features(x)) + x
+            x = self.conv_before_upsample(x)
+            x = self.conv_last(self.upsample(x))
+        elif self.upsampler == 'pixelshuffledirect':
+            # for lightweight SR
+            x = self.conv_first(x)
+            x = self.conv_after_body(self.forward_features(x)) + x
+            x = self.upsample(x)
+        elif self.upsampler == 'nearest+conv':
+            # for real-world SR
+            x = self.conv_first(x)
+            x = self.conv_after_body(self.forward_features(x)) + x
+            x = self.conv_before_upsample(x)
+            x = self.lrelu(self.conv_up1(torch.nn.functional.interpolate(x, scale_factor=2, mode='nearest')))
+            if self.upscale == 4:
+                x = self.lrelu(self.conv_up2(torch.nn.functional.interpolate(x, scale_factor=2, mode='nearest')))
+            elif self.upscale == 8:
+                x = self.lrelu(self.conv_up2(torch.nn.functional.interpolate(x, scale_factor=2, mode='nearest')))
+                x = self.lrelu(self.conv_up3(torch.nn.functional.interpolate(x, scale_factor=2, mode='nearest')))
+            x = self.conv_last(self.lrelu(self.conv_hr(x)))
+        else:
+            # for image denoising and JPEG compression artifact reduction
+            x_first = self.conv_first(x)
+            res = self.conv_after_body(self.forward_features(x_first)) + x_first
+            x = x + self.conv_last(res)
+
+        x = x / self.img_range + self.mean
+
+        return x[:, :, :H * self.upscale, :W * self.upscale]
+
+    def flops(self) -> int:
+        flops = 0
+        H, W = self.patches_resolution
+        flops += H * W * 3 * self.embed_dim * 9
+        flops += self.patch_embed.flops()
+        for i, layer in enumerate(self.layers):
+            flops += layer.flops()
+        flops += H * W * 3 * self.embed_dim * self.embed_dim
+        flops += self.upsample.flops()
+        return flops

guided_diffusion/unet.py

@@ -0,0 +1,1148 @@
+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
+import functools
+from collections import OrderedDict
+
+
+from .fp16_util import convert_module_to_f16, convert_module_to_f32
+from .nn import (
+    checkpoint,
+    conv_nd,
+    linear,
+    avg_pool_nd,
+    zero_module,
+    normalization,
+    timestep_embedding,
+)
+
+
+NUM_CLASSES = 1000
+
+def create_model(
+    image_size,
+    num_channels,
+    num_res_blocks,
+    channel_mult="",
+    learn_sigma=False,
+    class_cond=False,
+    conv_resample=True,
+    use_checkpoint=False,
+    attention_resolutions="16",
+    num_heads=1,
+    num_head_channels=-1,
+    num_heads_upsample=-1,
+    use_scale_shift_norm=False,
+    dropout=0,
+    resblock_updown=False,
+    use_fp16=False,
+    use_new_attention_order=False,
+    dims=2,
+    model_path='',
+):
+    if channel_mult == "":
+        if image_size == 512:
+            channel_mult = (0.5, 1, 1, 2, 2, 4, 4)
+        elif 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 channel_mult.split(","))
+    print(channel_mult)
+    attention_ds = []
+    if isinstance(attention_resolutions, int):
+        attention_ds.append(image_size // attention_resolutions)
+    elif isinstance(attention_resolutions, str):
+        for res in attention_resolutions.split(","):
+            attention_ds.append(image_size // int(res))
+    else:
+        raise NotImplementedError
+
+    if isinstance(num_res_blocks, str):
+        num_res_blocks_res = []
+        for res in num_res_blocks.split(","):
+            num_res_blocks_res.append(int(res))
+    else:
+        assert isinstance(num_res_blocks, int)
+        num_res_blocks_res = num_res_blocks
+
+    model= UNetModel(
+        image_size=image_size,
+        in_channels=3,
+        model_channels=num_channels,
+        out_channels=(3 if not learn_sigma else 6),
+        num_res_blocks=num_res_blocks_res,
+        attention_resolutions=tuple(attention_ds),
+        dropout=dropout,
+        channel_mult=channel_mult,
+        num_classes=(NUM_CLASSES if class_cond else None),
+        use_checkpoint=use_checkpoint,
+        use_fp16=use_fp16,
+        num_heads=num_heads,
+        dims=dims,
+        num_head_channels=num_head_channels,
+        num_heads_upsample=num_heads_upsample,
+        use_scale_shift_norm=use_scale_shift_norm,
+        resblock_updown=resblock_updown,
+        use_new_attention_order=use_new_attention_order,
+        conv_resample=conv_resample
+    )
+
+    try:
+        ckpt = th.load(model_path, map_location='cpu')
+        if list(model.state_dict().keys())[0].startswith('module.'):
+            if list(ckpt.keys())[0].startswith('module.'):
+                ckpt = ckpt
+            else:
+                ckpt = OrderedDict({f'module.{key}': value for key, value in ckpt.items()})
+        else:
+            if list(ckpt.keys())[0].startswith('module.'):
+                ckpt = OrderedDict({key[7:]: value for key, value in ckpt.items()})
+            else:
+                ckpt = ckpt
+
+        model.load_state_dict(ckpt)
+    except Exception as e:
+        print(f"Got exception: {e} / Randomly initialize")
+    return model
+
+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):
+        for layer in self:
+            if isinstance(layer, TimestepBlock):
+                x = layer(x, emb)
+            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),
+            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)
+
+    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 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,
+        num_heads=1,
+        num_head_channels=-1,
+        num_heads_upsample=-1,
+        use_scale_shift_norm=False,
+        resblock_updown=False,
+        use_new_attention_order=False,
+    ):
+        super().__init__()
+        if isinstance(num_res_blocks, int):
+            num_res_blocks = [num_res_blocks, ] * len(channel_mult)
+        else:
+            assert len(num_res_blocks) == len(channel_mult)
+        self.num_res_blocks = num_res_blocks
+
+        if num_heads_upsample == -1:
+            num_heads_upsample = num_heads
+
+        self.image_size = image_size
+        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.num_classes = num_classes
+        self.use_checkpoint = use_checkpoint
+        self.dtype = th.float16 if use_fp16 else th.float32
+        self.num_heads = num_heads
+        self.num_head_channels = num_head_channels
+        self.num_heads_upsample = num_heads_upsample
+
+        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:
+            self.label_emb = nn.Embedding(num_classes, time_embed_dim)
+
+        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[level]):
+                layers = [
+                    ResBlock(
+                        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,
+                            use_new_attention_order=use_new_attention_order,
+                        )
+                    )
+                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
+
+        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=num_head_channels,
+                use_new_attention_order=use_new_attention_order,
+            ),
+            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(num_res_blocks[level] + 1):
+                ich = input_block_chans.pop()
+                layers = [
+                    ResBlock(
+                        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,
+                            use_new_attention_order=use_new_attention_order,
+                        )
+                    )
+                if level and i == 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, input_ch, out_channels, 3, padding=1)),
+        )
+
+    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, 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.num_classes is not None
+        ), "must specify y if and only if the model is class-conditional"
+
+        hs = []
+        emb = self.time_embed(timestep_embedding(timesteps, self.model_channels))
+
+        if self.num_classes is not None:
+            assert y.shape == (x.shape[0],)
+            emb = emb + self.label_emb(y)
+
+        h = x.type(self.dtype)
+        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)
+        h = h.type(x.dtype)
+        return self.out(h)
+
+
+class SuperResModel(UNetModel):
+    """
+    A UNetModel that performs super-resolution.
+
+    Expects an extra kwarg `low_res` to condition on a low-resolution image.
+    """
+
+    def __init__(self, image_size, in_channels, *args, **kwargs):
+        super().__init__(image_size, in_channels * 2, *args, **kwargs)
+
+    def forward(self, x, timesteps, low_res=None, **kwargs):
+        _, _, new_height, new_width = x.shape
+        upsampled = F.interpolate(low_res, (new_height, new_width), mode="bilinear")
+        x = th.cat([x, upsampled], dim=1)
+        return super().forward(x, timesteps, **kwargs)
+
+
+class EncoderUNetModel(nn.Module):
+    """
+    The half UNet model with attention and timestep embedding.
+
+    For usage, see UNet.
+    """
+
+    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,
+        use_checkpoint=False,
+        use_fp16=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,
+        pool="adaptive",
+    ):
+        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.use_checkpoint = use_checkpoint
+        self.dtype = th.float16 if use_fp16 else th.float32
+        self.num_heads = num_heads
+        self.num_head_channels = num_head_channels
+        self.num_heads_upsample = num_heads_upsample
+
+        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),
+        )
+
+        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[level]):
+                layers = [
+                    ResBlock(
+                        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,
+                            use_new_attention_order=use_new_attention_order,
+                        )
+                    )
+                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
+
+        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=num_head_channels,
+                use_new_attention_order=use_new_attention_order,
+            ),
+            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.pool = pool
+        if pool == "adaptive":
+            self.out = nn.Sequential(
+                normalization(ch),
+                nn.SiLU(),
+                nn.AdaptiveAvgPool2d((1, 1)),
+                zero_module(conv_nd(dims, ch, out_channels, 1)),
+                nn.Flatten(),
+            )
+        elif pool == "attention":
+            assert num_head_channels != -1
+            self.out = nn.Sequential(
+                normalization(ch),
+                nn.SiLU(),
+                AttentionPool2d(
+                    (image_size // ds), ch, num_head_channels, out_channels
+                ),
+            )
+        elif pool == "spatial":
+            self.out = nn.Sequential(
+                nn.Linear(self._feature_size, 2048),
+                nn.ReLU(),
+                nn.Linear(2048, self.out_channels),
+            )
+        elif pool == "spatial_v2":
+            self.out = nn.Sequential(
+                nn.Linear(self._feature_size, 2048),
+                normalization(2048),
+                nn.SiLU(),
+                nn.Linear(2048, self.out_channels),
+            )
+        else:
+            raise NotImplementedError(f"Unexpected {pool} pooling")
+
+    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)
+
+    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)
+
+    def forward(self, x, timesteps):
+        """
+        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.
+        :return: an [N x K] Tensor of outputs.
+        """
+        emb = self.time_embed(timestep_embedding(timesteps, self.model_channels))
+
+        results = []
+        h = x.type(self.dtype)
+        for module in self.input_blocks:
+            h = module(h, emb)
+            if self.pool.startswith("spatial"):
+                results.append(h.type(x.dtype).mean(dim=(2, 3)))
+        h = self.middle_block(h, emb)
+        if self.pool.startswith("spatial"):
+            results.append(h.type(x.dtype).mean(dim=(2, 3)))
+            h = th.cat(results, axis=-1)
+            return self.out(h)
+        else:
+            h = h.type(x.dtype)
+            return self.out(h)
+
+
+class NLayerDiscriminator(nn.Module):
+    def __init__(self, input_nc, ndf=64, n_layers=3, norm_layer=nn.BatchNorm2d, use_sigmoid=False):
+        super(NLayerDiscriminator, self).__init__()
+        if type(norm_layer) == functools.partial:
+            use_bias = norm_layer.func == nn.InstanceNorm2d
+        else:
+            use_bias = norm_layer == nn.InstanceNorm2d
+
+        kw = 4
+        padw = 1
+        sequence = [
+            nn.Conv2d(input_nc, ndf, kernel_size=kw, stride=2, padding=padw),
+            nn.LeakyReLU(0.2, True)
+        ]
+
+        nf_mult = 1
+        nf_mult_prev = 1
+        for n in range(1, n_layers):
+            nf_mult_prev = nf_mult
+            nf_mult = min(2**n, 8)
+            sequence += [
+                nn.Conv2d(ndf * nf_mult_prev, ndf * nf_mult,
+                          kernel_size=kw, stride=2, padding=padw, bias=use_bias),
+                norm_layer(ndf * nf_mult),
+                nn.LeakyReLU(0.2, True)
+            ]
+
+        nf_mult_prev = nf_mult
+        nf_mult = min(2**n_layers, 8)
+        sequence += [
+            nn.Conv2d(ndf * nf_mult_prev, ndf * nf_mult,
+                      kernel_size=kw, stride=2, padding=padw, bias=use_bias),
+            norm_layer(ndf * nf_mult),
+            nn.LeakyReLU(0.2, True)
+        ]
+
+        sequence += [nn.Conv2d(ndf * nf_mult, 1, kernel_size=kw, stride=2, padding=padw)] + [nn.Dropout(0.5)]
+        if use_sigmoid:
+            sequence += [nn.Sigmoid()]
+
+        self.model = nn.Sequential(*sequence)
+
+    def forward(self, input):
+        return self.model(input)
+
+
+class GANLoss(nn.Module):
+    """Define different GAN objectives.
+
+    The GANLoss class abstracts away the need to create the target label tensor
+    that has the same size as the input.
+    """
+
+    def __init__(self, gan_mode, target_real_label=1.0, target_fake_label=0.0):
+        """ Initialize the GANLoss class.
+
+        Parameters:
+            gan_mode (str) - - the type of GAN objective. It currently supports vanilla, lsgan, and wgangp.
+            target_real_label (bool) - - label for a real image
+            target_fake_label (bool) - - label of a fake image
+
+        Note: Do not use sigmoid as the last layer of Discriminator.
+        LSGAN needs no sigmoid. vanilla GANs will handle it with BCEWithLogitsLoss.
+        """
+        super(GANLoss, self).__init__()
+        self.register_buffer('real_label', th.tensor(target_real_label))
+        self.register_buffer('fake_label', th.tensor(target_fake_label))
+        self.gan_mode = gan_mode
+        if gan_mode == 'lsgan':
+            self.loss = nn.MSELoss()
+        elif gan_mode == 'vanilla':
+            self.loss = nn.BCEWithLogitsLoss()
+        elif gan_mode in ['wgangp']:
+            self.loss = None
+        else:
+            raise NotImplementedError('gan mode %s not implemented' % gan_mode)
+
+    def get_target_tensor(self, prediction, target_is_real):
+        """Create label tensors with the same size as the input.
+
+        Parameters:
+            prediction (tensor) - - tpyically the prediction from a discriminator
+            target_is_real (bool) - - if the ground truth label is for real images or fake images
+
+        Returns:
+            A label tensor filled with ground truth label, and with the size of the input
+        """
+
+        if target_is_real:
+            target_tensor = self.real_label
+        else:
+            target_tensor = self.fake_label
+        return target_tensor.expand_as(prediction)
+
+    def __call__(self, prediction, target_is_real):
+        """Calculate loss given Discriminator's output and grount truth labels.
+
+        Parameters:
+            prediction (tensor) - - tpyically the prediction output from a discriminator
+            target_is_real (bool) - - if the ground truth label is for real images or fake images
+
+        Returns:
+            the calculated loss.
+        """
+        if self.gan_mode in ['lsgan', 'vanilla']:
+            target_tensor = self.get_target_tensor(prediction, target_is_real)
+            loss = self.loss(prediction, target_tensor)
+        elif self.gan_mode == 'wgangp':
+            if target_is_real:
+                loss = -prediction.mean()
+            else:
+                loss = prediction.mean()
+        return loss
+
+
+def cal_gradient_penalty(netD, real_data, fake_data, device, type='mixed', constant=1.0, lambda_gp=10.0):
+    """Calculate the gradient penalty loss, used in WGAN-GP paper https://arxiv.org/abs/1704.00028
+
+    Arguments:
+        netD (network)              -- discriminator network
+        real_data (tensor array)    -- real images
+        fake_data (tensor array)    -- generated images from the generator
+        device (str)                -- GPU / CPU: from torch.device('cuda:{}'.format(self.gpu_ids[0])) if self.gpu_ids else torch.device('cpu')
+        type (str)                  -- if we mix real and fake data or not [real | fake | mixed].
+        constant (float)            -- the constant used in formula ( | |gradient||_2 - constant)^2
+        lambda_gp (float)           -- weight for this loss
+
+    Returns the gradient penalty loss
+    """
+    if lambda_gp > 0.0:
+        if type == 'real':   # either use real images, fake images, or a linear interpolation of two.
+            interpolatesv = real_data
+        elif type == 'fake':
+            interpolatesv = fake_data
+        elif type == 'mixed':
+            alpha = th.rand(real_data.shape[0], 1, device=device)
+            alpha = alpha.expand(real_data.shape[0], real_data.nelement() // real_data.shape[0]).contiguous().view(*real_data.shape)
+            interpolatesv = alpha * real_data + ((1 - alpha) * fake_data)
+        else:
+            raise NotImplementedError('{} not implemented'.format(type))
+        interpolatesv.requires_grad_(True)
+        disc_interpolates = netD(interpolatesv)
+        gradients = th.autograd.grad(outputs=disc_interpolates, inputs=interpolatesv,
+                                     grad_outputs=th.ones(disc_interpolates.size()).to(device),
+                                     create_graph=True, retain_graph=True, only_inputs=True)
+        gradients = gradients[0].view(real_data.size(0), -1)  # flat the data
+        gradient_penalty = (((gradients + 1e-16).norm(2, dim=1) - constant) ** 2).mean() * lambda_gp        # added eps
+        return gradient_penalty, gradients
+    else:
+        return 0.0, None

latent_DDCM_CCFG.py

@@ -0,0 +1,45 @@
+import spaces
+import torch
+import numpy as np
+import gradio as gr
+
+from util.file import generate_binary_file, load_numpy_from_binary_bitwise
+from latent_utils import generate_ours
+
+
+@torch.no_grad()
+@spaces.GPU(duration=80)
+def main(prompt, T, K, K_tilde, model_type='512x512', bitstream=None, avail_models=None,
+         progress=gr.Progress(track_tqdm=True)):
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+    indices = load_numpy_from_binary_bitwise(bitstream, K, T, model_type, T - 1)
+    if indices is not None:
+        indices = indices.to(device)
+
+    # model, _ = load_model(img_size_to_id[img_size], T, device, float16=True, compile=False)
+    model = avail_models[model_type].to(device)
+
+    model.device = device
+    model.model.to(device=device)
+
+    model.model.scheduler.device = device
+
+    model.set_timesteps(T, device=device)
+
+    with torch.no_grad():
+        x, indices = generate_ours(model,
+                                   num_noises=K,
+                                   num_noises_to_optimize=K_tilde,
+                                   prompt=prompt,
+                                   negative_prompt=None,
+                                   indices=indices)
+    x = (x / 2 + 0.5).clamp(0, 1)
+    x = x.detach().cpu().squeeze().numpy()
+    x = np.transpose(x, (1, 2, 0))
+    torch.cuda.empty_cache()
+
+    if bitstream is None:
+        indices = generate_binary_file(indices.numpy(), K, T, model_type)
+        return x, indices
+    return x

latent_DDCM_compression.py

@@ -0,0 +1,47 @@
+import gradio as gr
+import numpy as np
+import spaces
+import torch
+import torchvision
+
+from latent_utils import compress
+from util.file import generate_binary_file, load_numpy_from_binary_bitwise
+from util.img_utils import resize_and_crop
+
+
+@torch.no_grad()
+@spaces.GPU(duration=80)
+def main(img_to_compress, T, K, model_type='512x512', bitstream=None, avail_models=None,
+         progress=gr.Progress(track_tqdm=True)):
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    indices = load_numpy_from_binary_bitwise(bitstream, K, T, model_type, T - 1)
+    if indices is not None:
+        indices = indices.to(device)
+    if indices is None:
+        img_to_compress = resize_and_crop(img_to_compress, int(model_type.split('x')[0]))
+        img_to_compress = (torchvision.transforms.ToTensor()(img_to_compress) * 2) - 1
+        img_to_compress = img_to_compress.unsqueeze(0).to(device)
+    else:
+        img_to_compress = None
+    print(T, K, model_type)
+    # model, _ = load_model(img_size_to_id[img_size], T, device, float16=True, compile=False)
+    model = avail_models[model_type].to(device)
+
+    model.device = device
+    model.model.to(device=device)
+
+    model.model.scheduler.device = device
+    # model.model.scheduler.scheduler = model.model.scheduler.scheduler.to(device)
+
+    model.set_timesteps(T, device=device)
+    model.num_timesteps = T
+    with torch.no_grad():
+        x, indices = compress(model, img_to_compress, K, indices, device=device)
+    x = (x / 2 + 0.5).clamp(0, 1)
+    x = x.detach().cpu().squeeze().numpy()
+    x = np.transpose(x, (1, 2, 0))
+    torch.cuda.empty_cache()
+    indices = generate_binary_file(indices.numpy(), K, T, model_type)
+    if bitstream is None:
+        return x, indices
+    return x

latent_models.py

@@ -0,0 +1,278 @@
+import torch
+from diffusers import DDIMScheduler, StableDiffusionPipeline
+from typing import Optional, Tuple, Union
+from transformers import Blip2Processor, Blip2ForConditionalGeneration
+
+
+class PipelineWrapper(torch.nn.Module):
+    def __init__(self, model_id: str,
+                 timesteps: int,
+                 device: torch.device,
+                 float16: bool = False,
+                 compile: bool = True,
+                 token: Optional[str] = None, *args, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+        self.model_id = model_id
+        self.num_timesteps = timesteps
+        self.device = device
+        self.float16 = float16
+        self.token = token
+        self.compile = compile
+        self.model = None
+
+    # def get_sigma(self, timestep: int) -> float:
+    #     sqrt_recipm1_alphas_cumprod = torch.sqrt(1.0 / self.model.scheduler.alphas_cumprod - 1)
+    #     return sqrt_recipm1_alphas_cumprod[timestep]
+
+    @property
+    def timesteps(self) -> torch.Tensor:
+        return self.model.scheduler.timesteps
+
+    @property
+    def dtype(self) -> torch.dtype:
+        if self.model is None:
+            raise AttributeError("Model is not initialized.")
+        return self.model.unet.dtype
+
+    def get_x_0_hat(self, xt: torch.Tensor, epst: torch.Tensor, timestep: torch.Tensor) -> torch.Tensor:
+        return self.model.scheduler.get_x_0_hat(xt, epst, timestep)
+
+    def finish_step(self, xt: torch.Tensor, pred_x0: torch.Tensor, epst: torch.Tensor,
+                    timestep: torch.Tensor, variance_noise: torch.Tensor,
+                    **kwargs) -> torch.Tensor:
+        return self.model.scheduler.finish_step(xt, pred_x0, epst, timestep, variance_noise, **kwargs)
+
+    def get_variance(self, timestep: torch.Tensor) -> torch.Tensor:
+        return self.model.scheduler.get_variance(timestep)
+
+    def set_timesteps(self, timesteps: int, device: torch.device) -> None:
+        self.model.scheduler.set_timesteps(timesteps, device=device)
+
+    def encode_image(self, x: torch.Tensor) -> torch.Tensor:
+        pass
+
+    def decode_image(self, x: torch.Tensor) -> torch.Tensor:
+        pass
+
+    def encode_prompt(self, prompt: torch.Tensor, negative_prompt=None) -> Tuple[torch.Tensor, torch.Tensor]:
+        pass
+
+    def get_epst(self, xt: torch.Tensor, t: torch.Tensor, prompt_embeds: torch.Tensor,
+                 guidance_scale: Optional[float] = None, **kwargs) -> torch.Tensor:
+        pass
+
+    def get_image_size(self) -> Tuple[int, int]:
+        return self.model.unet.config.sample_size * self.model.vae_scale_factor
+
+    def get_noise_shape(self, imsize: Union[int, Tuple[int]], batch_size: int) -> Tuple[int, ...]:
+        if isinstance(imsize, int):
+            imsize = (imsize, imsize)
+        variance_noise_shape = (batch_size,
+                                self.model.unet.config.in_channels,
+                                imsize[-2],
+                                imsize[-1])
+        return variance_noise_shape
+
+    def get_latent_shape(self, orig_image_shape: Union[int, Tuple[int, int]]) -> Tuple[int, ...]:
+        if isinstance(orig_image_shape, int):
+            orig_image_shape = (orig_image_shape, orig_image_shape)
+        return (self.model.unet.config.in_channels,
+                orig_image_shape[0] // self.model.vae_scale_factor,
+                orig_image_shape[1] // self.model.vae_scale_factor)
+
+    def get_pre_kwargs(self, **kwargs) -> dict:
+        return {}
+
+
+class StableDiffWrapper(PipelineWrapper):
+    def __init__(self, scheduler='ddpm', *args, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+        self.scheduler_type = scheduler
+        try:
+            self.model = StableDiffusionPipeline.from_pretrained(
+                self.model_id,
+                torch_dtype=torch.float16 if self.float16 else torch.float32,
+                token=self.token).to(self.device)
+        except OSError:
+            self.model = StableDiffusionPipeline.from_pretrained(
+                self.model_id,
+                torch_dtype=torch.float16 if self.float16 else torch.float32,
+                token=self.token, force_download=True
+                ).to(self.device)
+
+        if scheduler == 'ddpm' or 'ddim' in scheduler:
+            eta = 1.0 if 'ddpm' in scheduler else float(scheduler.split('-')[1])
+            self.model.scheduler = DDIMWrapper(model_id=self.model_id, device=self.device,
+                                               eta=eta,
+                                               float16=self.float16, token=self.token)
+
+        self.model.scheduler.set_timesteps(self.num_timesteps, device=self.device)
+        if self.compile:
+            try:
+                self.model.unet = torch.compile(self.model.unet, mode="reduce-overhead", fullgraph=True)
+            except Exception as e:
+                print(f"Error compiling model: {e}")
+
+    def encode_image(self, x: torch.Tensor) -> torch.Tensor:
+        return (self.model.vae.encode(x).latent_dist.mode() * self.model.vae.config.scaling_factor)  # .float()
+
+    def decode_image(self, x: torch.Tensor) -> torch.Tensor:
+        if x.device != self.device:
+            orig_device = self.model.vae.device
+            self.model.vae.to(x.device)
+            ret = self.model.vae.decode(x / self.model.vae.config.scaling_factor).sample.clamp(-1, 1)
+            self.model.vae.to(orig_device)
+            return ret
+        return self.model.vae.decode(x / self.model.vae.config.scaling_factor).sample.clamp(-1, 1)
+
+    def encode_prompt(self, prompt: torch.Tensor, negative_prompt=None) -> Tuple[torch.Tensor, torch.Tensor]:
+        do_cfg = (negative_prompt is not None) or prompt != ""
+
+        prompt_embeds, negative_prompt_embeds = self.model.encode_prompt(
+            prompt, self.device, 1,
+            do_cfg,
+            negative_prompt,
+        )
+
+        if do_cfg:
+            prompt_embeds = torch.cat([negative_prompt_embeds, prompt_embeds])
+        return prompt_embeds
+
+    def get_epst(self, xt: torch.Tensor, t: torch.Tensor, prompt_embeds: torch.Tensor,
+                 guidance_scale: Optional[float] = None, return_everything=False, **kwargs):
+        do_cfg = prompt_embeds.shape[0] > 1
+        xt = torch.cat([xt] * 2) if do_cfg else xt
+
+        # predict the noise residual
+        noise_pred = self.model.unet(xt, t, encoder_hidden_states=prompt_embeds, return_dict=False)[0]
+
+        # perform guidance
+        if do_cfg:
+            noise_pred_uncond, noise_pred_text = noise_pred.chunk(2)
+            return None, noise_pred_uncond, noise_pred_text
+        return None, noise_pred, None
+
+
+class SchedulerWrapper(object):
+    def __init__(self, model_id: str, device: torch.device,
+                 float16: bool = False, token: Optional[str] = None, *args, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+        self.model_id = model_id
+        self.device = device
+        self.float16 = float16
+        self.token = token
+        self.scheduler = None
+
+    @property
+    def timesteps(self) -> torch.Tensor:
+        return self.scheduler.timesteps
+
+    def set_timesteps(self, timesteps: int, device: torch.device) -> None:
+        self.scheduler.set_timesteps(timesteps, device=device)
+        if self.scheduler.timesteps[0] == 1000:
+            self.scheduler.timesteps -= 1
+
+    def get_x_0_hat(self, xt: torch.Tensor, epst: torch.Tensor, timestep: torch.Tensor) -> torch.Tensor:
+        pass
+
+    def finish_step(self, xt: torch.Tensor, pred_x0: torch.Tensor, epst: torch.Tensor,
+                    timestep: torch.Tensor, variance_noise: torch.Tensor,
+                    **kwargs) -> torch.Tensor:
+        pass
+
+    def get_variance(self, timestep: torch.Tensor) -> torch.Tensor:
+        pass
+
+
+class DDIMWrapper(SchedulerWrapper):
+    def __init__(self, eta, *args, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+        self.scheduler = DDIMScheduler.from_pretrained(
+            self.model_id, subfolder="scheduler",
+            torch_dtype=torch.float16 if self.float16 else torch.float32,
+            token=self.token,
+            device=self.device, timestep_spacing='linspace')
+        self.eta = eta
+
+    def get_x_0_hat(self, xt: torch.Tensor, epst: torch.Tensor, timestep: torch.Tensor) -> torch.Tensor:
+        # compute alphas, betas
+        alpha_prod_t = self.scheduler.alphas_cumprod[timestep]
+        beta_prod_t = 1 - alpha_prod_t
+        # compute predicted original sample from predicted noise also called
+        # "predicted x_0" of formula (12) from https://arxiv.org/pdf/2010.02502.pdf
+        if self.scheduler.config.prediction_type == 'epsilon':
+            pred_original_sample = (xt - beta_prod_t ** (0.5) * epst) / alpha_prod_t ** (0.5)
+        elif self.scheduler.config.prediction_type == 'v_prediction':
+            pred_original_sample = (alpha_prod_t ** 0.5) * xt - (beta_prod_t ** 0.5) * epst
+
+        return pred_original_sample
+
+    def finish_step(self, xt: torch.Tensor, pred_x0: torch.Tensor, epst: torch.Tensor,
+                    timestep: torch.Tensor, variance_noise: torch.Tensor,
+                    eta=None) -> torch.Tensor:
+        if eta is None:
+            eta = self.eta
+        prev_timestep = timestep - self.scheduler.config.num_train_timesteps // \
+            self.scheduler.num_inference_steps
+        # 2. compute alphas, betas
+        alpha_prod_t = self.scheduler.alphas_cumprod[timestep]
+        alpha_prod_t_prev = self._get_alpha_prod_t_prev(prev_timestep)
+        beta_prod_t = 1 - alpha_prod_t
+
+        # 5. compute variance: "sigma_t(η)" -> see formula (16)
+        # σ_t = sqrt((1 − α_t−1)/(1 − α_t)) * sqrt(1 − α_t/α_t−1)
+        variance = self.get_variance(timestep)
+        std_dev_t = eta * variance ** (0.5)
+
+        # std_dev_t = eta * variance ** (0.5)
+        # Take care of asymetric reverse process (asyrp)
+        if self.scheduler.config.prediction_type == 'epsilon':
+            model_output_direction = epst
+        elif self.scheduler.config.prediction_type == 'v_prediction':
+            model_output_direction = (alpha_prod_t**0.5) * epst + (beta_prod_t**0.5) * xt
+
+        # 6. compute "direction pointing to x_t" of formula (12) from https://arxiv.org/pdf/2010.02502.pdf
+        pred_sample_direction = (1 - alpha_prod_t_prev - std_dev_t**2) ** (0.5) * model_output_direction
+        # 7. compute x_t without "random noise" of formula (12) from https://arxiv.org/pdf/2010.02502.pdf
+        prev_sample = alpha_prod_t_prev ** (0.5) * pred_x0 + pred_sample_direction
+
+        # 8. Add noice if eta > 0
+        if eta > 0:
+            sigma_z = std_dev_t * variance_noise
+            prev_sample = prev_sample + sigma_z
+
+        return prev_sample
+
+    def get_variance(self, timestep: torch.Tensor) -> torch.Tensor:
+        prev_timestep = timestep - self.scheduler.config.num_train_timesteps // \
+            self.scheduler.num_inference_steps
+        variance = self.scheduler._get_variance(timestep, prev_timestep)
+        return variance
+
+    def _get_alpha_prod_t_prev(self, prev_timestep: torch.Tensor) -> torch.Tensor:
+        return self.scheduler.alphas_cumprod[prev_timestep] if prev_timestep >= 0 \
+            else self.scheduler.final_alpha_cumprod
+
+def load_model(model_id: str, timesteps: int,
+               device: torch.device, blip: bool = False,
+               float16: bool = False, token: Optional[str] = None,
+               compile: bool = True,
+               blip_model="Salesforce/blip2-opt-2.7b-coco", scheduler: str = 'ddpm') -> PipelineWrapper:
+    pipeline = StableDiffWrapper(model_id=model_id, timesteps=timesteps, device=device,
+                                 scheduler=scheduler,
+                                 float16=float16, token=token, compile=compile)
+
+    pipeline = pipeline.to(device)
+    if blip:
+        pipeline.blip_processor = Blip2Processor.from_pretrained(blip_model)
+        try:
+            print(device if torch.cuda.get_device_properties(0).total_memory/(1024**3) > 18 else 'cpu')
+            pipeline.blip_model = Blip2ForConditionalGeneration.from_pretrained(
+                blip_model,).to(device if torch.cuda.get_device_properties(0).total_memory/(1024**3) > 18 else 'cpu')
+        except OSError:
+            pipeline.blip_model = Blip2ForConditionalGeneration.from_pretrained(
+                blip_model, force_download=True).to(device if torch.cuda.get_device_properties(0).total_memory/(1024**3) > 18 else 'cpu')
+        pipeline.blip_max_words = 32
+
+    image_size = pipeline.get_image_size()
+    return pipeline, image_size

latent_utils.py

@@ -0,0 +1,322 @@
+import os
+import spaces
+import time
+from glob import glob
+from typing import Callable, Optional, Tuple, Union, Dict
+import random
+import matplotlib.pyplot as plt
+import numpy as np
+import torch
+import torchvision.transforms as transforms
+from PIL import Image
+from torch.utils.data import DataLoader
+from torchvision.datasets import VisionDataset
+from tqdm import tqdm
+from util.img_utils import clear_color
+
+from latent_models import PipelineWrapper
+
+
+def set_seed(seed: int) -> None:
+    torch.manual_seed(seed)
+    np.random.seed(seed)
+    random.seed(seed)
+    torch.cuda.manual_seed_all(seed)
+    # torch.backends.cudnn.deterministic = True
+    # torch.backends.cudnn.benchmark = False
+
+
+class MinusOneToOne(torch.nn.Module):
+    def forward(self, tensor: torch.Tensor) -> torch.Tensor:
+        return tensor * 2 - 1
+
+
+class ResizePIL(torch.nn.Module):
+    def __init__(self, image_size: Optional[Union[int, Tuple[int, int]]] = None):
+        super().__init__()
+        if isinstance(image_size, int):
+            image_size = (image_size, image_size)
+        self.image_size = image_size
+
+    def forward(self, pil_image: Image.Image) -> Image.Image:
+        if self.image_size is not None:
+            pil_image = pil_image.resize(self.image_size)
+        return pil_image
+
+
+def get_loader(datadir: str, batch_size: int = 1,
+               crop_to: Optional[Union[int, Tuple[int, int]]] = None,
+               include_path: bool = False) -> DataLoader:
+    transform = transforms.Compose([
+        ResizePIL(crop_to),
+        transforms.ToTensor(),
+        MinusOneToOne(),
+    ])
+    loader = DataLoader(FoldersDataset(datadir, transform, include_path=include_path),
+                        batch_size=batch_size,
+                        shuffle=True, num_workers=0, drop_last=False)
+    return loader
+
+
+class FoldersDataset(VisionDataset):
+    def __init__(self, root: str, transforms: Optional[Callable] = None,
+                 include_path: bool = False) -> None:
+        super().__init__(root, transforms)
+        self.include_path = include_path
+        self.root = root
+
+        if os.path.isdir(root):
+            self.fpaths = glob(os.path.join(root, '**', '*.png'), recursive=True)
+            self.fpaths += glob(os.path.join(root, '**', '*.JPEG'), recursive=True)
+            self.fpaths += glob(os.path.join(root, '**', '*.jpg'), recursive=True)
+            self.fpaths = sorted(self.fpaths)
+            assert len(self.fpaths) > 0, "File list is empty. Check the root."
+        elif os.path.exists(root):
+            self.fpaths = [root]
+        else:
+            raise FileNotFoundError(f"File not found: {root}")
+
+    def __len__(self):
+        return len(self.fpaths)
+
+    def __getitem__(self, index: int) -> Tuple[torch.Tensor, str]:
+        fpath = self.fpaths[index]
+        img = Image.open(fpath).convert('RGB')
+
+        if self.transforms is not None:
+            img = self.transforms(img)
+
+        path = ""
+        if self.include_path:
+            dirname = os.path.dirname(fpath)
+            # remove root from dirname
+            path = dirname[len(self.root) + 1:]
+        return img, os.path.basename(fpath).split(os.extsep)[0], path
+
+
+@spaces.GPU
+def compress(model: PipelineWrapper,
+             img_to_compress: torch.Tensor,
+             num_noises: int,
+             loaded_indices,
+             device,
+             ):
+    # model.set_timesteps(model.num_timesteps, device=device)
+    dtype = model.dtype
+
+    prompt_embeds = model.encode_prompt("", None)
+
+    set_seed(88888888)
+    if img_to_compress is None:
+        img_to_compress = torch.zeros(1, 3, model.get_image_size(), model.get_image_size(), device=device)
+    enc_im = model.encode_image(img_to_compress.to(dtype))
+    kwargs = model.get_pre_kwargs(height=img_to_compress.shape[-2], width=img_to_compress.shape[-1],
+                                  prompt_embeds=prompt_embeds)
+
+    set_seed(100000)
+    xt = torch.randn(1, *enc_im.shape[1:], device=device, dtype=dtype)
+
+    result_noise_indices = []
+
+    pbar = tqdm(model.timesteps)
+    for idx, t in enumerate(pbar):
+        set_seed(idx)
+        noise = torch.randn(num_noises, *xt.shape[1:], device=device, dtype=dtype)
+
+        _, epst, _ = model.get_epst(xt, t, prompt_embeds, 0.0, **kwargs)
+        x_0_hat = model.get_x_0_hat(xt, epst, t)
+        if loaded_indices is None:
+
+            if t >= 1:
+                dot_prod = torch.matmul(noise.view(noise.shape[0], -1),
+                                        (enc_im - x_0_hat).view(enc_im.shape[0], -1).transpose(0, 1))
+                best_idx = torch.argmax(dot_prod)
+                best_noise = noise[best_idx]
+            else:
+                best_noise = noise[0]
+        else:
+            if t >= 1:
+                best_idx = loaded_indices[idx]
+                best_noise = noise[best_idx]
+            else:
+                best_noise = noise[0]
+        if t >= 1:
+            result_noise_indices.append(best_idx)
+
+        xt = model.finish_step(xt, x_0_hat, epst, t, best_noise.unsqueeze(0), eta=None)
+
+    try:
+        img = model.decode_image(xt)
+    except torch.OutOfMemoryError:
+        img = model.decode_image(xt.to('cpu'))
+
+    return img, torch.tensor(result_noise_indices).squeeze().cpu()
+
+
+@spaces.GPU
+def generate_ours(model: PipelineWrapper,
+                  num_noises: int,
+                  num_noises_to_optimize: int,
+                  prompt: str = "",
+                  negative_prompt: Optional[str] = None,
+                  indices = None,
+                  ) -> Tuple[torch.Tensor, torch.Tensor]:
+    device = model.device
+    dtype = model.dtype
+    # print(num_noises, num_noises_to_optimize, flush=True)
+    # model.set_timesteps(model.num_timesteps, device=device)
+
+    set_seed(88888888)
+    if prompt is None:
+        prompt = ""
+    prompt_embeds = model.encode_prompt(prompt, negative_prompt)
+
+    kwargs = model.get_pre_kwargs(height=model.get_image_size(),
+                                  width=model.get_image_size(),
+                                  prompt_embeds=prompt_embeds)
+
+    set_seed(100000)
+    xt = torch.randn(1, *model.get_latent_shape(model.get_image_size()), device=device, dtype=dtype)
+
+    result_noise_indices = []
+    pbar = tqdm(model.timesteps)
+    for idx, t in enumerate(pbar):
+        set_seed(idx)
+        noise = torch.randn(num_noises, *xt.shape[1:], device=device, dtype=dtype)  # Codebook
+
+        _, epst_uncond, epst_cond = model.get_epst(xt, t, prompt_embeds, 1.0, return_everything=True, **kwargs)
+
+        x_0_hat = model.get_x_0_hat(xt, epst_uncond, t)
+        if t >= 1:
+            if indices is None:
+                prev_classif_score = epst_uncond - epst_cond
+                set_seed(int(time.time_ns() & 0xFFFFFFFF))
+                noise_indices = torch.randint(0, num_noises, size=(num_noises_to_optimize,), device=device)
+                loss = torch.matmul(noise[noise_indices].view(num_noises_to_optimize, -1),
+                                    prev_classif_score.view(prev_classif_score.shape[0], -1).transpose(0, 1))
+                best_idx = noise_indices[torch.argmax(loss)]
+            else:
+                best_idx = indices[idx]
+            best_noise = noise[best_idx]
+            result_noise_indices.append(best_idx)
+
+        else:
+            best_noise = torch.zeros_like(noise[0])
+        xt = model.finish_step(xt, x_0_hat, epst_uncond, t, best_noise)
+
+    try:
+        img = model.decode_image(xt)
+    except torch.OutOfMemoryError:
+        img = model.decode_image(xt.to('cpu'))
+    return img, torch.stack(result_noise_indices).squeeze().cpu()
+
+
+def decompress(model: PipelineWrapper,
+               image_size: Tuple[int, int],
+               indices: Dict[str, torch.Tensor],
+               num_noises: int,
+               prompt: str = "",
+               negative_prompt: Optional[str] = None,
+               tedit: int = 0,
+               new_prompt: str = "",
+               new_negative_prompt: Optional[str] = None,
+               guidance_scale: float = 3.0,
+               num_pursuit_noises: Optional[int] = 1,
+               num_pursuit_coef_bits: Optional[int] = 3,
+               t_range: Tuple[int, int] = (999, 0),
+               robust_randn: bool = False
+               ) -> torch.Tensor:
+    noise_indices = indices['noise_indices']
+    coeffs_indices = indices['coeff_indices']
+    num_pursuit_noises = num_pursuit_noises if num_pursuit_noises is not None else 1
+    num_pursuit_coef_bits = num_pursuit_coef_bits if num_pursuit_coef_bits is not None else 1
+
+    device = model.device
+    dtype = model.dtype
+    # model.set_timesteps(model.num_timesteps, device=device)
+
+    set_seed(88888888)
+    orig_prompt_embeds = model.encode_prompt(prompt, negative_prompt)
+    kwargs_orig = model.get_pre_kwargs(height=image_size[-2], width=image_size[-1],
+                                       prompt_embeds=orig_prompt_embeds)
+    if new_prompt != prompt or new_negative_prompt != negative_prompt:
+        new_prompt_embeds = model.encode_prompt(new_prompt, new_negative_prompt)
+        kwargs_new = model.get_pre_kwargs(height=image_size[-2], width=image_size[-1],
+                                          prompt_embeds=new_prompt_embeds)
+    else:
+        new_prompt_embeds = orig_prompt_embeds
+        kwargs_new = kwargs_orig
+
+    set_seed(100000)
+    xt = torch.randn(1, *model.get_latent_shape(image_size), device=device, dtype=dtype)
+
+    pbar = tqdm(model.timesteps)
+    for idx, t in enumerate(pbar):
+        set_seed(idx)
+
+        dont_optimize_t = not (t_range[0] >= t >= t_range[1])
+        # No intermittent support
+
+        if robust_randn:
+            noise = get_robust_randn(num_noises if not dont_optimize_t else 1, xt.shape[1:], device, dtype)
+        else:
+            noise = torch.randn(num_noises if not dont_optimize_t else 1, *xt.shape[1:], device=device, dtype=dtype)
+
+        curr_embs = orig_prompt_embeds if idx < tedit else new_prompt_embeds
+        curr_kwargs = kwargs_orig if idx < tedit else kwargs_new
+        epst = model.get_epst(xt, t, curr_embs, guidance_scale, **curr_kwargs)
+        x_0_hat = model.get_x_0_hat(xt, epst, t)
+
+        curr_t_noise_indices = noise_indices[idx]
+        best_noise = noise[curr_t_noise_indices[0]]
+        pursuit_coefs = torch.linspace(0, 1, 2 ** num_pursuit_coef_bits + 1)[1:]
+        if num_pursuit_noises > 1:
+            curr_t_coeffs_indices = coeffs_indices[idx]
+            if curr_t_coeffs_indices[0] == -1:
+                continue
+            for pursuit_idx in range(1, num_pursuit_noises):
+                pursuit_coef = pursuit_coefs[curr_t_coeffs_indices[pursuit_idx]]
+                best_noise = best_noise * torch.sqrt(pursuit_coef) + noise[
+                    curr_t_noise_indices[pursuit_idx]] * torch.sqrt(1 - pursuit_coef)
+                best_noise /= best_noise.std()
+        best_noise = best_noise.unsqueeze(0)
+        xt = model.finish_step(xt, x_0_hat, epst, t, best_noise)
+    img = model.decode_image(xt)
+    return img
+
+
+def inf_generate(model: PipelineWrapper,
+                 prompt: str = "",
+                 negative_prompt: Optional[str] = None,
+                 guidance_scale: float = 7.0,
+                 record: int = 0,
+                 save_root: str = "") -> Tuple[torch.Tensor, torch.Tensor]:
+    device = model.device
+    dtype = model.dtype
+
+    model.set_timesteps(model.num_timesteps, device=device)
+
+    prompt_embeds = model.encode_prompt(prompt, negative_prompt)
+    kwargs = model.get_pre_kwargs(height=model.get_image_size(),
+                                  width=model.get_image_size(),
+                                  prompt_embeds=prompt_embeds)
+
+    xt = torch.randn(1, *model.get_latent_shape(model.get_image_size()), device=device, dtype=dtype)
+    pbar = tqdm(model.timesteps)
+    for idx, t in enumerate(pbar):
+        noise = torch.randn(1, *xt.shape[1:], device=device, dtype=dtype)
+
+        epst = model.get_epst(xt, t, prompt_embeds, guidance_scale, **kwargs)
+        x_0_hat = model.get_x_0_hat(xt, epst, t)
+        xt = model.finish_step(xt, x_0_hat, epst, t, noise)
+
+        if record and not idx % record:
+            img = model.decode_image(x_0_hat)
+            plt.imsave(os.path.join(save_root, f"progress/x_0_hat_{str(t.item()).zfill(4)}.png"),
+                       clear_color(img[0].unsqueeze(0), normalize=False))
+    try:
+        img = model.decode_image(xt)
+    except torch.OutOfMemoryError:
+        img = model.decode_image(xt.to('cpu'))
+
+    return img

requirements.txt

@@ -0,0 +1,15 @@
+numpy
+opencv-python
+scipy
+tqdm
+lmdb
+pyyaml
+yapf
+dctorch
+einops
+timm
+diffusers
+facexlib
+pyiqa
+torch==2.4.0
+torchvision==0.19.0

util/basicsr_img_util.py

@@ -0,0 +1,172 @@
+import cv2
+import math
+import numpy as np
+import os
+import torch
+from torchvision.utils import make_grid
+
+
+def img2tensor(imgs, bgr2rgb=True, float32=True):
+    """Numpy array to tensor.
+
+    Args:
+        imgs (list[ndarray] | ndarray): Input images.
+        bgr2rgb (bool): Whether to change bgr to rgb.
+        float32 (bool): Whether to change to float32.
+
+    Returns:
+        list[tensor] | tensor: Tensor images. If returned results only have
+            one element, just return tensor.
+    """
+
+    def _totensor(img, bgr2rgb, float32):
+        if img.shape[2] == 3 and bgr2rgb:
+            if img.dtype == 'float64':
+                img = img.astype('float32')
+            img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
+        img = torch.from_numpy(img.transpose(2, 0, 1))
+        if float32:
+            img = img.float()
+        return img
+
+    if isinstance(imgs, list):
+        return [_totensor(img, bgr2rgb, float32) for img in imgs]
+    else:
+        return _totensor(imgs, bgr2rgb, float32)
+
+
+def tensor2img(tensor, rgb2bgr=True, out_type=np.uint8, min_max=(0, 1)):
+    """Convert torch Tensors into image numpy arrays.
+
+    After clamping to [min, max], values will be normalized to [0, 1].
+
+    Args:
+        tensor (Tensor or list[Tensor]): Accept shapes:
+            1) 4D mini-batch Tensor of shape (B x 3/1 x H x W);
+            2) 3D Tensor of shape (3/1 x H x W);
+            3) 2D Tensor of shape (H x W).
+            Tensor channel should be in RGB order.
+        rgb2bgr (bool): Whether to change rgb to bgr.
+        out_type (numpy type): output types. If ``np.uint8``, transform outputs
+            to uint8 type with range [0, 255]; otherwise, float type with
+            range [0, 1]. Default: ``np.uint8``.
+        min_max (tuple[int]): min and max values for clamp.
+
+    Returns:
+        (Tensor or list): 3D ndarray of shape (H x W x C) OR 2D ndarray of
+        shape (H x W). The channel order is BGR.
+    """
+    if not (torch.is_tensor(tensor) or (isinstance(tensor, list) and all(torch.is_tensor(t) for t in tensor))):
+        raise TypeError(f'tensor or list of tensors expected, got {type(tensor)}')
+
+    if torch.is_tensor(tensor):
+        tensor = [tensor]
+    result = []
+    for _tensor in tensor:
+        _tensor = _tensor.squeeze(0).float().detach().cpu().clamp_(*min_max)
+        _tensor = (_tensor - min_max[0]) / (min_max[1] - min_max[0])
+
+        n_dim = _tensor.dim()
+        if n_dim == 4:
+            img_np = make_grid(_tensor, nrow=int(math.sqrt(_tensor.size(0))), normalize=False).numpy()
+            img_np = img_np.transpose(1, 2, 0)
+            if rgb2bgr:
+                img_np = cv2.cvtColor(img_np, cv2.COLOR_RGB2BGR)
+        elif n_dim == 3:
+            img_np = _tensor.numpy()
+            img_np = img_np.transpose(1, 2, 0)
+            if img_np.shape[2] == 1:  # gray image
+                img_np = np.squeeze(img_np, axis=2)
+            else:
+                if rgb2bgr:
+                    img_np = cv2.cvtColor(img_np, cv2.COLOR_RGB2BGR)
+        elif n_dim == 2:
+            img_np = _tensor.numpy()
+        else:
+            raise TypeError(f'Only support 4D, 3D or 2D tensor. But received with dimension: {n_dim}')
+        if out_type == np.uint8:
+            # Unlike MATLAB, numpy.unit8() WILL NOT round by default.
+            img_np = (img_np * 255.0).round()
+        img_np = img_np.astype(out_type)
+        result.append(img_np)
+    if len(result) == 1:
+        result = result[0]
+    return result
+
+
+def tensor2img_fast(tensor, rgb2bgr=True, min_max=(0, 1)):
+    """This implementation is slightly faster than tensor2img.
+    It now only supports torch tensor with shape (1, c, h, w).
+
+    Args:
+        tensor (Tensor): Now only support torch tensor with (1, c, h, w).
+        rgb2bgr (bool): Whether to change rgb to bgr. Default: True.
+        min_max (tuple[int]): min and max values for clamp.
+    """
+    output = tensor.squeeze(0).detach().clamp_(*min_max).permute(1, 2, 0)
+    output = (output - min_max[0]) / (min_max[1] - min_max[0]) * 255
+    output = output.type(torch.uint8).cpu().numpy()
+    if rgb2bgr:
+        output = cv2.cvtColor(output, cv2.COLOR_RGB2BGR)
+    return output
+
+
+def imfrombytes(content, flag='color', float32=False):
+    """Read an image from bytes.
+
+    Args:
+        content (bytes): Image bytes got from files or other streams.
+        flag (str): Flags specifying the color type of a loaded image,
+            candidates are `color`, `grayscale` and `unchanged`.
+        float32 (bool): Whether to change to float32., If True, will also norm
+            to [0, 1]. Default: False.
+
+    Returns:
+        ndarray: Loaded image array.
+    """
+    img_np = np.frombuffer(content, np.uint8)
+    imread_flags = {'color': cv2.IMREAD_COLOR, 'grayscale': cv2.IMREAD_GRAYSCALE, 'unchanged': cv2.IMREAD_UNCHANGED}
+    img = cv2.imdecode(img_np, imread_flags[flag])
+    if float32:
+        img = img.astype(np.float32) / 255.
+    return img
+
+
+def imwrite(img, file_path, params=None, auto_mkdir=True):
+    """Write image to file.
+
+    Args:
+        img (ndarray): Image array to be written.
+        file_path (str): Image file path.
+        params (None or list): Same as opencv's :func:`imwrite` interface.
+        auto_mkdir (bool): If the parent folder of `file_path` does not exist,
+            whether to create it automatically.
+
+    Returns:
+        bool: Successful or not.
+    """
+    if auto_mkdir:
+        dir_name = os.path.abspath(os.path.dirname(file_path))
+        os.makedirs(dir_name, exist_ok=True)
+    ok = cv2.imwrite(file_path, img, params)
+    if not ok:
+        raise IOError('Failed in writing images.')
+
+
+def crop_border(imgs, crop_border):
+    """Crop borders of images.
+
+    Args:
+        imgs (list[ndarray] | ndarray): Images with shape (h, w, c).
+        crop_border (int): Crop border for each end of height and weight.
+
+    Returns:
+        list[ndarray]: Cropped images.
+    """
+    if crop_border == 0:
+        return imgs
+    else:
+        if isinstance(imgs, list):
+            return [v[crop_border:-crop_border, crop_border:-crop_border, ...] for v in imgs]
+        else:
+            return imgs[crop_border:-crop_border, crop_border:-crop_border, ...]

util/file.py

@@ -0,0 +1,55 @@
+import tempfile
+
+import numpy as np
+import torch
+import gradio as gr
+
+
+def save_numpy_as_binary_bitwise(array, K, filename):
+    """Save a NumPy array as a binary file with bitwise storage."""
+    bits_per_value = int(np.ceil(np.log2(K)))  # Number of bits required per value
+    bitstring = ''.join(format(val, f'0{bits_per_value}b') for val in array)  # Convert each number to binary
+
+    # Convert bitstring to bytes
+    byte_array = int(bitstring, 2).to_bytes((len(bitstring) + 7) // 8, byteorder='big')
+
+    # Write to binary file
+    with open(filename, 'wb') as f:
+        f.write(byte_array)
+
+
+def load_numpy_from_binary_bitwise(filename, K, T, model_type, effective_num_values):
+    if filename is None:
+        return None
+    """Load a NumPy array from a binary file stored in bitwise format."""
+    bits_per_value = int(np.ceil(np.log2(K)))  # Number of bits required per value
+
+    if f'-K{K}-' not in filename:
+        raise gr.Error("Please set the codebook size to match the bitstream file you provided")
+
+    if f'-T{T}-' not in filename:
+        raise gr.Error("Please set the number of diffusion timesteps to match the bitstream file you provided")
+
+    if f'-M{model_type}-' not in filename:
+        raise gr.Error("Please set the image size to match the bitstream file you provided")
+
+    # Read the binary file as bytes
+    with open(filename, 'rb') as f:
+        byte_data = f.read()
+    # Convert bytes to a binary string
+    bitstring = bin(int.from_bytes(byte_data, byteorder='big'))[2:]  # Remove '0b' prefix
+
+    # Pad with leading zeros if needed
+    bitstring = bitstring.zfill(effective_num_values * bits_per_value)
+
+    # Extract values from bitstring
+    values = [int(bitstring[i:i + bits_per_value], 2) for i in range(0, len(bitstring), bits_per_value)]
+
+    return torch.from_numpy(np.array(values, dtype=np.int32)).squeeze()
+
+
+def generate_binary_file(np_arr, num_noises, timesteps, model_type):
+    temp_file = tempfile.NamedTemporaryFile(delete=False,
+                                            suffix=f".bitstream-T{timesteps}-K{num_noises}-M{model_type}-")
+    save_numpy_as_binary_bitwise(np_arr, num_noises, temp_file.name)
+    return temp_file.name

util/img_utils.py

@@ -0,0 +1,423 @@
+import numpy as np
+import torch
+import scipy
+import torch.nn.functional as F
+from torch import nn
+from torch.autograd import Variable
+from PIL import Image
+import matplotlib.pyplot as plt
+
+"""
+Helper functions for new types of inverse problems
+"""
+
+
+def fft2(x):
+    """ FFT with shifting DC to the center of the image"""
+    return torch.fft.fftshift(torch.fft.fft2(x), dim=[-1, -2])
+
+
+def ifft2(x):
+    """ IFFT with shifting DC to the corner of the image prior to transform"""
+    return torch.fft.ifft2(torch.fft.ifftshift(x, dim=[-1, -2]))
+
+
+def fft2_m(x):
+    """ FFT for multi-coil """
+    if not torch.is_complex(x):
+        x = x.type(torch.complex64)
+    return torch.view_as_complex(fft2c_new(torch.view_as_real(x)))
+
+
+def ifft2_m(x):
+    """ IFFT for multi-coil """
+    if not torch.is_complex(x):
+        x = x.type(torch.complex64)
+    return torch.view_as_complex(ifft2c_new(torch.view_as_real(x)))
+
+
+def clear(x):
+    x = x.detach().cpu().squeeze().numpy()
+    return normalize_np(x)
+
+
+def resize_and_crop(image, imsize=512):
+    width, height = image.size
+
+    if width < height:
+        new_width = imsize
+        new_height = int((imsize / width) * height)
+    else:
+        new_height = imsize
+        new_width = int((imsize / height) * width)
+
+    image_resized = image.resize((new_width, new_height))
+
+    left = (new_width - imsize) / 2
+    top = (new_height - imsize) / 2
+    right = (new_width + imsize) / 2
+    bottom = (new_height + imsize) / 2
+
+    image_cropped = image_resized.crop((left, top, right, bottom))
+
+    return image_cropped
+
+
+def clear_color(x, normalize=True):
+    if torch.is_complex(x):
+        x = torch.abs(x)
+    if normalize:
+        x = x.detach().cpu().squeeze().numpy()
+        if x.ndim == 3:
+            return normalize_np(np.transpose(x, (1, 2, 0)))
+        else:
+            return normalize_np(x)
+    else:
+        x = (x / 2 + 0.5).clamp(0, 1)
+        x = x.detach().cpu().squeeze().numpy()
+        if x.ndim == 3:
+            return np.transpose(x, (1, 2, 0))
+        else:
+            return x
+
+
+def normalize_np(img):
+    """ Normalize img in arbitrary range to [0, 1] """
+    img -= np.min(img)
+    img /= np.max(img)
+    return img
+
+
+def prepare_im(load_dir, image_size, device):
+    ref_img = torch.from_numpy(normalize_np(plt.imread(load_dir)[:, :, :3].astype(np.float32))).to(device)
+    ref_img = ref_img.permute(2, 0, 1)
+    ref_img = ref_img.view(1, 3, image_size, image_size)
+    ref_img = ref_img * 2 - 1
+    return ref_img
+
+
+def fold_unfold(img_t, kernel, stride):
+    img_shape = img_t.shape
+    B, C, H, W = img_shape
+    print("\n----- input shape: ", img_shape)
+
+    patches = img_t.unfold(3, kernel, stride).unfold(2, kernel, stride).permute(0, 1, 2, 3, 5, 4)
+
+    print("\n----- patches shape:", patches.shape)
+    # reshape output to match F.fold input
+    patches = patches.contiguous().view(B, C, -1, kernel * kernel)
+    print("\n", patches.shape)  # [B, C, nb_patches_all, kernel_size*kernel_size]
+    patches = patches.permute(0, 1, 3, 2)
+    print("\n", patches.shape)  # [B, C, kernel_size*kernel_size, nb_patches_all]
+    patches = patches.contiguous().view(B, C * kernel * kernel, -1)
+    print("\n", patches.shape)  # [B, C*prod(kernel_size), L] as expected by Fold
+
+    output = F.fold(patches, output_size=(H, W),
+                    kernel_size=kernel, stride=stride)
+    # mask that mimics the original folding:
+    recovery_mask = F.fold(torch.ones_like(patches), output_size=(
+        H, W), kernel_size=kernel, stride=stride)
+    output = output / recovery_mask
+
+    return patches, output
+
+
+def reshape_patch(x, crop_size=128, dim_size=3):
+    x = x.transpose(0, 2).squeeze()  # [9, 3*(128**2)]
+    x = x.view(dim_size ** 2, 3, crop_size, crop_size)
+    return x
+
+
+def reshape_patch_back(x, crop_size=128, dim_size=3):
+    x = x.view(dim_size ** 2, 3 * (crop_size ** 2)).unsqueeze(dim=-1)
+    x = x.transpose(0, 2)
+    return x
+
+
+class Unfolder:
+    def __init__(self, img_size=256, crop_size=128, stride=64):
+        self.img_size = img_size
+        self.crop_size = crop_size
+        self.stride = stride
+
+        self.unfold = nn.Unfold(crop_size, stride=stride)
+        self.dim_size = (img_size - crop_size) // stride + 1
+
+    def __call__(self, x):
+        patch1D = self.unfold(x)
+        patch2D = reshape_patch(patch1D, crop_size=self.crop_size, dim_size=self.dim_size)
+        return patch2D
+
+
+def center_crop(img, new_width=None, new_height=None):
+    width = img.shape[1]
+    height = img.shape[0]
+
+    if new_width is None:
+        new_width = min(width, height)
+
+    if new_height is None:
+        new_height = min(width, height)
+
+    left = int(np.ceil((width - new_width) / 2))
+    right = width - int(np.floor((width - new_width) / 2))
+
+    top = int(np.ceil((height - new_height) / 2))
+    bottom = height - int(np.floor((height - new_height) / 2))
+
+    if len(img.shape) == 2:
+        center_cropped_img = img[top:bottom, left:right]
+    else:
+        center_cropped_img = img[top:bottom, left:right, ...]
+
+    return center_cropped_img
+
+
+class Folder:
+    def __init__(self, img_size=256, crop_size=128, stride=64):
+        self.img_size = img_size
+        self.crop_size = crop_size
+        self.stride = stride
+
+        self.fold = nn.Fold(img_size, crop_size, stride=stride)
+        self.dim_size = (img_size - crop_size) // stride + 1
+
+    def __call__(self, patch2D):
+        patch1D = reshape_patch_back(patch2D, crop_size=self.crop_size, dim_size=self.dim_size)
+        return self.fold(patch1D)
+
+
+def random_sq_bbox(img, mask_shape, image_size=256, margin=(16, 16)):
+    """Generate a random sqaure mask for inpainting
+    """
+    B, C, H, W = img.shape
+    h, w = mask_shape
+    margin_height, margin_width = margin
+    maxt = image_size - margin_height - h
+    maxl = image_size - margin_width - w
+
+    # bb
+    t = np.random.randint(margin_height, maxt)
+    l = np.random.randint(margin_width, maxl)
+
+    # make mask
+    mask = torch.ones([B, C, H, W], device=img.device)
+    mask[..., t:t + h, l:l + w] = 0
+
+    return mask, t, t + h, l, l + w
+
+
+class mask_generator:
+    def __init__(self, mask_type, mask_len_range=None, mask_prob_range=None,
+                 image_size=256, margin=(16, 16)):
+        """
+        (mask_len_range): given in (min, max) tuple.
+        Specifies the range of box size in each dimension
+        (mask_prob_range): for the case of random masking,
+        specify the probability of individual pixels being masked
+        """
+        assert mask_type in ['box', 'random', 'both', 'extreme']
+        self.mask_type = mask_type
+        self.mask_len_range = mask_len_range
+        self.mask_prob_range = mask_prob_range
+        self.image_size = image_size
+        self.margin = margin
+
+    def _retrieve_box(self, img):
+        l, h = self.mask_len_range
+        l, h = int(l), int(h)
+        mask_h = np.random.randint(l, h)
+        mask_w = np.random.randint(l, h)
+        mask, t, tl, w, wh = random_sq_bbox(img,
+                                            mask_shape=(mask_h, mask_w),
+                                            image_size=self.image_size,
+                                            margin=self.margin)
+        return mask, t, tl, w, wh
+
+    def _retrieve_random(self, img):
+        total = self.image_size ** 2
+        # random pixel sampling
+        l, h = self.mask_prob_range
+        prob = np.random.uniform(l, h)
+        mask_vec = torch.ones([1, self.image_size * self.image_size])
+        samples = np.random.choice(self.image_size * self.image_size, int(total * prob), replace=False)
+        mask_vec[:, samples] = 0
+        mask_b = mask_vec.view(1, self.image_size, self.image_size)
+        mask_b = mask_b.repeat(3, 1, 1)
+        mask = torch.ones_like(img, device=img.device)
+        mask[:, ...] = mask_b
+        return mask
+
+    def __call__(self, img):
+        if self.mask_type == 'random':
+            mask = self._retrieve_random(img)
+            return mask
+        elif self.mask_type == 'box':
+            mask, t, th, w, wl = self._retrieve_box(img)
+            return mask
+        elif self.mask_type == 'extreme':
+            mask, t, th, w, wl = self._retrieve_box(img)
+            mask = 1. - mask
+            return mask
+
+
+def unnormalize(img, s=0.95):
+    scaling = torch.quantile(img.abs(), s)
+    return img / scaling
+
+
+def normalize(img, s=0.95):
+    scaling = torch.quantile(img.abs(), s)
+    return img * scaling
+
+
+def dynamic_thresholding(img, s=0.95):
+    img = normalize(img, s=s)
+    return torch.clip(img, -1., 1.)
+
+
+def get_gaussian_kernel(kernel_size=31, std=0.5):
+    n = np.zeros([kernel_size, kernel_size])
+    n[kernel_size // 2, kernel_size // 2] = 1
+    k = scipy.ndimage.gaussian_filter(n, sigma=std)
+    k = k.astype(np.float32)
+    return k
+
+
+def init_kernel_torch(kernel, device="cuda:0"):
+    h, w = kernel.shape
+    kernel = Variable(torch.from_numpy(kernel).to(device), requires_grad=True)
+    kernel = kernel.view(1, 1, h, w)
+    kernel = kernel.repeat(1, 3, 1, 1)
+    return kernel
+
+
+class Blurkernel(nn.Module):
+    def __init__(self, blur_type='gaussian', kernel_size=31, std=3.0, device=None):
+        super().__init__()
+        self.blur_type = blur_type
+        self.kernel_size = kernel_size
+        self.std = std
+        self.device = device
+        self.seq = nn.Sequential(
+            nn.ReflectionPad2d(self.kernel_size // 2),
+            nn.Conv2d(3, 3, self.kernel_size, stride=1, padding=0, bias=False, groups=3)
+        )
+
+        self.weights_init()
+
+    def forward(self, x):
+        return self.seq(x)
+
+    def weights_init(self):
+        if self.blur_type == "gaussian":
+            n = np.zeros((self.kernel_size, self.kernel_size))
+            n[self.kernel_size // 2, self.kernel_size // 2] = 1
+            k = scipy.ndimage.gaussian_filter(n, sigma=self.std)
+            k = torch.from_numpy(k)
+            self.k = k
+            for name, f in self.named_parameters():
+                f.data.copy_(k)
+        elif self.blur_type == "motion":
+            k = Kernel(size=(self.kernel_size, self.kernel_size), intensity=self.std).kernelMatrix
+            k = torch.from_numpy(k)
+            self.k = k
+            for name, f in self.named_parameters():
+                f.data.copy_(k)
+
+    def update_weights(self, k):
+        if not torch.is_tensor(k):
+            k = torch.from_numpy(k).to(self.device)
+        for name, f in self.named_parameters():
+            f.data.copy_(k)
+
+    def get_kernel(self):
+        return self.k
+
+
+class exact_posterior():
+    def __init__(self, betas, sigma_0, label_dim, input_dim):
+        self.betas = betas
+        self.sigma_0 = sigma_0
+        self.label_dim = label_dim
+        self.input_dim = input_dim
+
+    def py_given_x0(self, x0, y, A, verbose=False):
+        norm_const = 1 / ((2 * np.pi) ** self.input_dim * self.sigma_0 ** 2)
+        exp_in = -1 / (2 * self.sigma_0 ** 2) * torch.linalg.norm(y - A(x0)) ** 2
+        if not verbose:
+            return norm_const * torch.exp(exp_in)
+        else:
+            return norm_const * torch.exp(exp_in), norm_const, exp_in
+
+    def pxt_given_x0(self, x0, xt, t, verbose=False):
+        beta_t = self.betas[t]
+        norm_const = 1 / ((2 * np.pi) ** self.label_dim * beta_t)
+        exp_in = -1 / (2 * beta_t) * torch.linalg.norm(xt - np.sqrt(1 - beta_t) * x0) ** 2
+        if not verbose:
+            return norm_const * torch.exp(exp_in)
+        else:
+            return norm_const * torch.exp(exp_in), norm_const, exp_in
+
+    def prod_logsumexp(self, x0, xt, y, A, t):
+        py_given_x0_density, pyx0_nc, pyx0_ei = self.py_given_x0(x0, y, A, verbose=True)
+        pxt_given_x0_density, pxtx0_nc, pxtx0_ei = self.pxt_given_x0(x0, xt, t, verbose=True)
+        summand = (pyx0_nc * pxtx0_nc) * torch.exp(-pxtx0_ei - pxtx0_ei)
+        return torch.logsumexp(summand, dim=0)
+
+
+def map2tensor(gray_map):
+    """Move gray maps to GPU, no normalization is done"""
+    return torch.FloatTensor(gray_map).unsqueeze(0).unsqueeze(0).cuda()
+
+
+def create_penalty_mask(k_size, penalty_scale):
+    """Generate a mask of weights penalizing values close to the boundaries"""
+    center_size = k_size // 2 + k_size % 2
+    mask = create_gaussian(size=k_size, sigma1=k_size, is_tensor=False)
+    mask = 1 - mask / np.max(mask)
+    margin = (k_size - center_size) // 2 - 1
+    mask[margin:-margin, margin:-margin] = 0
+    return penalty_scale * mask
+
+
+def create_gaussian(size, sigma1, sigma2=-1, is_tensor=False):
+    """Return a Gaussian"""
+    func1 = [np.exp(-z ** 2 / (2 * sigma1 ** 2)) / np.sqrt(2 * np.pi * sigma1 ** 2) for z in
+             range(-size // 2 + 1, size // 2 + 1)]
+    func2 = func1 if sigma2 == -1 else [np.exp(-z ** 2 / (2 * sigma2 ** 2)) / np.sqrt(2 * np.pi * sigma2 ** 2) for z in
+                                        range(-size // 2 + 1, size // 2 + 1)]
+    return torch.FloatTensor(np.outer(func1, func2)).cuda() if is_tensor else np.outer(func1, func2)
+
+
+def total_variation_loss(img, weight):
+    tv_h = ((img[:, :, 1:, :] - img[:, :, :-1, :]).pow(2)).mean()
+    tv_w = ((img[:, :, :, 1:] - img[:, :, :, :-1]).pow(2)).mean()
+    return weight * (tv_h + tv_w)
+
+
+if __name__ == '__main__':
+    import numpy as np
+    from torch import nn
+    import matplotlib.pyplot as plt
+
+    device = 'cuda:0'
+    load_path = '/media/harry/tomo/FFHQ/256/test/00000.png'
+    img = torch.tensor(plt.imread(load_path)[:, :, :3])  # rgb
+    img = torch.permute(img, (2, 0, 1)).view(1, 3, 256, 256).to(device)
+
+    mask_len_range = (32, 128)
+    mask_prob_range = (0.3, 0.7)
+    image_size = 256
+    # mask
+    mask_gen = mask_generator(
+        mask_len_range=mask_len_range,
+        mask_prob_range=mask_prob_range,
+        image_size=image_size
+    )
+    mask = mask_gen(img)
+
+    mask = np.transpose(mask.squeeze().cpu().detach().numpy(), (1, 2, 0))
+
+    plt.imshow(mask)
+    plt.show()