init

.gitignore

@@ -0,0 +1,7 @@
+.DS_Store
+*pyc
+__pycache__
+*.egg-info
+
+results
+*.ckpt

app.py

@@ -0,0 +1,51 @@
+import os
+import sys
+import time
+import gradio as gr
+from videocrafter_test import Text2Video
+
+def videocrafter_demo(result_dir='./tmp/'):
+    text2video = Text2Video(result_dir)
+    with gr.Blocks(analytics_enabled=False) as videocrafter_iface:
+        with gr.Row().style(equal_height=False):
+            with gr.Tab(label="VideoCrafter"):
+                input_text = gr.Text()
+                model_choices=['origin','vangogh','frozen','yourname', 'coco']
+                trigger_word_list=['','Loving Vincent style', 'frozenmovie style', 'MakotoShinkaiYourName style', 'coco style']
+
+                with gr.Row():
+                    model_index = gr.Dropdown(label='Models', elem_id=f"model", choices=model_choices, value=model_choices[0], type="index",interactive=True)
+                    trigger_word=gr.Dropdown(label='Trigger Word', elem_id=f"trigger_word", choices=trigger_word_list, value=trigger_word_list[0], interactive=True)
+
+                with gr.Row():
+                    steps = gr.Slider(minimum=1, maximum=200, step=1, elem_id=f"steps", label="Sampling steps", value=50)
+                    eta = gr.Slider(minimum=0.0, maximum=1.0, step=0.1, label='ETA', value=1.0, elem_id="eta")
+
+                with gr.Row():
+                    lora_scale = gr.Slider(minimum=0.0, maximum=2.0, step=0.1, label='Lora Scale', value=1.0, elem_id="lora_scale")
+                    cfg_scale = gr.Slider(minimum=1.0, maximum=30.0, step=0.5, label='CFG Scale', value=15.0, elem_id="cfg_scale")
+
+                send_btn = gr.Button("Send")
+
+            with gr.Column():
+                output_video_1 = gr.PlayableVideo()
+
+            send_btn.click(
+                fn=text2video.get_prompt, 
+                inputs=[
+                    input_text,
+                    steps,
+                    model_index,
+                    eta,
+                    cfg_scale,
+                    lora_scale,
+                    trigger_word
+                ],
+                outputs=[output_video_1],
+            )
+    return videocrafter_iface
+
+if __name__ == "__main__":
+    result_dir = os.path.join('./', 'results')
+    videocrafter_iface = videocrafter_demo(result_dir)
+    videocrafter_iface.launch()

input/prompts.txt

@@ -0,0 +1,2 @@
+astronaut riding a horse
+Flying through an intense battle between pirate ships in a stormy ocean

lvdm/data/webvid.py

@@ -0,0 +1,188 @@
+import os
+import random
+import bisect
+
+import pandas as pd
+
+import omegaconf
+import torch
+from torch.utils.data import Dataset
+from torchvision import transforms
+from decord import VideoReader, cpu
+import torchvision.transforms._transforms_video as transforms_video
+
+class WebVid(Dataset):
+    """
+    WebVid Dataset.
+    Assumes webvid data is structured as follows.
+    Webvid/
+        videos/
+            000001_000050/      ($page_dir)
+                1.mp4           (videoid.mp4)
+                ...
+                5000.mp4
+            ...
+    """
+    def __init__(self,
+                 meta_path,
+                 data_dir,
+                 subsample=None,
+                 video_length=16,
+                 resolution=[256, 512],
+                 frame_stride=1,
+                 spatial_transform=None,
+                 crop_resolution=None,
+                 fps_max=None,
+                 load_raw_resolution=False,
+                 fps_schedule=None,
+                 fs_probs=None,
+                 bs_per_gpu=None,
+                 trigger_word='',
+                 dataname='',
+                 ):
+        self.meta_path = meta_path
+        self.data_dir = data_dir
+        self.subsample = subsample
+        self.video_length = video_length
+        self.resolution = [resolution, resolution] if isinstance(resolution, int) else resolution
+        self.frame_stride = frame_stride
+        self.fps_max = fps_max
+        self.load_raw_resolution = load_raw_resolution
+        self.fs_probs = fs_probs
+        self.trigger_word = trigger_word
+        self.dataname = dataname
+
+        self._load_metadata()
+        if spatial_transform is not None:
+            if spatial_transform == "random_crop":
+                self.spatial_transform = transforms_video.RandomCropVideo(crop_resolution)
+            elif spatial_transform == "resize_center_crop":
+                assert(self.resolution[0] == self.resolution[1])
+                self.spatial_transform = transforms.Compose([
+                    transforms.Resize(resolution),
+                    transforms_video.CenterCropVideo(resolution),
+                    ])
+            else:
+                raise NotImplementedError
+        else:
+            self.spatial_transform = None
+        
+        self.fps_schedule = fps_schedule
+        self.bs_per_gpu = bs_per_gpu
+        if self.fps_schedule is not None:
+            assert(self.bs_per_gpu is not None)
+            self.counter = 0
+            self.stage_idx = 0
+        
+    def _load_metadata(self):
+        metadata = pd.read_csv(self.meta_path)
+        if self.subsample is not None:
+            metadata = metadata.sample(self.subsample, random_state=0)
+        metadata['caption'] = metadata['name']
+        del metadata['name']
+        self.metadata = metadata
+        self.metadata.dropna(inplace=True)
+        # self.metadata['caption'] = self.metadata['caption'].str[:350]
+    
+    def _get_video_path(self, sample):
+        if self.dataname == "loradata":
+            rel_video_fp =  str(sample['videoid']) + '.mp4'
+            full_video_fp = os.path.join(self.data_dir, rel_video_fp)
+        else:
+            rel_video_fp = os.path.join(sample['page_dir'], str(sample['videoid']) + '.mp4')
+            full_video_fp = os.path.join(self.data_dir, 'videos', rel_video_fp)
+        return full_video_fp, rel_video_fp
+    
+    def get_fs_based_on_schedule(self, frame_strides, schedule):
+        assert(len(frame_strides) == len(schedule) + 1) # nstage=len_fps_schedule + 1
+        global_step = self.counter // self.bs_per_gpu # TODO: support resume.
+        stage_idx = bisect.bisect(schedule, global_step)
+        frame_stride = frame_strides[stage_idx]
+        # log stage change
+        if stage_idx != self.stage_idx:
+            print(f'fps stage: {stage_idx} start ... new frame stride = {frame_stride}')
+            self.stage_idx = stage_idx
+        return frame_stride
+    
+    def get_fs_based_on_probs(self, frame_strides, probs):
+        assert(len(frame_strides) == len(probs))
+        return random.choices(frame_strides, weights=probs)[0]
+
+    def get_fs_randomly(self, frame_strides):
+        return random.choice(frame_strides)
+    
+    def __getitem__(self, index):
+        
+        if isinstance(self.frame_stride, list) or isinstance(self.frame_stride, omegaconf.listconfig.ListConfig):
+            if self.fps_schedule is not None:
+                frame_stride = self.get_fs_based_on_schedule(self.frame_stride, self.fps_schedule)
+            elif self.fs_probs is not None:
+                frame_stride = self.get_fs_based_on_probs(self.frame_stride, self.fs_probs)
+            else:
+                frame_stride = self.get_fs_randomly(self.frame_stride)
+        else:
+            frame_stride = self.frame_stride
+        assert(isinstance(frame_stride, int)), type(frame_stride)
+
+        while True:
+            index = index % len(self.metadata)
+            sample = self.metadata.iloc[index]
+            video_path, rel_fp = self._get_video_path(sample)
+            caption = sample['caption']+self.trigger_word
+            
+            # make reader
+            try:
+                if self.load_raw_resolution:
+                    video_reader = VideoReader(video_path, ctx=cpu(0))
+                else:
+                    video_reader = VideoReader(video_path, ctx=cpu(0), width=self.resolution[1], height=self.resolution[0])
+                if len(video_reader) < self.video_length:
+                    print(f"video length ({len(video_reader)}) is smaller than target length({self.video_length})")
+                    index += 1
+                    continue
+                else:
+                    pass
+            except:
+                index += 1
+                print(f"Load video failed! path = {video_path}")
+                continue
+            
+            # sample strided frames
+            all_frames = list(range(0, len(video_reader), frame_stride))
+            if len(all_frames) < self.video_length: # recal a max fs
+                frame_stride = len(video_reader) // self.video_length
+                assert(frame_stride != 0)
+                all_frames = list(range(0, len(video_reader), frame_stride))
+
+            # select a random clip
+            rand_idx = random.randint(0, len(all_frames) - self.video_length)
+            frame_indices = all_frames[rand_idx:rand_idx+self.video_length]
+            try:
+                frames = video_reader.get_batch(frame_indices)
+                break
+            except:
+                print(f"Get frames failed! path = {video_path}")
+                index += 1
+                continue
+
+        assert(frames.shape[0] == self.video_length),f'{len(frames)}, self.video_length={self.video_length}'
+        frames = torch.tensor(frames.asnumpy()).permute(3, 0, 1, 2).float() # [t,h,w,c] -> [c,t,h,w]
+        if self.spatial_transform is not None:
+            frames = self.spatial_transform(frames)
+        if self.resolution is not None:
+            assert(frames.shape[2] == self.resolution[0] and frames.shape[3] == self.resolution[1]), f'frames={frames.shape}, self.resolution={self.resolution}'
+        frames = (frames / 255 - 0.5) * 2
+        
+        fps_ori = video_reader.get_avg_fps()
+        fps_clip = fps_ori // frame_stride
+        if self.fps_max is not None and fps_clip > self.fps_max:
+            fps_clip = self.fps_max
+        
+        data = {'video': frames, 'caption': caption, 'path': video_path, 'fps': fps_clip, 'frame_stride': frame_stride}
+
+        if self.fps_schedule is not None:
+            self.counter += 1
+        return data
+    
+    def __len__(self):
+        return len(self.metadata)

lvdm/models/autoencoder.py

@@ -0,0 +1,202 @@
+import torch
+import pytorch_lightning as pl
+import torch.nn.functional as F
+import os
+from einops import rearrange
+
+from lvdm.models.modules.autoencoder_modules import Encoder, Decoder
+from lvdm.models.modules.distributions import DiagonalGaussianDistribution
+from lvdm.utils.common_utils import instantiate_from_config
+
+class AutoencoderKL(pl.LightningModule):
+    def __init__(self,
+                 ddconfig,
+                 lossconfig,
+                 embed_dim,
+                 ckpt_path=None,
+                 ignore_keys=[],
+                 image_key="image",
+                 colorize_nlabels=None,
+                 monitor=None,
+                 test=False,
+                 logdir=None,
+                 input_dim=4,
+                 test_args=None,
+                 ):
+        super().__init__()
+        self.image_key = image_key
+        self.encoder = Encoder(**ddconfig)
+        self.decoder = Decoder(**ddconfig)
+        self.loss = instantiate_from_config(lossconfig)
+        assert ddconfig["double_z"]
+        self.quant_conv = torch.nn.Conv2d(2*ddconfig["z_channels"], 2*embed_dim, 1)
+        self.post_quant_conv = torch.nn.Conv2d(embed_dim, ddconfig["z_channels"], 1)
+        self.embed_dim = embed_dim
+        self.input_dim = input_dim
+        self.test = test
+        self.test_args = test_args
+        self.logdir = logdir
+        if colorize_nlabels is not None:
+            assert type(colorize_nlabels)==int
+            self.register_buffer("colorize", torch.randn(3, colorize_nlabels, 1, 1))
+        if monitor is not None:
+            self.monitor = monitor
+        if ckpt_path is not None:
+            self.init_from_ckpt(ckpt_path, ignore_keys=ignore_keys)
+        if self.test:
+            self.init_test()
+    
+    def init_test(self,):
+        self.test = True
+        save_dir = os.path.join(self.logdir, "test")
+        if 'ckpt' in self.test_args:
+            ckpt_name = os.path.basename(self.test_args.ckpt).split('.ckpt')[0] + f'_epoch{self._cur_epoch}'
+            self.root = os.path.join(save_dir, ckpt_name)
+        else:
+            self.root = save_dir
+        if 'test_subdir' in self.test_args:
+            self.root = os.path.join(save_dir, self.test_args.test_subdir)
+
+        self.root_zs = os.path.join(self.root, "zs")
+        self.root_dec = os.path.join(self.root, "reconstructions")
+        self.root_inputs = os.path.join(self.root, "inputs")
+        os.makedirs(self.root, exist_ok=True)
+
+        if self.test_args.save_z:
+            os.makedirs(self.root_zs, exist_ok=True)
+        if self.test_args.save_reconstruction:
+            os.makedirs(self.root_dec, exist_ok=True)
+        if self.test_args.save_input:
+            os.makedirs(self.root_inputs, exist_ok=True)
+        assert(self.test_args is not None)
+        self.test_maximum = getattr(self.test_args, 'test_maximum', None) #1500 # 12000/8
+        self.count = 0
+        self.eval_metrics = {}
+        self.decodes = []
+        self.save_decode_samples = 2048
+        
+    def init_from_ckpt(self, path, ignore_keys=list()):
+        sd = torch.load(path, map_location="cpu")
+        try:
+            self._cur_epoch = sd['epoch']
+            sd = sd["state_dict"]
+        except:
+            self._cur_epoch = 'null'
+        keys = list(sd.keys())
+        for k in keys:
+            for ik in ignore_keys:
+                if k.startswith(ik):
+                    print("Deleting key {} from state_dict.".format(k))
+                    del sd[k]
+        self.load_state_dict(sd, strict=False)
+        # self.load_state_dict(sd, strict=True)
+        print(f"Restored from {path}")
+
+    def encode(self, x, **kwargs):
+        
+        h = self.encoder(x)
+        moments = self.quant_conv(h)
+        posterior = DiagonalGaussianDistribution(moments)
+        return posterior
+
+    def decode(self, z, **kwargs):
+        z = self.post_quant_conv(z)
+        dec = self.decoder(z)
+        return dec
+
+    def forward(self, input, sample_posterior=True):
+        posterior = self.encode(input)
+        if sample_posterior:
+            z = posterior.sample()
+        else:
+            z = posterior.mode()
+        dec = self.decode(z)
+        return dec, posterior
+
+    def get_input(self, batch, k):
+        x = batch[k]
+        # if len(x.shape) == 3:
+        #     x = x[..., None]
+        # if x.dim() == 4:
+        #     x = x.permute(0, 3, 1, 2).to(memory_format=torch.contiguous_format).float()
+        if x.dim() == 5 and self.input_dim == 4:
+            b,c,t,h,w = x.shape
+            self.b = b
+            self.t = t 
+            x = rearrange(x, 'b c t h w -> (b t) c h w')
+
+        return x
+
+    def training_step(self, batch, batch_idx, optimizer_idx):
+        inputs = self.get_input(batch, self.image_key)
+        reconstructions, posterior = self(inputs)
+
+        if optimizer_idx == 0:
+            # train encoder+decoder+logvar
+            aeloss, log_dict_ae = self.loss(inputs, reconstructions, posterior, optimizer_idx, self.global_step,
+                                            last_layer=self.get_last_layer(), split="train")
+            self.log("aeloss", aeloss, prog_bar=True, logger=True, on_step=True, on_epoch=True)
+            self.log_dict(log_dict_ae, prog_bar=False, logger=True, on_step=True, on_epoch=False)
+            return aeloss
+
+        if optimizer_idx == 1:
+            # train the discriminator
+            discloss, log_dict_disc = self.loss(inputs, reconstructions, posterior, optimizer_idx, self.global_step,
+                                                last_layer=self.get_last_layer(), split="train")
+
+            self.log("discloss", discloss, prog_bar=True, logger=True, on_step=True, on_epoch=True)
+            self.log_dict(log_dict_disc, prog_bar=False, logger=True, on_step=True, on_epoch=False)
+            return discloss
+
+    def validation_step(self, batch, batch_idx):
+        inputs = self.get_input(batch, self.image_key)
+        reconstructions, posterior = self(inputs)
+        aeloss, log_dict_ae = self.loss(inputs, reconstructions, posterior, 0, self.global_step,
+                                        last_layer=self.get_last_layer(), split="val")
+
+        discloss, log_dict_disc = self.loss(inputs, reconstructions, posterior, 1, self.global_step,
+                                            last_layer=self.get_last_layer(), split="val")
+
+        self.log("val/rec_loss", log_dict_ae["val/rec_loss"])
+        self.log_dict(log_dict_ae)
+        self.log_dict(log_dict_disc)
+        return self.log_dict
+    
+    def configure_optimizers(self):
+        lr = self.learning_rate
+        opt_ae = torch.optim.Adam(list(self.encoder.parameters())+
+                                  list(self.decoder.parameters())+
+                                  list(self.quant_conv.parameters())+
+                                  list(self.post_quant_conv.parameters()),
+                                  lr=lr, betas=(0.5, 0.9))
+        opt_disc = torch.optim.Adam(self.loss.discriminator.parameters(),
+                                    lr=lr, betas=(0.5, 0.9))
+        return [opt_ae, opt_disc], []
+
+    def get_last_layer(self):
+        return self.decoder.conv_out.weight
+
+    @torch.no_grad()
+    def log_images(self, batch, only_inputs=False, **kwargs):
+        log = dict()
+        x = self.get_input(batch, self.image_key)
+        x = x.to(self.device)
+        if not only_inputs:
+            xrec, posterior = self(x)
+            if x.shape[1] > 3:
+                # colorize with random projection
+                assert xrec.shape[1] > 3
+                x = self.to_rgb(x)
+                xrec = self.to_rgb(xrec)
+            log["samples"] = self.decode(torch.randn_like(posterior.sample()))
+            log["reconstructions"] = xrec
+        log["inputs"] = x
+        return log
+
+    def to_rgb(self, x):
+        assert self.image_key == "segmentation"
+        if not hasattr(self, "colorize"):
+            self.register_buffer("colorize", torch.randn(3, x.shape[1], 1, 1).to(x))
+        x = F.conv2d(x, weight=self.colorize)
+        x = 2.*(x-x.min())/(x.max()-x.min()) - 1.
+        return x

lvdm/models/ddpm3d.py

@@ -0,0 +1,1434 @@
+import os
+import time
+import random
+import itertools
+from functools import partial
+from contextlib import contextmanager
+
+import numpy as np
+from tqdm import tqdm
+from einops import rearrange, repeat
+
+import torch
+import torch.nn as nn
+import pytorch_lightning as pl
+from torchvision.utils import make_grid
+from torch.optim.lr_scheduler import LambdaLR
+from pytorch_lightning.utilities import rank_zero_only
+from lvdm.models.modules.distributions import normal_kl, DiagonalGaussianDistribution
+from lvdm.models.modules.util import make_beta_schedule, extract_into_tensor, noise_like
+from lvdm.models.modules.lora import inject_trainable_lora
+from lvdm.samplers.ddim import DDIMSampler
+from lvdm.utils.common_utils import log_txt_as_img, exists, default, ismap, isimage, mean_flat, count_params, instantiate_from_config, check_istarget
+
+
+def disabled_train(self, mode=True):
+    """Overwrite model.train with this function to make sure train/eval mode
+    does not change anymore."""
+    return self
+
+
+def uniform_on_device(r1, r2, shape, device):
+    return (r1 - r2) * torch.rand(*shape, device=device) + r2
+
+
+def split_video_to_clips(video, clip_length, drop_left=True):
+    video_length = video.shape[2]
+    shape = video.shape
+    if video_length % clip_length != 0 and drop_left:
+        video = video[:, :, :video_length // clip_length * clip_length, :, :]
+        print(f'[split_video_to_clips] Drop frames from {shape} to {video.shape}')
+    nclips = video_length // clip_length
+    clips = rearrange(video, 'b c (nc cl) h w -> (b nc) c cl h w', cl=clip_length, nc=nclips)
+    return clips
+
+def merge_clips_to_videos(clips, bs):
+    nclips = clips.shape[0] // bs
+    video = rearrange(clips, '(b nc) c t h w -> b c (nc t) h w', nc=nclips)
+    return video
+
+class DDPM(pl.LightningModule):
+    # classic DDPM with Gaussian diffusion, in pixel space
+    def __init__(self,
+                 unet_config,
+                 timesteps=1000,
+                 beta_schedule="linear",
+                 loss_type="l2",
+                 ckpt_path=None,
+                 ignore_keys=[],
+                 load_only_unet=False,
+                 monitor="val/loss",
+                 use_ema=True,
+                 first_stage_key="image",
+                 image_size=256,
+                 video_length=None,
+                 channels=3,
+                 log_every_t=100,
+                 clip_denoised=True,
+                 linear_start=1e-4,
+                 linear_end=2e-2,
+                 cosine_s=8e-3,
+                 given_betas=None,
+                 original_elbo_weight=0.,
+                 v_posterior=0.,
+                 l_simple_weight=1.,
+                 conditioning_key=None,
+                 parameterization="eps",
+                 scheduler_config=None,
+                 learn_logvar=False,
+                 logvar_init=0.,
+                 *args, **kwargs
+                 ):
+        super().__init__()
+        assert parameterization in ["eps", "x0"], 'currently only supporting "eps" and "x0"'
+        self.parameterization = parameterization
+        print(f"{self.__class__.__name__}: Running in {self.parameterization}-prediction mode")
+        self.cond_stage_model = None
+        self.clip_denoised = clip_denoised
+        self.log_every_t = log_every_t
+        self.first_stage_key = first_stage_key
+        self.image_size = image_size  # try conv?
+        
+        if isinstance(self.image_size, int):
+            self.image_size = [self.image_size, self.image_size]
+        self.channels = channels
+        self.model = DiffusionWrapper(unet_config, conditioning_key)
+        self.conditioning_key = conditioning_key # also register conditioning_key in diffusion
+        
+        self.temporal_length = video_length if video_length is not None else unet_config.params.temporal_length
+        count_params(self.model, verbose=True)
+        self.use_ema = use_ema
+        
+        self.use_scheduler = scheduler_config is not None
+        if self.use_scheduler:
+            self.scheduler_config = scheduler_config
+
+        self.v_posterior = v_posterior
+        self.original_elbo_weight = original_elbo_weight
+        self.l_simple_weight = l_simple_weight
+
+        if monitor is not None:
+            self.monitor = monitor
+        if ckpt_path is not None:
+            self.init_from_ckpt(ckpt_path, ignore_keys=ignore_keys, only_model=load_only_unet)
+
+        self.register_schedule(given_betas=given_betas, beta_schedule=beta_schedule, timesteps=timesteps,
+                               linear_start=linear_start, linear_end=linear_end, cosine_s=cosine_s)
+
+        self.loss_type = loss_type
+
+        self.learn_logvar = learn_logvar
+        self.logvar = torch.full(fill_value=logvar_init, size=(self.num_timesteps,))
+        if self.learn_logvar:
+            self.logvar = nn.Parameter(self.logvar, requires_grad=True)
+
+    def register_schedule(self, given_betas=None, beta_schedule="linear", timesteps=1000,
+                          linear_start=1e-4, linear_end=2e-2, cosine_s=8e-3):
+        if exists(given_betas):
+            betas = given_betas
+        else:
+            betas = make_beta_schedule(beta_schedule, timesteps, linear_start=linear_start, linear_end=linear_end,
+                                       cosine_s=cosine_s)
+        alphas = 1. - betas
+        alphas_cumprod = np.cumprod(alphas, axis=0)
+        alphas_cumprod_prev = np.append(1., alphas_cumprod[:-1])
+
+        timesteps, = betas.shape
+        self.num_timesteps = int(timesteps)
+        self.linear_start = linear_start
+        self.linear_end = linear_end
+        assert alphas_cumprod.shape[0] == self.num_timesteps, 'alphas have to be defined for each timestep'
+
+        to_torch = partial(torch.tensor, dtype=torch.float32)
+
+        self.register_buffer('betas', to_torch(betas))
+        self.register_buffer('alphas_cumprod', to_torch(alphas_cumprod))
+        self.register_buffer('alphas_cumprod_prev', to_torch(alphas_cumprod_prev))
+
+        # calculations for diffusion q(x_t | x_{t-1}) and others
+        self.register_buffer('sqrt_alphas_cumprod', to_torch(np.sqrt(alphas_cumprod)))
+        self.register_buffer('sqrt_one_minus_alphas_cumprod', to_torch(np.sqrt(1. - alphas_cumprod)))
+        self.register_buffer('log_one_minus_alphas_cumprod', to_torch(np.log(1. - alphas_cumprod)))
+        self.register_buffer('sqrt_recip_alphas_cumprod', to_torch(np.sqrt(1. / alphas_cumprod)))
+        self.register_buffer('sqrt_recipm1_alphas_cumprod', to_torch(np.sqrt(1. / alphas_cumprod - 1)))
+
+        # calculations for posterior q(x_{t-1} | x_t, x_0)
+        posterior_variance = (1 - self.v_posterior) * betas * (1. - alphas_cumprod_prev) / (
+                    1. - alphas_cumprod) + self.v_posterior * betas
+        # above: equal to 1. / (1. / (1. - alpha_cumprod_tm1) + alpha_t / beta_t)
+        self.register_buffer('posterior_variance', to_torch(posterior_variance))
+        # below: log calculation clipped because the posterior variance is 0 at the beginning of the diffusion chain
+        self.register_buffer('posterior_log_variance_clipped', to_torch(np.log(np.maximum(posterior_variance, 1e-20))))
+        self.register_buffer('posterior_mean_coef1', to_torch(
+            betas * np.sqrt(alphas_cumprod_prev) / (1. - alphas_cumprod)))
+        self.register_buffer('posterior_mean_coef2', to_torch(
+            (1. - alphas_cumprod_prev) * np.sqrt(alphas) / (1. - alphas_cumprod)))
+
+        if self.parameterization == "eps":
+            lvlb_weights = self.betas ** 2 / (
+                        2 * self.posterior_variance * to_torch(alphas) * (1 - self.alphas_cumprod))
+        elif self.parameterization == "x0":
+            lvlb_weights = 0.5 * np.sqrt(torch.Tensor(alphas_cumprod)) / (2. * 1 - torch.Tensor(alphas_cumprod))
+        else:
+            raise NotImplementedError("mu not supported")
+        # TODO how to choose this term
+        lvlb_weights[0] = lvlb_weights[1]
+        self.register_buffer('lvlb_weights', lvlb_weights, persistent=False)
+        assert not torch.isnan(self.lvlb_weights).all()
+
+    @contextmanager
+    def ema_scope(self, context=None):
+        if self.use_ema:
+            self.model_ema.store(self.model.parameters())
+            self.model_ema.copy_to(self.model)
+            if context is not None:
+                print(f"{context}: Switched to EMA weights")
+        try:
+            yield None
+        finally:
+            if self.use_ema:
+                self.model_ema.restore(self.model.parameters())
+                if context is not None:
+                    print(f"{context}: Restored training weights")
+
+    def init_from_ckpt(self, path, ignore_keys=list(), only_model=False):
+        sd = torch.load(path, map_location="cpu")
+        if "state_dict" in list(sd.keys()):
+            sd = sd["state_dict"]
+        keys = list(sd.keys())
+        for k in keys:
+            for ik in ignore_keys:
+                if k.startswith(ik) or (ik.startswith('**') and ik.split('**')[-1] in k):
+                    print("Deleting key {} from state_dict.".format(k))
+                    del sd[k]
+        missing, unexpected = self.load_state_dict(sd, strict=False) if not only_model else self.model.load_state_dict(
+            sd, strict=False)
+        print(f"Restored from {path} with {len(missing)} missing and {len(unexpected)} unexpected keys")
+        if len(missing) > 0:
+            print(f"Missing Keys: {missing}")
+        if len(unexpected) > 0:
+            print(f"Unexpected Keys: {unexpected}")
+
+    def q_mean_variance(self, x_start, t):
+        """
+        Get the distribution q(x_t | x_0).
+        :param x_start: the [N x C x ...] tensor of noiseless inputs.
+        :param t: the number of diffusion steps (minus 1). Here, 0 means one step.
+        :return: A tuple (mean, variance, log_variance), all of x_start's shape.
+        """
+        mean = (extract_into_tensor(self.sqrt_alphas_cumprod, t, x_start.shape) * x_start)
+        variance = extract_into_tensor(1.0 - self.alphas_cumprod, t, x_start.shape)
+        log_variance = extract_into_tensor(self.log_one_minus_alphas_cumprod, t, x_start.shape)
+        return mean, variance, log_variance
+
+    def predict_start_from_noise(self, x_t, t, noise):
+        return (
+                extract_into_tensor(self.sqrt_recip_alphas_cumprod, t, x_t.shape) * x_t -
+                extract_into_tensor(self.sqrt_recipm1_alphas_cumprod, t, x_t.shape) * noise
+        )
+
+    def q_posterior(self, x_start, x_t, t):
+        posterior_mean = (
+                extract_into_tensor(self.posterior_mean_coef1, t, x_t.shape) * x_start +
+                extract_into_tensor(self.posterior_mean_coef2, t, x_t.shape) * x_t
+        )
+        posterior_variance = extract_into_tensor(self.posterior_variance, t, x_t.shape)
+        posterior_log_variance_clipped = extract_into_tensor(self.posterior_log_variance_clipped, t, x_t.shape)
+        return posterior_mean, posterior_variance, posterior_log_variance_clipped
+
+    def p_mean_variance(self, x, t, clip_denoised: bool):
+        model_out = self.model(x, t)
+        if self.parameterization == "eps":
+            x_recon = self.predict_start_from_noise(x, t=t, noise=model_out)
+        elif self.parameterization == "x0":
+            x_recon = model_out
+        if clip_denoised:
+            x_recon.clamp_(-1., 1.)
+
+        model_mean, posterior_variance, posterior_log_variance = self.q_posterior(x_start=x_recon, x_t=x, t=t)
+        return model_mean, posterior_variance, posterior_log_variance
+
+    @torch.no_grad()
+    def p_sample(self, x, t, clip_denoised=True, repeat_noise=False):
+        b, *_, device = *x.shape, x.device
+        model_mean, _, model_log_variance = self.p_mean_variance(x=x, t=t, clip_denoised=clip_denoised)
+        noise = noise_like(x.shape, device, repeat_noise)
+        # no noise when t == 0
+        nonzero_mask = (1 - (t == 0).float()).reshape(b, *((1,) * (len(x.shape) - 1)))
+        return model_mean + nonzero_mask * (0.5 * model_log_variance).exp() * noise
+
+    @torch.no_grad()
+    def p_sample_loop(self, shape, return_intermediates=False):
+        device = self.betas.device
+        b = shape[0]
+        img = torch.randn(shape, device=device)
+        intermediates = [img]
+        for i in tqdm(reversed(range(0, self.num_timesteps)), desc='Sampling t', total=self.num_timesteps):
+            img = self.p_sample(img, torch.full((b,), i, device=device, dtype=torch.long),
+                                clip_denoised=self.clip_denoised)
+            if i % self.log_every_t == 0 or i == self.num_timesteps - 1:
+                intermediates.append(img)
+        if return_intermediates:
+            return img, intermediates
+        return img
+
+    @torch.no_grad()
+    def sample(self, batch_size=16, return_intermediates=False):
+        channels = self.channels
+        video_length = self.total_length
+        size = (batch_size, channels, video_length, *self.image_size)
+        return self.p_sample_loop(size,
+                                  return_intermediates=return_intermediates)
+
+    def q_sample(self, x_start, t, noise=None):
+        noise = default(noise, lambda: torch.randn_like(x_start))
+        return (extract_into_tensor(self.sqrt_alphas_cumprod, t, x_start.shape) * x_start +
+                extract_into_tensor(self.sqrt_one_minus_alphas_cumprod, t, x_start.shape) * noise)
+
+    def get_loss(self, pred, target, mean=True, mask=None):
+        if self.loss_type == 'l1':
+            loss = (target - pred).abs()
+            if mean:
+                loss = loss.mean()
+        elif self.loss_type == 'l2':
+            if mean:
+                loss = torch.nn.functional.mse_loss(target, pred)
+            else:
+                loss = torch.nn.functional.mse_loss(target, pred, reduction='none')
+        else:
+            raise NotImplementedError("unknown loss type '{loss_type}'")
+        if mask is not None:
+            assert(mean is False)
+            assert(loss.shape[2:] == mask.shape[2:]) #thw need be the same
+            loss = loss * mask
+        return loss
+
+    def p_losses(self, x_start, t, noise=None):
+        noise = default(noise, lambda: torch.randn_like(x_start))
+        x_noisy = self.q_sample(x_start=x_start, t=t, noise=noise)
+        model_out = self.model(x_noisy, t)
+
+        loss_dict = {}
+        if self.parameterization == "eps":
+            target = noise
+        elif self.parameterization == "x0":
+            target = x_start
+        else:
+            raise NotImplementedError(f"Paramterization {self.parameterization} not yet supported")
+
+        loss = self.get_loss(model_out, target, mean=False).mean(dim=[1, 2, 3, 4])
+
+        log_prefix = 'train' if self.training else 'val'
+
+        loss_dict.update({f'{log_prefix}/loss_simple': loss.mean()})
+        loss_simple = loss.mean() * self.l_simple_weight
+
+        loss_vlb = (self.lvlb_weights[t] * loss).mean()
+        loss_dict.update({f'{log_prefix}/loss_vlb': loss_vlb})
+
+        loss = loss_simple + self.original_elbo_weight * loss_vlb
+
+        loss_dict.update({f'{log_prefix}/loss': loss})
+
+        return loss, loss_dict
+
+    def forward(self, x, *args, **kwargs):
+        t = torch.randint(0, self.num_timesteps, (x.shape[0],), device=self.device).long()
+        return self.p_losses(x, t, *args, **kwargs)
+
+    def get_input(self, batch, k):
+        x = batch[k]
+        x = x.to(memory_format=torch.contiguous_format).float()
+        return x
+
+    def shared_step(self, batch):
+        x = self.get_input(batch, self.first_stage_key)
+        loss, loss_dict = self(x)
+        return loss, loss_dict
+
+    def training_step(self, batch, batch_idx):
+        loss, loss_dict = self.shared_step(batch)
+
+        self.log_dict(loss_dict, prog_bar=True,
+                      logger=True, on_step=True, on_epoch=True)
+
+        self.log("global_step", self.global_step,
+                 prog_bar=True, logger=True, on_step=True, on_epoch=False)
+
+        if self.use_scheduler:
+            lr = self.optimizers().param_groups[0]['lr']
+            self.log('lr_abs', lr, prog_bar=True, logger=True, on_step=True, on_epoch=False)
+        
+        if self.log_time:
+            total_train_time = (time.time() - self.start_time) / (3600*24)
+            avg_step_time = (time.time() - self.start_time) / (self.global_step + 1)
+            left_time_2w_step = (20000-self.global_step -1) * avg_step_time / (3600*24)
+            left_time_5w_step = (50000-self.global_step -1) * avg_step_time / (3600*24)
+            with open(self.logger_path, 'w') as f:
+                print(f'total_train_time = {total_train_time:.1f} days \n\
+                      total_train_step = {self.global_step + 1} steps \n\
+                      left_time_2w_step = {left_time_2w_step:.1f} days \n\
+                      left_time_5w_step = {left_time_5w_step:.1f} days', file=f)
+        return loss
+
+    @torch.no_grad()
+    def validation_step(self, batch, batch_idx):
+        # _, loss_dict_no_ema = self.shared_step_validate(batch)
+        # with self.ema_scope():
+        #     _, loss_dict_ema = self.shared_step_validate(batch)
+        #     loss_dict_ema = {key + '_ema': loss_dict_ema[key] for key in loss_dict_ema}
+        # self.log_dict(loss_dict_no_ema, prog_bar=False, logger=True, on_step=False, on_epoch=True)
+        # self.log_dict(loss_dict_ema, prog_bar=False, logger=True, on_step=False, on_epoch=True)
+        if (self.global_step) % self.val_fvd_interval == 0 and self.global_step != 0:
+            print(f'sample for fvd...')
+            self.log_images_kwargs = {
+                'inpaint': False,
+                'plot_diffusion_rows': False,
+                'plot_progressive_rows': False,
+                'ddim_steps': 50,
+                'unconditional_guidance_scale': 15.0,
+            }
+            torch.cuda.empty_cache()
+            logs = self.log_images(batch, **self.log_images_kwargs)
+            self.log("batch_idx", batch_idx,
+                    prog_bar=True, on_step=True, on_epoch=False)
+            return {'real': logs['inputs'], 'fake': logs['samples'], 'conditioning_txt_img': logs['conditioning_txt_img']}
+    
+    def get_condition_validate(self, prompt):
+        """ text embd
+        """
+        if isinstance(prompt, str):
+            prompt = [prompt]
+        c = self.get_learned_conditioning(prompt)
+        bs = c.shape[0]
+        
+        return c
+    
+    def on_train_batch_end(self, *args, **kwargs):
+        if self.use_ema:
+            self.model_ema(self.model)
+        
+    def training_epoch_end(self, outputs):
+        
+        if (self.current_epoch == 0) or self.resume_new_epoch == 0:
+            self.epoch_start_time = time.time()
+            self.current_epoch_time = 0
+            self.total_time = 0
+            self.epoch_time_avg = 0
+        else:
+            self.current_epoch_time = time.time() - self.epoch_start_time
+            self.epoch_start_time = time.time()
+            self.total_time += self.current_epoch_time
+            self.epoch_time_avg = self.total_time / self.current_epoch
+        self.resume_new_epoch += 1
+        epoch_avg_loss = torch.stack([x['loss'] for x in outputs]).mean()
+        
+        self.log('train/epoch/loss', epoch_avg_loss, logger=True, on_epoch=True)
+        self.log('train/epoch/idx', self.current_epoch, logger=True, on_epoch=True)
+        self.log('train/epoch/time', self.current_epoch_time, logger=True, on_epoch=True)
+        self.log('train/epoch/time_avg', self.epoch_time_avg, logger=True, on_epoch=True)
+        self.log('train/epoch/time_avg_min', self.epoch_time_avg / 60, logger=True, on_epoch=True)
+
+    def _get_rows_from_list(self, samples):
+        n_imgs_per_row = len(samples)
+        denoise_grid = rearrange(samples, 'n b c t h w -> b n c t h w')
+        denoise_grid = rearrange(denoise_grid, 'b n c t h w -> (b n) c t h w')
+        denoise_grid = rearrange(denoise_grid, 'n c t h w -> (n t) c h w')
+        denoise_grid = make_grid(denoise_grid, nrow=n_imgs_per_row)
+        return denoise_grid
+
+    @torch.no_grad()
+    def log_images(self, batch, N=8, n_row=2, sample=True, return_keys=None, 
+                   plot_diffusion_rows=True, plot_denoise_rows=True, **kwargs):
+        """ log images for DDPM """
+        log = dict()
+        x = self.get_input(batch, self.first_stage_key)
+        N = min(x.shape[0], N)
+        n_row = min(x.shape[0], n_row)
+        x = x.to(self.device)[:N]
+        log["inputs"] = x
+        if 'fps' in batch:
+            log['fps'] = batch['fps']
+
+        if plot_diffusion_rows:
+            # get diffusion row
+            diffusion_row = list()
+            x_start = x[:n_row]
+
+            for t in range(self.num_timesteps):
+                if t % self.log_every_t == 0 or t == self.num_timesteps - 1:
+                    t = repeat(torch.tensor([t]), '1 -> b', b=n_row)
+                    t = t.to(self.device).long()
+                    noise = torch.randn_like(x_start)
+                    x_noisy = self.q_sample(x_start=x_start, t=t, noise=noise)
+                    diffusion_row.append(x_noisy)
+
+            log["diffusion_row"] = self._get_rows_from_list(diffusion_row)
+
+        if sample:
+            # get denoise row
+            with self.ema_scope("Plotting"):
+                samples, denoise_row = self.sample(batch_size=N, return_intermediates=True)
+
+            log["samples"] = samples
+            if plot_denoise_rows:
+                log["denoise_row"] = self._get_rows_from_list(denoise_row)
+
+        if return_keys:
+            if np.intersect1d(list(log.keys()), return_keys).shape[0] == 0:
+                return log
+            else:
+                return {key: log[key] for key in return_keys}
+        return log
+
+    def configure_optimizers(self):
+        lr = self.learning_rate
+        params = list(self.model.parameters())
+        if self.learn_logvar:
+            params = params + [self.logvar]
+        opt = torch.optim.AdamW(params, lr=lr)
+        return opt
+
+
+class LatentDiffusion(DDPM):
+    """main class"""
+    def __init__(self,
+                 first_stage_config,
+                 cond_stage_config,
+                 num_timesteps_cond=None,
+                 cond_stage_key="image",
+                 cond_stage_trainable=False,
+                 concat_mode=True,
+                 cond_stage_forward=None,
+                 conditioning_key=None,
+                 scale_factor=1.0,
+                 scale_by_std=False,
+                 encoder_type="2d",
+                 shift_factor=0.0,
+                 split_clips=True,
+                 downfactor_t=None,
+                 clip_length=None,
+                 only_model=False,
+                 lora_args={},
+                 *args, **kwargs):
+        self.num_timesteps_cond = default(num_timesteps_cond, 1)
+        self.scale_by_std = scale_by_std
+        assert self.num_timesteps_cond <= kwargs['timesteps']
+        # for backwards compatibility after implementation of DiffusionWrapper
+        
+        if conditioning_key is None:
+            conditioning_key = 'concat' if concat_mode else 'crossattn'
+        if cond_stage_config == '__is_unconditional__':
+            conditioning_key = None
+        ckpt_path = kwargs.pop("ckpt_path", None)
+        ignore_keys = kwargs.pop("ignore_keys", [])
+        super().__init__(conditioning_key=conditioning_key, *args, **kwargs)
+        self.concat_mode = concat_mode
+        self.cond_stage_trainable = cond_stage_trainable
+        self.cond_stage_key = cond_stage_key
+        try:
+            self.num_downs = len(first_stage_config.params.ddconfig.ch_mult) - 1
+        except:
+            self.num_downs = 0
+        if not scale_by_std:
+            self.scale_factor = scale_factor
+        else:
+            self.register_buffer('scale_factor', torch.tensor(scale_factor))
+        self.instantiate_first_stage(first_stage_config)
+        self.instantiate_cond_stage(cond_stage_config)
+        self.cond_stage_forward = cond_stage_forward
+        self.clip_denoised = False
+        self.bbox_tokenizer = None  
+        self.cond_stage_config = cond_stage_config
+        self.first_stage_config = first_stage_config
+        self.encoder_type = encoder_type
+        assert(encoder_type in ["2d", "3d"])
+        self.restarted_from_ckpt = False
+        self.shift_factor = shift_factor
+        if ckpt_path is not None:
+            self.init_from_ckpt(ckpt_path, ignore_keys, only_model=only_model)
+            self.restarted_from_ckpt = True
+        self.split_clips = split_clips
+        self.downfactor_t = downfactor_t
+        self.clip_length = clip_length
+        # lora related args
+        self.inject_unet = getattr(lora_args, "inject_unet", False)
+        self.inject_clip = getattr(lora_args, "inject_clip", False)
+        self.inject_unet_key_word = getattr(lora_args, "inject_unet_key_word", None)
+        self.inject_clip_key_word = getattr(lora_args, "inject_clip_key_word", None)
+        self.lora_rank = getattr(lora_args, "lora_rank", 4)
+
+    def make_cond_schedule(self, ):
+        self.cond_ids = torch.full(size=(self.num_timesteps,), fill_value=self.num_timesteps - 1, dtype=torch.long)
+        ids = torch.round(torch.linspace(0, self.num_timesteps - 1, self.num_timesteps_cond)).long()
+        self.cond_ids[:self.num_timesteps_cond] = ids
+
+    def inject_lora(self, lora_scale=1.0):
+        if self.inject_unet:
+            self.lora_require_grad_params, self.lora_names = inject_trainable_lora(self.model, self.inject_unet_key_word, 
+                                                                                   r=self.lora_rank,
+                                                                                   scale=lora_scale
+                                                                                   )
+        if self.inject_clip:
+            self.lora_require_grad_params_clip, self.lora_names_clip = inject_trainable_lora(self.cond_stage_model, self.inject_clip_key_word, 
+                                                                                             r=self.lora_rank,
+                                                                                             scale=lora_scale
+                                                                                             )
+
+    @rank_zero_only
+    @torch.no_grad()
+    def on_train_batch_start(self, batch, batch_idx, dataloader_idx=None):
+        # only for very first batch, reset the self.scale_factor
+        if self.scale_by_std and self.current_epoch == 0 and self.global_step == 0 and batch_idx == 0 and not self.restarted_from_ckpt:
+            assert self.scale_factor == 1., 'rather not use custom rescaling and std-rescaling simultaneously'
+            # set rescale weight to 1./std of encodings
+            print("### USING STD-RESCALING ###")
+            x = super().get_input(batch, self.first_stage_key)
+            x = x.to(self.device)
+            encoder_posterior = self.encode_first_stage(x)
+            z = self.get_first_stage_encoding(encoder_posterior).detach()
+            del self.scale_factor
+            self.register_buffer('scale_factor', 1. / z.flatten().std())
+            print(f"setting self.scale_factor to {self.scale_factor}")
+            print("### USING STD-RESCALING ###")
+            print(f"std={z.flatten().std()}")
+
+    def register_schedule(self,
+                          given_betas=None, beta_schedule="linear", timesteps=1000,
+                          linear_start=1e-4, linear_end=2e-2, cosine_s=8e-3):
+        super().register_schedule(given_betas, beta_schedule, timesteps, linear_start, linear_end, cosine_s)
+
+        self.shorten_cond_schedule = self.num_timesteps_cond > 1
+        if self.shorten_cond_schedule:
+            self.make_cond_schedule()
+
+    def instantiate_first_stage(self, config):
+        model = instantiate_from_config(config)
+        self.first_stage_model = model.eval()
+        self.first_stage_model.train = disabled_train
+        for param in self.first_stage_model.parameters():
+            param.requires_grad = False
+
+    def instantiate_cond_stage(self, config):
+        if config is None:
+            self.cond_stage_model = None
+            return
+        if not self.cond_stage_trainable:
+            if config == "__is_first_stage__":
+                print("Using first stage also as cond stage.")
+                self.cond_stage_model = self.first_stage_model
+            elif config == "__is_unconditional__":
+                print(f"Training {self.__class__.__name__} as an unconditional model.")
+                self.cond_stage_model = None
+            else:
+                model = instantiate_from_config(config)
+                self.cond_stage_model = model.eval()
+                self.cond_stage_model.train = disabled_train
+                for param in self.cond_stage_model.parameters():
+                    param.requires_grad = False
+        else:
+            assert config != '__is_first_stage__'
+            assert config != '__is_unconditional__'
+            model = instantiate_from_config(config)
+            self.cond_stage_model = model
+
+
+    def get_first_stage_encoding(self, encoder_posterior, noise=None):
+        if isinstance(encoder_posterior, DiagonalGaussianDistribution):
+            z = encoder_posterior.sample(noise=noise)
+        elif isinstance(encoder_posterior, torch.Tensor):
+            z = encoder_posterior
+        else:
+            raise NotImplementedError(f"encoder_posterior of type '{type(encoder_posterior)}' not yet implemented")
+        z = self.scale_factor * (z + self.shift_factor)
+        return z
+
+
+    def get_learned_conditioning(self, c):
+        if self.cond_stage_forward is None:
+            if hasattr(self.cond_stage_model, 'encode') and callable(self.cond_stage_model.encode):
+                c = self.cond_stage_model.encode(c)
+                if isinstance(c, DiagonalGaussianDistribution):
+                    c = c.mode()
+            else:
+                c = self.cond_stage_model(c)
+        else:
+            assert hasattr(self.cond_stage_model, self.cond_stage_forward)
+            c = getattr(self.cond_stage_model, self.cond_stage_forward)(c)
+        return c
+
+
+    @torch.no_grad()
+    def get_condition(self, batch, x, bs, force_c_encode, k, cond_key, is_imgs=False):
+        is_conditional = self.model.conditioning_key is not None # crossattn
+        if is_conditional:
+            if cond_key is None:
+                cond_key = self.cond_stage_key 
+            
+            # get condition batch of different condition type
+            if cond_key != self.first_stage_key:
+                assert(cond_key in ["caption", "txt"])
+                xc = batch[cond_key]
+            else:
+                xc = x
+            
+            # if static video
+            if self.static_video:
+                xc_ = [c + ' (static)' for c in xc]
+                xc = xc_
+            
+            # get learned condition.
+            # can directly skip it: c = xc
+            if self.cond_stage_config is not None and (not self.cond_stage_trainable or force_c_encode):
+                if isinstance(xc, torch.Tensor):
+                    xc = xc.to(self.device)
+                c = self.get_learned_conditioning(xc)
+            else:
+                c = xc
+
+            if self.classfier_free_guidance:
+                if cond_key in ['caption', "txt"] and self.uncond_type == 'empty_seq':
+                    for i, ci in enumerate(c):
+                        if random.random() < self.prob:
+                            c[i] = ""
+                elif cond_key == 'class_label' and self.uncond_type == 'zero_embed':
+                    pass
+                elif cond_key == 'class_label' and self.uncond_type == 'learned_embed':
+                    import pdb;pdb.set_trace()
+                    for i, ci in enumerate(c):
+                        if random.random() < self.prob:
+                            c[i]['class_label'] = self.n_classes
+                    
+                else:
+                    raise NotImplementedError
+                
+            if self.zero_cond_embed:
+                import pdb;pdb.set_trace()
+                c = torch.zeros_like(c)
+
+            # process c
+            if bs is not None:
+                if (is_imgs and not self.static_video):
+                    c = c[:bs*self.temporal_length] # each random img (in T axis) has a corresponding prompt
+                else:
+                    c = c[:bs]
+
+        else:
+            c = None
+            xc = None
+            
+        return c, xc
+
+    @torch.no_grad()
+    def get_input(self, batch, k, return_first_stage_outputs=False, force_c_encode=False,
+                  cond_key=None, return_original_cond=False, bs=None, mask_temporal=False):
+        """ Get input in LDM 
+        """
+        # get input imgaes
+        x = super().get_input(batch, k) # k = first_stage_key=image
+        is_imgs = True if k == 'jpg' else False
+        if is_imgs:
+            if self.static_video:
+                # repeat single img to a static video
+                x = x.unsqueeze(2) # bchw -> bc1hw
+                x = x.repeat(1,1,self.temporal_length,1,1) # bc1hw -> bcthw
+            else:
+                # rearrange to videos with T random img
+                bs_load = x.shape[0] // self.temporal_length
+                x = x[:bs_load*self.temporal_length, ...]
+                x = rearrange(x, '(b t) c h w -> b c t h w', t=self.temporal_length, b=bs_load)
+
+        if bs is not None:
+            x = x[:bs]
+        
+        x = x.to(self.device)
+        x_ori = x
+        
+        b, _, t, h, w = x.shape
+        
+        # encode video frames x to z via a 2D encoder
+        x = rearrange(x, 'b c t h w -> (b t) c h w')
+        encoder_posterior = self.encode_first_stage(x, mask_temporal)
+        z = self.get_first_stage_encoding(encoder_posterior).detach()
+        z = rearrange(z, '(b t) c h w -> b c t h w', b=b, t=t)
+        
+        
+        c, xc = self.get_condition(batch, x, bs, force_c_encode, k, cond_key, is_imgs)
+        out = [z, c]
+        
+        if return_first_stage_outputs:
+            xrec = self.decode_first_stage(z, mask_temporal=mask_temporal)
+            out.extend([x_ori, xrec])
+        if return_original_cond:
+            if isinstance(xc, torch.Tensor) and xc.dim() == 4:
+                xc = rearrange(xc, '(b t) c h w -> b c t h w', b=b, t=t)
+            out.append(xc)
+        
+        return out
+    
+    @torch.no_grad()
+    def decode(self, z, **kwargs,):
+        z = 1. / self.scale_factor * z - self.shift_factor
+        results = self.first_stage_model.decode(z,**kwargs)
+        return results
+    
+    @torch.no_grad()
+    def decode_first_stage_2DAE(self, z, decode_bs=16, return_cpu=True, **kwargs):
+        b, _, t, _, _ = z.shape
+        z = rearrange(z, 'b c t h w -> (b t) c h w')
+        if decode_bs is None:
+            results = self.decode(z, **kwargs)
+        else:
+            z = torch.split(z, decode_bs, dim=0)
+            if return_cpu:
+                results = torch.cat([self.decode(z_, **kwargs).cpu() for z_ in z], dim=0)
+            else:
+                results = torch.cat([self.decode(z_, **kwargs) for z_ in z], dim=0)
+        results = rearrange(results, '(b t) c h w -> b c t h w', b=b,t=t).contiguous()
+        return results
+
+    @torch.no_grad()
+    def decode_first_stage(self, z, decode_bs=16, return_cpu=True, **kwargs):
+        assert(self.encoder_type == "2d" and z.dim() == 5)
+        return self.decode_first_stage_2DAE(z, decode_bs=decode_bs, return_cpu=return_cpu, **kwargs)
+
+    @torch.no_grad()
+    def encode_first_stage_2DAE(self, x, encode_bs=16):
+        b, _, t, _, _ = x.shape
+        x = rearrange(x, 'b c t h w -> (b t) c h w')
+        if encode_bs is None:
+            results = self.first_stage_model.encode(x)
+        else:
+            x = torch.split(x, encode_bs, dim=0)
+            zs = []
+            for x_ in x:
+                encoder_posterior = self.first_stage_model.encode(x_)
+                z = self.get_first_stage_encoding(encoder_posterior).detach()
+                zs.append(z)
+            results = torch.cat(zs, dim=0)
+        results = rearrange(results, '(b t) c h w -> b c t h w', b=b,t=t)
+        return results
+    
+    @torch.no_grad()
+    def encode_first_stage(self, x):
+        assert(self.encoder_type == "2d" and x.dim() == 5)
+        b, _, t, _, _ = x.shape
+        x = rearrange(x, 'b c t h w -> (b t) c h w')
+        results = self.first_stage_model.encode(x)
+        results = rearrange(results, '(b t) c h w -> b c t h w', b=b,t=t)
+        return results
+
+    def shared_step(self, batch, **kwargs):
+        """ shared step of LDM.
+        If learned condition, c is raw condition (e.g. text)
+        Encoding condition is performed in below forward function.
+        """
+        x, c = self.get_input(batch, self.first_stage_key)
+        loss = self(x, c)
+        return loss
+    
+    def forward(self, x, c, *args, **kwargs):
+        start_t = getattr(self, "start_t", 0)
+        end_t = getattr(self, "end_t", self.num_timesteps)
+        t = torch.randint(start_t, end_t, (x.shape[0],), device=self.device).long()
+        
+        if self.model.conditioning_key is not None:
+            assert c is not None
+            if self.cond_stage_trainable:
+                c = self.get_learned_conditioning(c)
+            if self.classfier_free_guidance and self.uncond_type == 'zero_embed':
+                for i, ci in enumerate(c):
+                    if random.random() < self.prob:
+                        c[i] = torch.zeros_like(c[i])
+            if self.shorten_cond_schedule:  # TODO: drop this option
+                tc = self.cond_ids[t].to(self.device)
+                c = self.q_sample(x_start=c, t=tc, noise=torch.randn_like(c.float()))
+        
+        return self.p_losses(x, c, t, *args, **kwargs)
+
+    def apply_model(self, x_noisy, t, cond, return_ids=False, **kwargs):
+
+        if isinstance(cond, dict):
+            # hybrid case, cond is exptected to be a dict
+            pass
+        else:
+            if not isinstance(cond, list):
+                cond = [cond]
+            key = 'c_concat' if self.model.conditioning_key == 'concat' else 'c_crossattn'
+            cond = {key: cond}
+
+        x_recon = self.model(x_noisy, t, **cond, **kwargs)
+
+        if isinstance(x_recon, tuple) and not return_ids:
+            return x_recon[0]
+        else:
+            return x_recon
+
+    def _predict_eps_from_xstart(self, x_t, t, pred_xstart):
+        return (extract_into_tensor(self.sqrt_recip_alphas_cumprod, t, x_t.shape) * x_t - pred_xstart) / \
+               extract_into_tensor(self.sqrt_recipm1_alphas_cumprod, t, x_t.shape)
+
+    def _prior_bpd(self, x_start):
+        """
+        Get the prior KL term for the variational lower-bound, measured in
+        bits-per-dim.
+        This term can't be optimized, as it only depends on the encoder.
+        :param x_start: the [N x C x ...] tensor of inputs.
+        :return: a batch of [N] KL values (in bits), one per batch element.
+        """
+        batch_size = x_start.shape[0]
+        t = torch.tensor([self.num_timesteps - 1] * batch_size, device=x_start.device)
+        qt_mean, _, qt_log_variance = self.q_mean_variance(x_start, t)
+        kl_prior = normal_kl(mean1=qt_mean, logvar1=qt_log_variance, mean2=0.0, logvar2=0.0)
+        return mean_flat(kl_prior) / np.log(2.0)
+
+    def p_losses(self, x_start, cond, t, noise=None, skip_qsample=False, x_noisy=None, cond_mask=None, **kwargs,):
+        if not skip_qsample:
+            noise = default(noise, lambda: torch.randn_like(x_start))
+            x_noisy = self.q_sample(x_start=x_start, t=t, noise=noise)
+        else:
+            assert(x_noisy is not None)
+            assert(noise is not None)
+        model_output = self.apply_model(x_noisy, t, cond, **kwargs)
+
+        loss_dict = {}
+        prefix = 'train' if self.training else 'val'
+
+        if self.parameterization == "x0":
+            target = x_start
+        elif self.parameterization == "eps":
+            target = noise
+        else:
+            raise NotImplementedError()
+        
+        loss_simple = self.get_loss(model_output, target, mean=False).mean([1, 2, 3, 4])
+        loss_dict.update({f'{prefix}/loss_simple': loss_simple.mean()})
+        if self.logvar.device != self.device:
+            self.logvar = self.logvar.to(self.device)
+        logvar_t = self.logvar[t]
+        loss = loss_simple / torch.exp(logvar_t) + logvar_t
+        if self.learn_logvar:
+            loss_dict.update({f'{prefix}/loss_gamma': loss.mean()})
+            loss_dict.update({'logvar': self.logvar.data.mean()})
+
+        loss = self.l_simple_weight * loss.mean()
+
+        loss_vlb = self.get_loss(model_output, target, mean=False).mean(dim=(1, 2, 3, 4))
+        loss_vlb = (self.lvlb_weights[t] * loss_vlb).mean()
+        loss_dict.update({f'{prefix}/loss_vlb': loss_vlb})
+        loss += (self.original_elbo_weight * loss_vlb)
+        loss_dict.update({f'{prefix}/loss': loss})
+
+        return loss, loss_dict
+
+    def p_mean_variance(self, x, c, t, clip_denoised: bool, return_codebook_ids=False, quantize_denoised=False,
+                        return_x0=False, score_corrector=None, corrector_kwargs=None, 
+                        unconditional_guidance_scale=1., unconditional_conditioning=None,
+                        uc_type=None,):
+        t_in = t
+        if unconditional_conditioning is None or unconditional_guidance_scale == 1.:
+            model_out = self.apply_model(x, t_in, c, return_ids=return_codebook_ids)
+        else:
+            # with unconditional condition
+            if isinstance(c, torch.Tensor):
+                x_in = torch.cat([x] * 2)
+                t_in = torch.cat([t] * 2)
+                c_in = torch.cat([unconditional_conditioning, c])
+                model_out_uncond, model_out = self.apply_model(x_in, t_in, c_in, return_ids=return_codebook_ids).chunk(2)
+            elif isinstance(c, dict):
+                model_out = self.apply_model(x, t, c, return_ids=return_codebook_ids)
+                model_out_uncond = self.apply_model(x, t, unconditional_conditioning, return_ids=return_codebook_ids)
+            else:
+                raise NotImplementedError
+            if uc_type is None:
+                model_out = model_out_uncond + unconditional_guidance_scale * (model_out - model_out_uncond)
+            else:
+                if uc_type == 'cfg_original':
+                    model_out = model_out + unconditional_guidance_scale * (model_out - model_out_uncond)
+                elif uc_type == 'cfg_ours':
+                    model_out = model_out + unconditional_guidance_scale * (model_out_uncond - model_out)
+                else:
+                    raise NotImplementedError
+
+        if score_corrector is not None:
+            assert self.parameterization == "eps"
+            model_out = score_corrector.modify_score(self, model_out, x, t, c, **corrector_kwargs)
+
+        if return_codebook_ids:
+            model_out, logits = model_out
+
+        if self.parameterization == "eps":
+            x_recon = self.predict_start_from_noise(x, t=t, noise=model_out)
+        elif self.parameterization == "x0":
+            x_recon = model_out
+        else:
+            raise NotImplementedError()
+
+        if clip_denoised:
+            x_recon.clamp_(-1., 1.)
+        if quantize_denoised:
+            x_recon, _, [_, _, indices] = self.first_stage_model.quantize(x_recon)
+        model_mean, posterior_variance, posterior_log_variance = self.q_posterior(x_start=x_recon, x_t=x, t=t)
+        if return_codebook_ids:
+            return model_mean, posterior_variance, posterior_log_variance, logits
+        elif return_x0:
+            return model_mean, posterior_variance, posterior_log_variance, x_recon
+        else:
+            return model_mean, posterior_variance, posterior_log_variance
+
+    @torch.no_grad()
+    def p_sample(self, x, c, t, clip_denoised=False, repeat_noise=False,
+                 return_codebook_ids=False, quantize_denoised=False, return_x0=False,
+                 temperature=1., noise_dropout=0., score_corrector=None, corrector_kwargs=None,
+                 unconditional_guidance_scale=1., unconditional_conditioning=None,
+                 uc_type=None,):
+        b, *_, device = *x.shape, x.device
+        outputs = self.p_mean_variance(x=x, c=c, t=t, clip_denoised=clip_denoised,
+                                       return_codebook_ids=return_codebook_ids,
+                                       quantize_denoised=quantize_denoised,
+                                       return_x0=return_x0,
+                                       score_corrector=score_corrector, corrector_kwargs=corrector_kwargs,
+                                       unconditional_guidance_scale=unconditional_guidance_scale, 
+                                       unconditional_conditioning=unconditional_conditioning,
+                                       uc_type=uc_type,)
+        if return_codebook_ids:
+            raise DeprecationWarning("Support dropped.")
+        elif return_x0:
+            model_mean, _, model_log_variance, x0 = outputs
+        else:
+            model_mean, _, model_log_variance = outputs
+
+        noise = noise_like(x.shape, device, repeat_noise) * temperature
+        if noise_dropout > 0.:
+            noise = torch.nn.functional.dropout(noise, p=noise_dropout)
+        
+        nonzero_mask = (1 - (t == 0).float()).reshape(b, *((1,) * (len(x.shape) - 1)))
+
+        if return_codebook_ids:
+            return model_mean + nonzero_mask * (0.5 * model_log_variance).exp() * noise, logits.argmax(dim=1)
+        if return_x0:
+            return model_mean + nonzero_mask * (0.5 * model_log_variance).exp() * noise, x0
+        else:
+            return model_mean + nonzero_mask * (0.5 * model_log_variance).exp() * noise
+
+    @torch.no_grad()
+    def progressive_denoising(self, cond, shape, verbose=True, callback=None, quantize_denoised=False,
+                              img_callback=None, mask=None, x0=None, temperature=1., noise_dropout=0.,
+                              score_corrector=None, corrector_kwargs=None, batch_size=None, x_T=None, start_T=None,
+                              log_every_t=None):
+        if not log_every_t:
+            log_every_t = self.log_every_t
+        timesteps = self.num_timesteps
+        if batch_size is not None:
+            b = batch_size if batch_size is not None else shape[0]
+            shape = [batch_size] + list(shape)
+        else:
+            b = batch_size = shape[0]
+        if x_T is None:
+            img = torch.randn(shape, device=self.device)
+        else:
+            img = x_T
+        intermediates = []
+        if cond is not None:
+            if isinstance(cond, dict):
+                cond = {key: cond[key][:batch_size] if not isinstance(cond[key], list) else
+                list(map(lambda x: x[:batch_size], cond[key])) for key in cond}
+            else:
+                cond = [c[:batch_size] for c in cond] if isinstance(cond, list) else cond[:batch_size]
+
+        if start_T is not None:
+            timesteps = min(timesteps, start_T)
+        iterator = tqdm(reversed(range(0, timesteps)), desc='Progressive Generation',
+                        total=timesteps) if verbose else reversed(
+            range(0, timesteps))
+        if type(temperature) == float:
+            temperature = [temperature] * timesteps
+
+        for i in iterator:
+            ts = torch.full((b,), i, device=self.device, dtype=torch.long)
+            if self.shorten_cond_schedule:
+                assert self.model.conditioning_key != 'hybrid'
+                tc = self.cond_ids[ts].to(cond.device)
+                cond = self.q_sample(x_start=cond, t=tc, noise=torch.randn_like(cond))
+
+            img, x0_partial = self.p_sample(img, cond, ts,
+                                            clip_denoised=self.clip_denoised,
+                                            quantize_denoised=quantize_denoised, return_x0=True,
+                                            temperature=temperature[i], noise_dropout=noise_dropout,
+                                            score_corrector=score_corrector, corrector_kwargs=corrector_kwargs)
+            if mask is not None:
+                assert x0 is not None
+                img_orig = self.q_sample(x0, ts)
+                img = img_orig * mask + (1. - mask) * img
+
+            if i % log_every_t == 0 or i == timesteps - 1:
+                intermediates.append(x0_partial)
+            if callback: callback(i)
+            if img_callback: img_callback(img, i)
+        return img, intermediates
+
+    @torch.no_grad()
+    def p_sample_loop(self, cond, shape, return_intermediates=False,
+                      x_T=None, verbose=True, callback=None, timesteps=None, quantize_denoised=False,
+                      mask=None, x0=None, img_callback=None, start_T=None,
+                      log_every_t=None,
+                      unconditional_guidance_scale=1., unconditional_conditioning=None,
+                      uc_type=None,):
+
+        if not log_every_t:
+            log_every_t = self.log_every_t
+        device = self.betas.device
+        b = shape[0]
+        
+        # sample an initial noise
+        if x_T is None:
+            img = torch.randn(shape, device=device)
+        else:
+            img = x_T
+        
+        intermediates = [img]
+        if timesteps is None:
+            timesteps = self.num_timesteps
+
+        if start_T is not None:
+            timesteps = min(timesteps, start_T)
+        iterator = tqdm(reversed(range(0, timesteps)), desc='Sampling t', total=timesteps) if verbose else reversed(
+            range(0, timesteps))
+
+        if mask is not None:
+            assert x0 is not None
+            assert x0.shape[2:3] == mask.shape[2:3]  # spatial size has to match
+
+        for i in iterator:
+            ts = torch.full((b,), i, device=device, dtype=torch.long)
+            if self.shorten_cond_schedule:
+                assert self.model.conditioning_key != 'hybrid'
+                tc = self.cond_ids[ts].to(cond.device)
+                cond = self.q_sample(x_start=cond, t=tc, noise=torch.randn_like(cond))
+
+            img = self.p_sample(img, cond, ts,
+                                clip_denoised=self.clip_denoised,
+                                quantize_denoised=quantize_denoised,
+                                unconditional_guidance_scale=unconditional_guidance_scale,
+                                unconditional_conditioning=unconditional_conditioning,
+                                uc_type=uc_type)
+            if mask is not None:
+                img_orig = self.q_sample(x0, ts)
+                img = img_orig * mask + (1. - mask) * img
+
+            if i % log_every_t == 0 or i == timesteps - 1:
+                intermediates.append(img)
+            if callback: callback(i)
+            if img_callback: img_callback(img, i)
+
+        if return_intermediates:
+            return img, intermediates
+        return img
+
+    @torch.no_grad()
+    def sample(self, cond, batch_size=16, return_intermediates=False, x_T=None,
+               verbose=True, timesteps=None, quantize_denoised=False,
+               mask=None, x0=None, shape=None, **kwargs):
+        if shape is None:
+            shape = (batch_size, self.channels, self.total_length, *self.image_size)
+        if cond is not None:
+            if isinstance(cond, dict):
+                cond = {key: cond[key][:batch_size] if not isinstance(cond[key], list) else
+                list(map(lambda x: x[:batch_size], cond[key])) for key in cond}
+            else:
+                cond = [c[:batch_size] for c in cond] if isinstance(cond, list) else cond[:batch_size]
+        return self.p_sample_loop(cond,
+                                  shape,
+                                  return_intermediates=return_intermediates, x_T=x_T,
+                                  verbose=verbose, timesteps=timesteps, quantize_denoised=quantize_denoised,
+                                  mask=mask, x0=x0,)
+
+    @torch.no_grad()
+    def sample_log(self,cond,batch_size,ddim, ddim_steps,**kwargs):
+
+        if ddim:
+            ddim_sampler = DDIMSampler(self)
+            shape = (self.channels, self.total_length, *self.image_size)
+            samples, intermediates =ddim_sampler.sample(ddim_steps,batch_size,
+                                                        shape,cond,verbose=False, **kwargs)
+
+        else:
+            samples, intermediates = self.sample(cond=cond, batch_size=batch_size,
+                                                 return_intermediates=True, **kwargs)
+
+        return samples, intermediates
+    
+    @torch.no_grad()
+    def log_condition(self, log, batch, xc, x, c, cond_stage_key=None):
+        """ 
+        xc: oringinal condition before enconding. 
+        c: condition after encoding.
+        """
+        if x.dim() == 5:
+            txt_img_shape = [x.shape[3], x.shape[4]]
+        elif x.dim() == 4:
+            txt_img_shape = [x.shape[2], x.shape[3]]
+        else:
+            raise ValueError
+        if self.model.conditioning_key is not None: #concat-time-mask
+            if hasattr(self.cond_stage_model, "decode"):
+                xc = self.cond_stage_model.decode(c)
+                log["conditioning"] = xc
+            elif cond_stage_key in ["caption", "txt"]:
+                log["conditioning_txt_img"] = log_txt_as_img(txt_img_shape, batch[cond_stage_key], size=x.shape[3]//25)
+                log["conditioning_txt"] = batch[cond_stage_key]
+            elif cond_stage_key == 'class_label':
+                try:
+                    xc = log_txt_as_img(txt_img_shape, batch["human_label"], size=x.shape[3]//25)
+                except:
+                    xc = log_txt_as_img(txt_img_shape, batch["class_name"], size=x.shape[3]//25)
+                log['conditioning'] = xc
+            elif isimage(xc):
+                log["conditioning"] = xc
+            if ismap(xc):
+                log["original_conditioning"] = self.to_rgb(xc)
+            if isinstance(c, dict) and 'mask' in c:
+                log['mask'] =self.mask_to_rgb(c['mask'])
+        return log
+    
+    @torch.no_grad()
+    def log_images(self, batch, N=8, n_row=4, sample=True, ddim_steps=200, ddim_eta=1., unconditional_guidance_scale=1.0, 
+                   first_stage_key2=None, cond_key2=None,
+                   c=None, 
+                   **kwargs):
+        """ log images for LatentDiffusion """
+        use_ddim = ddim_steps is not None
+        is_imgs = first_stage_key2 is not None
+        if is_imgs:
+            assert(cond_key2 is not None)
+        log = dict()
+
+        # get input
+        z, c, x, xrec, xc = self.get_input(batch, 
+                                           k=self.first_stage_key if first_stage_key2 is None else first_stage_key2,
+                                           return_first_stage_outputs=True,
+                                           force_c_encode=True,
+                                           return_original_cond=True,
+                                           bs=N,
+                                           cond_key=cond_key2 if cond_key2 is not None else None,
+                                           )
+        
+        N_ori = N
+        N = min(z.shape[0], N)
+        n_row = min(x.shape[0], n_row)
+
+        if unconditional_guidance_scale != 1.0:
+            prompts = N * self.temporal_length * [""] if (is_imgs and not self.static_video) else N * [""]
+            uc = self.get_condition_validate(prompts)
+            
+        else:
+            uc = None
+
+        log["inputs"] = x
+        log["reconstruction"] = xrec
+        log = self.log_condition(log, batch, xc, x, c, 
+                                 cond_stage_key=self.cond_stage_key if cond_key2 is None else cond_key2
+        )
+        
+        if sample:
+            with self.ema_scope("Plotting"):
+                samples, z_denoise_row = self.sample_log(cond=c,batch_size=N,ddim=use_ddim,
+                                                         ddim_steps=ddim_steps,eta=ddim_eta,
+                                                         temporal_length=self.video_length,
+                                                         unconditional_guidance_scale=unconditional_guidance_scale,
+                                                         unconditional_conditioning=uc, **kwargs,
+                                                         )
+            # decode samples
+            x_samples = self.decode_first_stage(samples)
+            log["samples"] = x_samples
+        return log
+
+    def configure_optimizers(self):
+        """ configure_optimizers for LatentDiffusion """
+        lr = self.learning_rate
+        
+        # --------------------------------------------------------------------------------
+        # set parameters
+        if hasattr(self, "only_optimize_empty_parameters") and self.only_optimize_empty_parameters:
+            print("[INFO] Optimize only empty parameters!")
+            assert(hasattr(self, "empty_paras"))
+            params = [p for n, p in self.model.named_parameters() if n in self.empty_paras]
+        elif hasattr(self, "only_optimize_pretrained_parameters") and self.only_optimize_pretrained_parameters:
+            print("[INFO] Optimize only pretrained parameters!")
+            assert(hasattr(self, "empty_paras"))
+            params = [p for n, p in self.model.named_parameters() if n not in self.empty_paras]
+            assert(len(params) != 0)
+        elif getattr(self, "optimize_empty_and_spatialattn", False):
+            print("[INFO] Optimize empty parameters + spatial transformer!")
+            assert(hasattr(self, "empty_paras"))
+            empty_paras = [p for n, p in self.model.named_parameters() if n in self.empty_paras]
+            SA_list = [".attn1.", ".attn2.", ".ff.", ".norm1.", ".norm2.", ".norm3."]
+            SA_params = [p for n, p in self.model.named_parameters() if check_istarget(n, SA_list)]
+            if getattr(self, "spatial_lr_decay", False):
+                params = [
+                    {"params": empty_paras},
+                    {"params": SA_params, "lr": lr * self.spatial_lr_decay}
+                ]
+            else:
+                params = empty_paras + SA_params
+        else:
+            # optimize whole denoiser
+            if hasattr(self, "spatial_lr_decay") and self.spatial_lr_decay:
+                print("[INFO] Optimize the whole net with different lr!")
+                print(f"[INFO] {lr} for empty paras, {lr * self.spatial_lr_decay} for pretrained paras!")
+                empty_paras = [p for n, p in self.model.named_parameters() if n in self.empty_paras]
+                # assert(len(empty_paras) == len(self.empty_paras)) # self.empty_paras:cond_stage_model.embedding.weight not in diffusion model params
+                pretrained_paras = [p for n, p in self.model.named_parameters() if n not in self.empty_paras]
+                params = [
+                    {"params": empty_paras},
+                    {"params": pretrained_paras, "lr": lr * self.spatial_lr_decay}
+                ]
+                print(f"[INFO] Empty paras: {len(empty_paras)}, Pretrained paras: {len(pretrained_paras)}")
+
+            else:
+                params = list(self.model.parameters())
+        
+        if hasattr(self, "generator_trainable") and not self.generator_trainable:
+            # fix unet denoiser
+            params = list()
+
+        if self.inject_unet:
+            params = itertools.chain(*self.lora_require_grad_params)
+                
+        if self.inject_clip:
+            if self.inject_unet:
+                params = list(params)+list(itertools.chain(*self.lora_require_grad_params_clip))
+            else:
+                params = itertools.chain(*self.lora_require_grad_params_clip)
+            
+
+        # append paras
+        # ------------------------------------------------------------------
+        def add_cond_model(cond_model, params):
+            if isinstance(params[0], dict):
+                # parameter groups
+                params.append({"params": list(cond_model.parameters())})
+            else:
+                # parameter list: [torch.nn.parameter.Parameter]
+                params = params + list(cond_model.parameters())
+            return params
+        # ------------------------------------------------------------------
+        
+        if self.cond_stage_trainable:
+            # print(f"{self.__class__.__name__}: Also optimizing conditioner params!")
+            params = add_cond_model(self.cond_stage_model, params)
+        
+        if self.learn_logvar:
+            print('Diffusion model optimizing logvar')
+            if isinstance(params[0], dict):
+                params.append({"params": [self.logvar]})
+            else:
+                params.append(self.logvar)
+        
+        # --------------------------------------------------------------------------------
+        opt = torch.optim.AdamW(params, lr=lr)
+        
+        # lr scheduler
+        if self.use_scheduler:
+            assert 'target' in self.scheduler_config
+            scheduler = instantiate_from_config(self.scheduler_config)
+
+            print("Setting up LambdaLR scheduler...")
+            scheduler = [
+                {
+                    'scheduler': LambdaLR(opt, lr_lambda=scheduler.schedule),
+                    'interval': 'step',
+                    'frequency': 1
+                }]
+            return [opt], scheduler
+        
+        return opt
+    
+    @torch.no_grad()
+    def to_rgb(self, x):
+        x = x.float()
+        if not hasattr(self, "colorize"):
+            self.colorize = torch.randn(3, x.shape[1], 1, 1).to(x)
+        x = nn.functional.conv2d(x, weight=self.colorize)
+        x = 2. * (x - x.min()) / (x.max() - x.min()) - 1.
+        return x
+
+    @torch.no_grad()
+    def mask_to_rgb(self, x):
+        x = x * 255
+        x = x.int()
+        return x
+
+class DiffusionWrapper(pl.LightningModule):
+    def __init__(self, diff_model_config, conditioning_key):
+        super().__init__()
+        self.diffusion_model = instantiate_from_config(diff_model_config)
+        print('Successfully initialize the diffusion model !')
+        self.conditioning_key = conditioning_key
+        # assert self.conditioning_key in [None, 'concat', 'crossattn', 'hybrid', 'adm', 'resblockcond', 'hybrid-adm', 'hybrid-time']
+
+    def forward(self, x, t, c_concat: list = None, c_crossattn: list = None,
+                c_adm=None, s=None, mask=None, **kwargs):
+        # temporal_context = fps is foNone
+        if self.conditioning_key is None:
+            out = self.diffusion_model(x, t, **kwargs)
+        elif self.conditioning_key == 'concat':
+            xc = torch.cat([x] + c_concat, dim=1)
+            out = self.diffusion_model(xc, t, **kwargs)
+        elif self.conditioning_key == 'crossattn':
+            cc = torch.cat(c_crossattn, 1)
+            out = self.diffusion_model(x, t, context=cc, **kwargs)
+        elif self.conditioning_key == 'hybrid':
+            xc = torch.cat([x] + c_concat, dim=1)
+            cc = torch.cat(c_crossattn, 1)
+            out = self.diffusion_model(xc, t, context=cc, **kwargs)
+        elif self.conditioning_key == 'resblockcond':
+            cc = c_crossattn[0]
+            out = self.diffusion_model(x, t, context=cc, **kwargs)
+        elif self.conditioning_key == 'adm':
+            cc = c_crossattn[0]
+            out = self.diffusion_model(x, t, y=cc, **kwargs)
+        elif self.conditioning_key == 'hybrid-adm':
+            assert c_adm is not None
+            xc = torch.cat([x] + c_concat, dim=1)
+            cc = torch.cat(c_crossattn, 1)
+            out = self.diffusion_model(xc, t, context=cc, y=c_adm, **kwargs)
+        elif self.conditioning_key == 'hybrid-time':
+            assert s is not None
+            xc = torch.cat([x] + c_concat, dim=1)
+            cc = torch.cat(c_crossattn, 1)
+            out = self.diffusion_model(xc, t, context=cc, s=s, **kwargs)
+        elif self.conditioning_key == 'concat-time-mask':
+            # assert s is not None
+            # print('x & mask:',x.shape,c_concat[0].shape)
+            xc = torch.cat([x] + c_concat, dim=1)
+            out = self.diffusion_model(xc, t, context=None, s=s, mask=mask, **kwargs)
+        elif self.conditioning_key == 'concat-adm-mask':
+            # assert s is not None
+            # print('x & mask:',x.shape,c_concat[0].shape)
+            if c_concat is not None:
+                xc = torch.cat([x] + c_concat, dim=1)
+            else:
+                xc = x
+            out = self.diffusion_model(xc, t, context=None, y=s, mask=mask, **kwargs)
+        elif self.conditioning_key == 'crossattn-adm':
+            cc = torch.cat(c_crossattn, 1)
+            out = self.diffusion_model(x, t, context=cc, y=s, **kwargs)
+        elif self.conditioning_key == 'hybrid-adm-mask':
+            cc = torch.cat(c_crossattn, 1)
+            if c_concat is not None:
+                xc = torch.cat([x] + c_concat, dim=1)
+            else:
+                xc = x
+            out = self.diffusion_model(xc, t, context=cc, y=s, mask=mask, **kwargs)
+        elif self.conditioning_key == 'hybrid-time-adm': # adm means y, e.g., class index
+            # assert s is not None
+            assert c_adm is not None
+            xc = torch.cat([x] + c_concat, dim=1)
+            cc = torch.cat(c_crossattn, 1)
+            out = self.diffusion_model(xc, t, context=cc, s=s, y=c_adm, **kwargs)
+        else:
+            raise NotImplementedError()
+
+        return out
+

lvdm/models/modules/attention_temporal.py

@@ -0,0 +1,399 @@
+from typing import Optional, Any
+
+import torch
+import torch as th
+from torch import nn, einsum
+from einops import rearrange, repeat
+try:
+    import xformers
+    import xformers.ops
+    XFORMERS_IS_AVAILBLE = True
+except:
+    XFORMERS_IS_AVAILBLE = False
+
+from lvdm.models.modules.util import (
+    GEGLU,
+    exists,
+    default,
+    Normalize,
+    checkpoint,
+    zero_module,
+)
+
+
+# ---------------------------------------------------------------------------------------------------
+class FeedForward(nn.Module):
+    def __init__(self, dim, dim_out=None, mult=4, glu=False, dropout=0.):
+        super().__init__()
+        inner_dim = int(dim * mult)
+        dim_out = default(dim_out, dim)
+        project_in = nn.Sequential(
+            nn.Linear(dim, inner_dim),
+            nn.GELU()
+        ) if not glu else GEGLU(dim, inner_dim)
+
+        self.net = nn.Sequential(
+            project_in,
+            nn.Dropout(dropout),
+            nn.Linear(inner_dim, dim_out)
+        )
+
+    def forward(self, x):
+        return self.net(x)
+
+
+# ---------------------------------------------------------------------------------------------------
+class RelativePosition(nn.Module):
+    """ https://github.com/evelinehong/Transformer_Relative_Position_PyTorch/blob/master/relative_position.py """
+
+    def __init__(self, num_units, max_relative_position):
+        super().__init__()
+        self.num_units = num_units
+        self.max_relative_position = max_relative_position
+        self.embeddings_table = nn.Parameter(th.Tensor(max_relative_position * 2 + 1, num_units))
+        nn.init.xavier_uniform_(self.embeddings_table)
+
+    def forward(self, length_q, length_k):
+        device = self.embeddings_table.device
+        range_vec_q = th.arange(length_q, device=device)
+        range_vec_k = th.arange(length_k, device=device)
+        distance_mat = range_vec_k[None, :] - range_vec_q[:, None]
+        distance_mat_clipped = th.clamp(distance_mat, -self.max_relative_position, self.max_relative_position)
+        final_mat = distance_mat_clipped + self.max_relative_position
+        final_mat = final_mat.long()
+        embeddings = self.embeddings_table[final_mat]
+        return embeddings
+
+
+# ---------------------------------------------------------------------------------------------------
+class TemporalCrossAttention(nn.Module):
+    def __init__(self, 
+        query_dim, 
+        context_dim=None, 
+        heads=8, 
+        dim_head=64, 
+        dropout=0.,
+        use_relative_position=False,    # whether use relative positional representation in temporal attention.
+        temporal_length=None,           # relative positional representation
+        **kwargs,
+    ):
+        super().__init__()
+        inner_dim = dim_head * heads
+        context_dim = default(context_dim, query_dim)
+        self.context_dim = context_dim
+        self.scale = dim_head ** -0.5
+        self.heads = heads
+        self.temporal_length = temporal_length
+        self.use_relative_position = use_relative_position
+        self.to_q = nn.Linear(query_dim, inner_dim, bias=False)
+        self.to_k = nn.Linear(context_dim, inner_dim, bias=False)
+        self.to_v = nn.Linear(context_dim, inner_dim, bias=False)
+        self.to_out = nn.Sequential(
+            nn.Linear(inner_dim, query_dim),
+            nn.Dropout(dropout)
+        )
+
+        if use_relative_position:
+            assert(temporal_length is not None)
+            self.relative_position_k = RelativePosition(num_units=dim_head, max_relative_position=temporal_length)
+            self.relative_position_v = RelativePosition(num_units=dim_head, max_relative_position=temporal_length)
+
+        nn.init.constant_(self.to_q.weight, 0)
+        nn.init.constant_(self.to_k.weight, 0)
+        nn.init.constant_(self.to_v.weight, 0)
+        nn.init.constant_(self.to_out[0].weight, 0)
+        nn.init.constant_(self.to_out[0].bias, 0)
+
+    def forward(self, x, context=None, mask=None):
+        nh = self.heads
+        out = x
+
+        # cal qkv
+        q = self.to_q(out)
+        context = default(context, x)
+        k = self.to_k(context)
+        v = self.to_v(context)
+
+        q, k, v = map(lambda t: rearrange(t, 'b n (h d) -> (b h) n d', h=nh), (q, k, v))
+        sim = einsum('b i d, b j d -> b i j', q, k) * self.scale
+
+        # relative positional embedding
+        if self.use_relative_position:
+            len_q, len_k, len_v = q.shape[1], k.shape[1], v.shape[1]
+            k2 = self.relative_position_k(len_q, len_k) 
+            sim2 = einsum('b t d, t s d -> b t s', q, k2) * self.scale
+            sim += sim2
+        
+        # mask attention
+        if mask is not None:
+            max_neg_value = -1e9
+            sim = sim + (1-mask.float()) * max_neg_value # 1=masking,0=no masking
+        
+        # attend to values
+        attn = sim.softmax(dim=-1)
+        out = einsum('b i j, b j d -> b i d', attn, v)
+        
+        # relative positional embedding
+        if self.use_relative_position:
+            v2 = self.relative_position_v(len_q, len_v)
+            out2 = einsum('b t s, t s d -> b t d', attn, v2)
+            out += out2
+        
+        # merge head
+        out = rearrange(out, '(b h) n d -> b n (h d)', h=nh)
+        return self.to_out(out)
+
+
+# ---------------------------------------------------------------------------------------------------
+class CrossAttention(nn.Module):
+    def __init__(self, query_dim, context_dim=None, heads=8, dim_head=64, dropout=0.,
+                 **kwargs,):
+        super().__init__()
+        inner_dim = dim_head * heads
+        context_dim = default(context_dim, query_dim)
+        
+        self.scale = dim_head ** -0.5
+        self.heads = heads
+
+        self.to_q = nn.Linear(query_dim, inner_dim, bias=False)
+        self.to_k = nn.Linear(context_dim, inner_dim, bias=False)
+        self.to_v = nn.Linear(context_dim, inner_dim, bias=False)
+
+        self.to_out = nn.Sequential(
+            nn.Linear(inner_dim, query_dim),
+            nn.Dropout(dropout)
+        )
+
+    def forward(self, x, context=None, mask=None):
+        h = self.heads
+        b = x.shape[0]
+        
+        q = self.to_q(x)
+        context = default(context, x)
+        k = self.to_k(context)
+        v = self.to_v(context)
+        
+        q, k, v = map(lambda t: rearrange(t, 'b n (h d) -> (b h) n d', h=h), (q, k, v))
+
+        sim = einsum('b i d, b j d -> b i j', q, k) * self.scale
+
+        if exists(mask):
+            mask = rearrange(mask, 'b ... -> b (...)')
+            max_neg_value = -torch.finfo(sim.dtype).max
+            mask = repeat(mask, 'b j -> (b h) () j', h=h)
+            sim.masked_fill_(~mask, max_neg_value)
+
+        attn = sim.softmax(dim=-1)
+
+        out = einsum('b i j, b j d -> b i d', attn, v)
+        out = rearrange(out, '(b h) n d -> b n (h d)', h=h)
+        return self.to_out(out)
+    
+
+# ---------------------------------------------------------------------------------------------------
+class MemoryEfficientCrossAttention(nn.Module):
+    """https://github.com/MatthieuTPHR/diffusers/blob/d80b531ff8060ec1ea982b65a1b8df70f73aa67c/src/diffusers/models/attention.py#L223
+    """
+    def __init__(self, query_dim, context_dim=None, heads=8, dim_head=64, dropout=0.0,
+                 **kwargs,):
+        super().__init__()
+        print(f"Setting up {self.__class__.__name__}. Query dim is {query_dim}, context_dim is {context_dim} and using "
+              f"{heads} heads."
+        )
+        inner_dim = dim_head * heads
+        context_dim = default(context_dim, query_dim)
+
+        self.heads = heads
+        self.dim_head = dim_head
+
+        self.to_q = nn.Linear(query_dim, inner_dim, bias=False)
+        self.to_k = nn.Linear(context_dim, inner_dim, bias=False)
+        self.to_v = nn.Linear(context_dim, inner_dim, bias=False)
+
+        self.to_out = nn.Sequential(nn.Linear(inner_dim, query_dim), nn.Dropout(dropout))
+        self.attention_op: Optional[Any] = None
+
+    def forward(self, x, context=None, mask=None):
+        q = self.to_q(x)
+        context = default(context, x)
+        k = self.to_k(context)
+        v = self.to_v(context)
+
+        b, _, _ = q.shape
+        q, k, v = map(
+            lambda t: t.unsqueeze(3)
+            .reshape(b, t.shape[1], self.heads, self.dim_head)
+            .permute(0, 2, 1, 3)
+            .reshape(b * self.heads, t.shape[1], self.dim_head)
+            .contiguous(),
+            (q, k, v),
+        )
+        out = xformers.ops.memory_efficient_attention(q, k, v, attn_bias=None, op=self.attention_op)
+
+        if exists(mask):
+            raise NotImplementedError
+        out = (
+            out.unsqueeze(0)
+            .reshape(b, self.heads, out.shape[1], self.dim_head)
+            .permute(0, 2, 1, 3)
+            .reshape(b, out.shape[1], self.heads * self.dim_head)
+        )
+        return self.to_out(out)
+
+
+# ---------------------------------------------------------------------------------------------------
+class BasicTransformerBlockST(nn.Module):
+    """
+    if no context is given to forward function, cross-attention defaults to self-attention
+    """
+    def __init__(self, 
+        # Spatial
+        dim, 
+        n_heads, 
+        d_head, 
+        dropout=0., 
+        context_dim=None, 
+        gated_ff=True, 
+        checkpoint=True,
+        # Temporal
+        temporal_length=None,   
+        use_relative_position=True,
+        **kwargs,
+    ):
+        super().__init__()
+
+        # spatial self attention (if context_dim is None) and spatial cross attention
+        if XFORMERS_IS_AVAILBLE:
+            self.attn1 = MemoryEfficientCrossAttention(query_dim=dim, heads=n_heads, dim_head=d_head, dropout=dropout, **kwargs,)
+            self.attn2 = MemoryEfficientCrossAttention(query_dim=dim, context_dim=context_dim,
+                                    heads=n_heads, dim_head=d_head, dropout=dropout, **kwargs,)
+        else:
+            self.attn1 = CrossAttention(query_dim=dim, heads=n_heads, dim_head=d_head, dropout=dropout, **kwargs,)
+            self.attn2 = CrossAttention(query_dim=dim, context_dim=context_dim,
+                                    heads=n_heads, dim_head=d_head, dropout=dropout, **kwargs,)
+        self.ff = FeedForward(dim, dropout=dropout, glu=gated_ff)
+        
+        self.norm1 = nn.LayerNorm(dim)
+        self.norm2 = nn.LayerNorm(dim)
+        self.norm3 = nn.LayerNorm(dim)
+        self.checkpoint = checkpoint
+        
+        # Temporal attention
+        self.attn1_tmp = TemporalCrossAttention(query_dim=dim, heads=n_heads, dim_head=d_head, dropout=dropout,
+                                                temporal_length=temporal_length,
+                                                use_relative_position=use_relative_position,
+                                                **kwargs,
+        )
+        self.attn2_tmp = TemporalCrossAttention(query_dim=dim, heads=n_heads, dim_head=d_head, dropout=dropout,
+                                                # cross attn
+                                                context_dim=None,
+                                                # temporal attn
+                                                temporal_length=temporal_length,
+                                                use_relative_position=use_relative_position,
+                                                **kwargs,
+        )
+        self.norm4 = nn.LayerNorm(dim)
+        self.norm5 = nn.LayerNorm(dim)
+        
+    def forward(self, x, context=None, **kwargs):
+        return checkpoint(self._forward, (x, context), self.parameters(), self.checkpoint)
+        
+    def _forward(self, x, context=None, mask=None,):
+        assert(x.dim() == 5), f"x shape = {x.shape}"
+        b, c, t, h, w = x.shape
+        
+        # spatial self attention
+        x = rearrange(x, 'b c t h w -> (b t) (h w) c')
+        x = self.attn1(self.norm1(x)) + x
+        x = rearrange(x, '(b t) (h w) c -> b c t h w', b=b,h=h)
+        
+        # temporal self attention
+        x = rearrange(x, 'b c t h w -> (b h w) t c')
+        x = self.attn1_tmp(self.norm4(x), mask=mask) + x
+        x = rearrange(x, '(b h w) t c -> b c t h w', b=b,h=h,w=w) # 3d -> 5d
+        
+        # spatial cross attention
+        x = rearrange(x, 'b c t h w -> (b t) (h w) c')
+        if context is not None:
+            context_ = []
+            for i in range(context.shape[0]):
+                context_.append(context[i].unsqueeze(0).repeat(t, 1, 1))
+            context_ = torch.cat(context_,dim=0)
+        else:
+            context_ = None
+        x = self.attn2(self.norm2(x), context=context_) + x
+        x = rearrange(x, '(b t) (h w) c -> b c t h w', b=b,h=h)
+
+        # temporal cross attention
+        x = rearrange(x, 'b c t h w -> (b h w) t c')
+        x = self.attn2_tmp(self.norm5(x), context=None, mask=mask) + x
+
+        # feedforward
+        x = self.ff(self.norm3(x)) + x
+        x = rearrange(x, '(b h w) t c -> b c t h w', b=b,h=h,w=w) # 3d -> 5d
+        
+        return x
+
+
+# ---------------------------------------------------------------------------------------------------
+class SpatialTemporalTransformer(nn.Module):
+    """
+    Transformer block for video-like data (5D tensor).
+    First, project the input (aka embedding) with NO reshape.
+    Then apply standard transformer action.
+    The 5D -> 3D reshape operation will be done in the specific attention module.
+    """
+    def __init__(
+        self,
+        in_channels, n_heads, d_head,
+        depth=1, dropout=0.,
+        context_dim=None,
+        # Temporal
+        temporal_length=None,
+        use_relative_position=True,
+        **kwargs,
+        ):
+        super().__init__()
+
+        self.in_channels = in_channels
+        inner_dim = n_heads * d_head
+
+        self.norm = Normalize(in_channels)
+        self.proj_in = nn.Conv3d(in_channels,
+                                 inner_dim,
+                                 kernel_size=1,
+                                 stride=1,
+                                 padding=0)
+
+        self.transformer_blocks = nn.ModuleList(
+            [BasicTransformerBlockST(
+                inner_dim, n_heads, d_head, dropout=dropout,
+                # cross attn
+                context_dim=context_dim,
+                # temporal attn
+                temporal_length=temporal_length,   
+                use_relative_position=use_relative_position,
+                **kwargs
+                ) for d in range(depth)]
+        )
+
+        self.proj_out = zero_module(nn.Conv3d(inner_dim,
+                                              in_channels,
+                                              kernel_size=1,
+                                              stride=1,
+                                              padding=0))
+        
+    def forward(self, x, context=None, **kwargs):
+        
+        assert(x.dim() == 5), f"x shape = {x.shape}"
+        x_in = x
+        
+        x = self.norm(x)
+        x = self.proj_in(x)
+        
+        for block in self.transformer_blocks:
+            x = block(x, context=context, **kwargs)
+        
+        x = self.proj_out(x)
+
+        return x + x_in

lvdm/models/modules/autoencoder_modules.py

@@ -0,0 +1,596 @@
+import math
+
+import torch
+import numpy as np
+from torch import nn
+from einops import rearrange
+
+
+def get_timestep_embedding(timesteps, embedding_dim):
+    """
+    This matches the implementation in Denoising Diffusion Probabilistic Models:
+    From Fairseq.
+    Build sinusoidal embeddings.
+    This matches the implementation in tensor2tensor, but differs slightly
+    from the description in Section 3.5 of "Attention Is All You Need".
+    """
+    assert len(timesteps.shape) == 1
+
+    half_dim = embedding_dim // 2
+    emb = math.log(10000) / (half_dim - 1)
+    emb = torch.exp(torch.arange(half_dim, dtype=torch.float32) * -emb)
+    emb = emb.to(device=timesteps.device)
+    emb = timesteps.float()[:, None] * emb[None, :]
+    emb = torch.cat([torch.sin(emb), torch.cos(emb)], dim=1)
+    if embedding_dim % 2 == 1:  # zero pad
+        emb = torch.nn.functional.pad(emb, (0,1,0,0))
+    return emb
+
+def nonlinearity(x):
+    # swish
+    return x*torch.sigmoid(x)
+
+
+def Normalize(in_channels, num_groups=32):
+    return torch.nn.GroupNorm(num_groups=num_groups, num_channels=in_channels, eps=1e-6, affine=True)
+
+
+
+class LinearAttention(nn.Module):
+    def __init__(self, dim, heads=4, dim_head=32):
+        super().__init__()
+        self.heads = heads
+        hidden_dim = dim_head * heads
+        self.to_qkv = nn.Conv2d(dim, hidden_dim * 3, 1, bias = False)
+        self.to_out = nn.Conv2d(hidden_dim, dim, 1)
+
+    def forward(self, x):
+        b, c, h, w = x.shape
+        qkv = self.to_qkv(x)
+        q, k, v = rearrange(qkv, 'b (qkv heads c) h w -> qkv b heads c (h w)', heads = self.heads, qkv=3)
+        k = k.softmax(dim=-1)  
+        context = torch.einsum('bhdn,bhen->bhde', k, v)
+        out = torch.einsum('bhde,bhdn->bhen', context, q)
+        out = rearrange(out, 'b heads c (h w) -> b (heads c) h w', heads=self.heads, h=h, w=w)
+        return self.to_out(out)
+
+
+class LinAttnBlock(LinearAttention):
+    """to match AttnBlock usage"""
+    def __init__(self, in_channels):
+        super().__init__(dim=in_channels, heads=1, dim_head=in_channels)
+
+
+class AttnBlock(nn.Module):
+    def __init__(self, in_channels):
+        super().__init__()
+        self.in_channels = in_channels
+
+        self.norm = Normalize(in_channels)
+        self.q = torch.nn.Conv2d(in_channels,
+                                 in_channels,
+                                 kernel_size=1,
+                                 stride=1,
+                                 padding=0)
+        self.k = torch.nn.Conv2d(in_channels,
+                                 in_channels,
+                                 kernel_size=1,
+                                 stride=1,
+                                 padding=0)
+        self.v = torch.nn.Conv2d(in_channels,
+                                 in_channels,
+                                 kernel_size=1,
+                                 stride=1,
+                                 padding=0)
+        self.proj_out = torch.nn.Conv2d(in_channels,
+                                        in_channels,
+                                        kernel_size=1,
+                                        stride=1,
+                                        padding=0)
+
+    def forward(self, x):
+        h_ = x
+        h_ = self.norm(h_)
+        q = self.q(h_)
+        k = self.k(h_)
+        v = self.v(h_)
+
+        # compute attention
+        b,c,h,w = q.shape
+        q = q.reshape(b,c,h*w) # bcl
+        q = q.permute(0,2,1)   # bcl -> blc l=hw
+        k = k.reshape(b,c,h*w) # bcl
+        
+        w_ = torch.bmm(q,k)    # b,hw,hw    w[b,i,j]=sum_c q[b,i,c]k[b,c,j]
+        w_ = w_ * (int(c)**(-0.5))
+        w_ = torch.nn.functional.softmax(w_, dim=2)
+
+        # attend to values
+        v = v.reshape(b,c,h*w)
+        w_ = w_.permute(0,2,1)   # b,hw,hw (first hw of k, second of q)
+        h_ = torch.bmm(v,w_)     # b, c,hw (hw of q) h_[b,c,j] = sum_i v[b,c,i] w_[b,i,j]
+        h_ = h_.reshape(b,c,h,w)
+
+        h_ = self.proj_out(h_)
+
+        return x+h_
+
+
+def make_attn(in_channels, attn_type="vanilla"):
+    assert attn_type in ["vanilla", "linear", "none"], f'attn_type {attn_type} unknown'
+    print(f"making attention of type '{attn_type}' with {in_channels} in_channels")
+    if attn_type == "vanilla":
+        return AttnBlock(in_channels)
+    elif attn_type == "none":
+        return nn.Identity(in_channels)
+    else:
+        return LinAttnBlock(in_channels)
+ 
+class Downsample(nn.Module):
+    def __init__(self, in_channels, with_conv):
+        super().__init__()
+        self.with_conv = with_conv
+        self.in_channels = in_channels
+        if self.with_conv:
+            # no asymmetric padding in torch conv, must do it ourselves
+            self.conv = torch.nn.Conv2d(in_channels,
+                                        in_channels,
+                                        kernel_size=3,
+                                        stride=2,
+                                        padding=0)
+    def forward(self, x):
+        if self.with_conv:
+            pad = (0,1,0,1)
+            x = torch.nn.functional.pad(x, pad, mode="constant", value=0)
+            x = self.conv(x)
+        else:
+            x = torch.nn.functional.avg_pool2d(x, kernel_size=2, stride=2)
+        return x
+
+class Upsample(nn.Module):
+    def __init__(self, in_channels, with_conv):
+        super().__init__()
+        self.with_conv = with_conv
+        self.in_channels = in_channels
+        if self.with_conv:
+            self.conv = torch.nn.Conv2d(in_channels,
+                                        in_channels,
+                                        kernel_size=3,
+                                        stride=1,
+                                        padding=1)
+
+    def forward(self, x):
+        x = torch.nn.functional.interpolate(x, scale_factor=2.0, mode="nearest")
+        if self.with_conv:
+            x = self.conv(x)
+        return x
+
+
+class ResnetBlock(nn.Module):
+    def __init__(self, *, in_channels, out_channels=None, conv_shortcut=False,
+                 dropout, temb_channels=512):
+        super().__init__()
+        self.in_channels = in_channels
+        out_channels = in_channels if out_channels is None else out_channels
+        self.out_channels = out_channels
+        self.use_conv_shortcut = conv_shortcut
+
+        self.norm1 = Normalize(in_channels)
+        self.conv1 = torch.nn.Conv2d(in_channels,
+                                     out_channels,
+                                     kernel_size=3,
+                                     stride=1,
+                                     padding=1)
+        if temb_channels > 0:
+            self.temb_proj = torch.nn.Linear(temb_channels,
+                                             out_channels)
+        self.norm2 = Normalize(out_channels)
+        self.dropout = torch.nn.Dropout(dropout)
+        self.conv2 = torch.nn.Conv2d(out_channels,
+                                     out_channels,
+                                     kernel_size=3,
+                                     stride=1,
+                                     padding=1)
+        if self.in_channels != self.out_channels:
+            if self.use_conv_shortcut:
+                self.conv_shortcut = torch.nn.Conv2d(in_channels,
+                                                     out_channels,
+                                                     kernel_size=3,
+                                                     stride=1,
+                                                     padding=1)
+            else:
+                self.nin_shortcut = torch.nn.Conv2d(in_channels,
+                                                    out_channels,
+                                                    kernel_size=1,
+                                                    stride=1,
+                                                    padding=0)
+
+    def forward(self, x, temb):
+        h = x
+        h = self.norm1(h)
+        h = nonlinearity(h)
+        h = self.conv1(h)
+
+        if temb is not None:
+            h = h + self.temb_proj(nonlinearity(temb))[:,:,None,None]
+
+        h = self.norm2(h)
+        h = nonlinearity(h)
+        h = self.dropout(h)
+        h = self.conv2(h)
+
+        if self.in_channels != self.out_channels:
+            if self.use_conv_shortcut:
+                x = self.conv_shortcut(x)
+            else:
+                x = self.nin_shortcut(x)
+
+        return x+h
+
+class Model(nn.Module):
+    def __init__(self, *, ch, out_ch, ch_mult=(1,2,4,8), num_res_blocks,
+                 attn_resolutions, dropout=0.0, resamp_with_conv=True, in_channels,
+                 resolution, use_timestep=True, use_linear_attn=False, attn_type="vanilla"):
+        super().__init__()
+        if use_linear_attn: attn_type = "linear"
+        self.ch = ch
+        self.temb_ch = self.ch*4
+        self.num_resolutions = len(ch_mult)
+        self.num_res_blocks = num_res_blocks
+        self.resolution = resolution
+        self.in_channels = in_channels
+
+        self.use_timestep = use_timestep
+        if self.use_timestep:
+            # timestep embedding
+            self.temb = nn.Module()
+            self.temb.dense = nn.ModuleList([
+                torch.nn.Linear(self.ch,
+                                self.temb_ch),
+                torch.nn.Linear(self.temb_ch,
+                                self.temb_ch),
+            ])
+
+        # downsampling
+        self.conv_in = torch.nn.Conv2d(in_channels,
+                                       self.ch,
+                                       kernel_size=3,
+                                       stride=1,
+                                       padding=1)
+
+        curr_res = resolution
+        in_ch_mult = (1,)+tuple(ch_mult)
+        self.down = nn.ModuleList()
+        for i_level in range(self.num_resolutions):
+            block = nn.ModuleList()
+            attn = nn.ModuleList()
+            block_in = ch*in_ch_mult[i_level]
+            block_out = ch*ch_mult[i_level]
+            for i_block in range(self.num_res_blocks):
+                block.append(ResnetBlock(in_channels=block_in,
+                                         out_channels=block_out,
+                                         temb_channels=self.temb_ch,
+                                         dropout=dropout))
+                block_in = block_out
+                if curr_res in attn_resolutions:
+                    attn.append(make_attn(block_in, attn_type=attn_type))
+            down = nn.Module()
+            down.block = block
+            down.attn = attn
+            if i_level != self.num_resolutions-1:
+                down.downsample = Downsample(block_in, resamp_with_conv)
+                curr_res = curr_res // 2
+            self.down.append(down)
+
+        # middle
+        self.mid = nn.Module()
+        self.mid.block_1 = ResnetBlock(in_channels=block_in,
+                                       out_channels=block_in,
+                                       temb_channels=self.temb_ch,
+                                       dropout=dropout)
+        self.mid.attn_1 = make_attn(block_in, attn_type=attn_type)
+        self.mid.block_2 = ResnetBlock(in_channels=block_in,
+                                       out_channels=block_in,
+                                       temb_channels=self.temb_ch,
+                                       dropout=dropout)
+
+        # upsampling
+        self.up = nn.ModuleList()
+        for i_level in reversed(range(self.num_resolutions)):
+            block = nn.ModuleList()
+            attn = nn.ModuleList()
+            block_out = ch*ch_mult[i_level]
+            skip_in = ch*ch_mult[i_level]
+            for i_block in range(self.num_res_blocks+1):
+                if i_block == self.num_res_blocks:
+                    skip_in = ch*in_ch_mult[i_level]
+                block.append(ResnetBlock(in_channels=block_in+skip_in,
+                                         out_channels=block_out,
+                                         temb_channels=self.temb_ch,
+                                         dropout=dropout))
+                block_in = block_out
+                if curr_res in attn_resolutions:
+                    attn.append(make_attn(block_in, attn_type=attn_type))
+            up = nn.Module()
+            up.block = block
+            up.attn = attn
+            if i_level != 0:
+                up.upsample = Upsample(block_in, resamp_with_conv)
+                curr_res = curr_res * 2
+            self.up.insert(0, up) # prepend to get consistent order
+
+        # end
+        self.norm_out = Normalize(block_in)
+        self.conv_out = torch.nn.Conv2d(block_in,
+                                        out_ch,
+                                        kernel_size=3,
+                                        stride=1,
+                                        padding=1)
+
+    def forward(self, x, t=None, context=None):
+        #assert x.shape[2] == x.shape[3] == self.resolution
+        if context is not None:
+            # assume aligned context, cat along channel axis
+            x = torch.cat((x, context), dim=1)
+        if self.use_timestep:
+            # timestep embedding
+            assert t is not None
+            temb = get_timestep_embedding(t, self.ch)
+            temb = self.temb.dense[0](temb)
+            temb = nonlinearity(temb)
+            temb = self.temb.dense[1](temb)
+        else:
+            temb = None
+
+        # downsampling
+        hs = [self.conv_in(x)]
+        for i_level in range(self.num_resolutions):
+            for i_block in range(self.num_res_blocks):
+                h = self.down[i_level].block[i_block](hs[-1], temb)
+                if len(self.down[i_level].attn) > 0:
+                    h = self.down[i_level].attn[i_block](h)
+                hs.append(h)
+            if i_level != self.num_resolutions-1:
+                hs.append(self.down[i_level].downsample(hs[-1]))
+
+        # middle
+        h = hs[-1]
+        h = self.mid.block_1(h, temb)
+        h = self.mid.attn_1(h)
+        h = self.mid.block_2(h, temb)
+
+        # upsampling
+        for i_level in reversed(range(self.num_resolutions)):
+            for i_block in range(self.num_res_blocks+1):
+                h = self.up[i_level].block[i_block](
+                    torch.cat([h, hs.pop()], dim=1), temb)
+                if len(self.up[i_level].attn) > 0:
+                    h = self.up[i_level].attn[i_block](h)
+            if i_level != 0:
+                h = self.up[i_level].upsample(h)
+
+        # end
+        h = self.norm_out(h)
+        h = nonlinearity(h)
+        h = self.conv_out(h)
+        return h
+
+    def get_last_layer(self):
+        return self.conv_out.weight
+
+
+class Encoder(nn.Module):
+    def __init__(self, *, ch, out_ch, ch_mult=(1,2,4,8), num_res_blocks,
+                 attn_resolutions, dropout=0.0, resamp_with_conv=True, in_channels,
+                 resolution, z_channels, double_z=True, use_linear_attn=False, attn_type="vanilla",
+                 **ignore_kwargs):
+        super().__init__()
+        if use_linear_attn: attn_type = "linear"
+        self.ch = ch
+        self.temb_ch = 0
+        self.num_resolutions = len(ch_mult)
+        self.num_res_blocks = num_res_blocks
+        self.resolution = resolution
+        self.in_channels = in_channels
+
+        # downsampling
+        self.conv_in = torch.nn.Conv2d(in_channels,
+                                       self.ch,
+                                       kernel_size=3,
+                                       stride=1,
+                                       padding=1)
+
+        curr_res = resolution
+        in_ch_mult = (1,)+tuple(ch_mult)
+        self.in_ch_mult = in_ch_mult
+        self.down = nn.ModuleList()
+        for i_level in range(self.num_resolutions):
+            block = nn.ModuleList()
+            attn = nn.ModuleList()
+            block_in = ch*in_ch_mult[i_level]
+            block_out = ch*ch_mult[i_level]
+            for i_block in range(self.num_res_blocks):
+                block.append(ResnetBlock(in_channels=block_in,
+                                         out_channels=block_out,
+                                         temb_channels=self.temb_ch,
+                                         dropout=dropout))
+                block_in = block_out
+                if curr_res in attn_resolutions:
+                    attn.append(make_attn(block_in, attn_type=attn_type))
+            down = nn.Module()
+            down.block = block
+            down.attn = attn
+            if i_level != self.num_resolutions-1:
+                down.downsample = Downsample(block_in, resamp_with_conv)
+                curr_res = curr_res // 2
+            self.down.append(down)
+
+        # middle
+        self.mid = nn.Module()
+        self.mid.block_1 = ResnetBlock(in_channels=block_in,
+                                       out_channels=block_in,
+                                       temb_channels=self.temb_ch,
+                                       dropout=dropout)
+        self.mid.attn_1 = make_attn(block_in, attn_type=attn_type)
+        self.mid.block_2 = ResnetBlock(in_channels=block_in,
+                                       out_channels=block_in,
+                                       temb_channels=self.temb_ch,
+                                       dropout=dropout)
+
+        # end
+        self.norm_out = Normalize(block_in)
+        self.conv_out = torch.nn.Conv2d(block_in,
+                                        2*z_channels if double_z else z_channels,
+                                        kernel_size=3,
+                                        stride=1,
+                                        padding=1)
+
+    def forward(self, x):
+        # timestep embedding
+        temb = None
+
+        # print(f'encoder-input={x.shape}')
+        # downsampling
+        hs = [self.conv_in(x)]
+        # print(f'encoder-conv in feat={hs[0].shape}')
+        for i_level in range(self.num_resolutions):
+            for i_block in range(self.num_res_blocks):
+                h = self.down[i_level].block[i_block](hs[-1], temb)
+                # print(f'encoder-down feat={h.shape}')
+                if len(self.down[i_level].attn) > 0:
+                    h = self.down[i_level].attn[i_block](h)
+                hs.append(h)
+            if i_level != self.num_resolutions-1:
+                # print(f'encoder-downsample (input)={hs[-1].shape}')
+                hs.append(self.down[i_level].downsample(hs[-1]))
+                # print(f'encoder-downsample (output)={hs[-1].shape}')
+
+        # middle
+        h = hs[-1]
+        h = self.mid.block_1(h, temb)
+        # print(f'encoder-mid1 feat={h.shape}')
+        h = self.mid.attn_1(h)
+        h = self.mid.block_2(h, temb)
+        # print(f'encoder-mid2 feat={h.shape}')
+
+        # end
+        h = self.norm_out(h)
+        h = nonlinearity(h)
+        h = self.conv_out(h)
+        # print(f'end feat={h.shape}')
+        return h
+
+
+class Decoder(nn.Module):
+    def __init__(self, *, ch, out_ch, ch_mult=(1,2,4,8), num_res_blocks,
+                 attn_resolutions, dropout=0.0, resamp_with_conv=True, in_channels,
+                 resolution, z_channels, give_pre_end=False, tanh_out=False, use_linear_attn=False,
+                 attn_type="vanilla", **ignorekwargs):
+        super().__init__()
+        if use_linear_attn: attn_type = "linear"
+        self.ch = ch
+        self.temb_ch = 0
+        self.num_resolutions = len(ch_mult)
+        self.num_res_blocks = num_res_blocks
+        self.resolution = resolution
+        self.in_channels = in_channels
+        self.give_pre_end = give_pre_end
+        self.tanh_out = tanh_out
+
+        # compute in_ch_mult, block_in and curr_res at lowest res
+        in_ch_mult = (1,)+tuple(ch_mult)
+        block_in = ch*ch_mult[self.num_resolutions-1]
+        curr_res = resolution // 2**(self.num_resolutions-1)
+        self.z_shape = (1,z_channels,curr_res,curr_res)
+        print("Working with z of shape {} = {} dimensions.".format(
+            self.z_shape, np.prod(self.z_shape)))
+
+        # z to block_in
+        self.conv_in = torch.nn.Conv2d(z_channels,
+                                       block_in,
+                                       kernel_size=3,
+                                       stride=1,
+                                       padding=1)
+
+        # middle
+        self.mid = nn.Module()
+        self.mid.block_1 = ResnetBlock(in_channels=block_in,
+                                       out_channels=block_in,
+                                       temb_channels=self.temb_ch,
+                                       dropout=dropout)
+        self.mid.attn_1 = make_attn(block_in, attn_type=attn_type)
+        self.mid.block_2 = ResnetBlock(in_channels=block_in,
+                                       out_channels=block_in,
+                                       temb_channels=self.temb_ch,
+                                       dropout=dropout)
+
+        # upsampling
+        self.up = nn.ModuleList()
+        for i_level in reversed(range(self.num_resolutions)):
+            block = nn.ModuleList()
+            attn = nn.ModuleList()
+            block_out = ch*ch_mult[i_level]
+            for i_block in range(self.num_res_blocks+1):
+                block.append(ResnetBlock(in_channels=block_in,
+                                         out_channels=block_out,
+                                         temb_channels=self.temb_ch,
+                                         dropout=dropout))
+                block_in = block_out
+                if curr_res in attn_resolutions:
+                    attn.append(make_attn(block_in, attn_type=attn_type))
+            up = nn.Module()
+            up.block = block
+            up.attn = attn
+            if i_level != 0:
+                up.upsample = Upsample(block_in, resamp_with_conv)
+                curr_res = curr_res * 2
+            self.up.insert(0, up) # prepend to get consistent order
+
+        # end
+        self.norm_out = Normalize(block_in)
+        self.conv_out = torch.nn.Conv2d(block_in,
+                                        out_ch,
+                                        kernel_size=3,
+                                        stride=1,
+                                        padding=1)
+
+    def forward(self, z):
+        #assert z.shape[1:] == self.z_shape[1:]
+        self.last_z_shape = z.shape
+
+        # print(f'decoder-input={z.shape}')
+        # timestep embedding
+        temb = None
+
+        # z to block_in
+        h = self.conv_in(z)
+        # print(f'decoder-conv in feat={h.shape}')
+
+        # middle
+        h = self.mid.block_1(h, temb)
+        h = self.mid.attn_1(h)
+        h = self.mid.block_2(h, temb)
+        # print(f'decoder-mid feat={h.shape}')
+
+        # upsampling
+        for i_level in reversed(range(self.num_resolutions)):
+            for i_block in range(self.num_res_blocks+1):
+                h = self.up[i_level].block[i_block](h, temb)
+                if len(self.up[i_level].attn) > 0:
+                    h = self.up[i_level].attn[i_block](h)
+                # print(f'decoder-up feat={h.shape}')
+            if i_level != 0:
+                h = self.up[i_level].upsample(h)
+                # print(f'decoder-upsample feat={h.shape}')
+
+        # end
+        if self.give_pre_end:
+            return h
+
+        h = self.norm_out(h)
+        h = nonlinearity(h)
+        h = self.conv_out(h)
+        # print(f'decoder-conv_out feat={h.shape}')
+        if self.tanh_out:
+            h = torch.tanh(h)
+        return h

lvdm/models/modules/condition_modules.py

@@ -0,0 +1,40 @@
+import torch.nn as nn
+from transformers import logging
+from transformers import CLIPTokenizer, CLIPTextModel
+logging.set_verbosity_error()
+
+
+class AbstractEncoder(nn.Module):
+    def __init__(self):
+        super().__init__()
+
+    def encode(self, *args, **kwargs):
+        raise NotImplementedError
+
+
+class FrozenCLIPEmbedder(AbstractEncoder):
+    """Uses the CLIP transformer encoder for text (from huggingface)"""
+    def __init__(self, version="openai/clip-vit-large-patch14", device="cuda", max_length=77):
+        super().__init__()
+        self.tokenizer = CLIPTokenizer.from_pretrained(version)
+        self.transformer = CLIPTextModel.from_pretrained(version)
+        self.device = device
+        self.max_length = max_length
+        self.freeze()
+
+    def freeze(self):
+        self.transformer = self.transformer.eval()
+        for param in self.parameters():
+            param.requires_grad = False
+
+    def forward(self, text):
+        batch_encoding = self.tokenizer(text, truncation=True, max_length=self.max_length, return_length=True,
+                                        return_overflowing_tokens=False, padding="max_length", return_tensors="pt")
+        tokens = batch_encoding["input_ids"].to(self.device)
+        outputs = self.transformer(input_ids=tokens)
+
+        z = outputs.last_hidden_state
+        return z
+
+    def encode(self, text):
+        return self(text)

lvdm/models/modules/distributions.py

@@ -0,0 +1,76 @@
+import torch
+import numpy as np
+
+
+class DiagonalGaussianDistribution(object):
+    def __init__(self, parameters, deterministic=False):
+        self.parameters = parameters
+        self.mean, self.logvar = torch.chunk(parameters, 2, dim=1)
+        self.logvar = torch.clamp(self.logvar, -30.0, 20.0)
+        self.deterministic = deterministic
+        self.std = torch.exp(0.5 * self.logvar)
+        self.var = torch.exp(self.logvar)
+        if self.deterministic:
+            self.var = self.std = torch.zeros_like(self.mean).to(device=self.parameters.device)
+
+    def sample(self, noise=None):
+        if noise is None:
+            noise = torch.randn(self.mean.shape)
+        
+        x = self.mean + self.std * noise.to(device=self.parameters.device)
+        return x
+
+    def kl(self, other=None):
+        if self.deterministic:
+            return torch.Tensor([0.])
+        else:
+            if other is None:
+                return 0.5 * torch.sum(torch.pow(self.mean, 2)
+                                       + self.var - 1.0 - self.logvar,
+                                       dim=[1, 2, 3])
+            else:
+                return 0.5 * torch.sum(
+                    torch.pow(self.mean - other.mean, 2) / other.var
+                    + self.var / other.var - 1.0 - self.logvar + other.logvar,
+                    dim=[1, 2, 3])
+
+    def nll(self, sample, dims=[1,2,3]):
+        if self.deterministic:
+            return torch.Tensor([0.])
+        logtwopi = np.log(2.0 * np.pi)
+        return 0.5 * torch.sum(
+            logtwopi + self.logvar + torch.pow(sample - self.mean, 2) / self.var,
+            dim=dims)
+
+    def mode(self):
+        return self.mean
+
+
+def normal_kl(mean1, logvar1, mean2, logvar2):
+    """
+    source: https://github.com/openai/guided-diffusion/blob/27c20a8fab9cb472df5d6bdd6c8d11c8f430b924/guided_diffusion/losses.py#L12
+    Compute the KL divergence between two gaussians.
+    Shapes are automatically broadcasted, so batches can be compared to
+    scalars, among other use cases.
+    """
+    tensor = None
+    for obj in (mean1, logvar1, mean2, logvar2):
+        if isinstance(obj, torch.Tensor):
+            tensor = obj
+            break
+    assert tensor is not None, "at least one argument must be a Tensor"
+
+    # Force variances to be Tensors. Broadcasting helps convert scalars to
+    # Tensors, but it does not work for torch.exp().
+    logvar1, logvar2 = [
+        x if isinstance(x, torch.Tensor) else torch.tensor(x).to(tensor)
+        for x in (logvar1, logvar2)
+    ]
+
+    return 0.5 * (
+        -1.0
+        + logvar2
+        - logvar1
+        + torch.exp(logvar1 - logvar2)
+        + ((mean1 - mean2) ** 2) * torch.exp(-logvar2)
+    )

lvdm/models/modules/lora.py

@@ -0,0 +1,1174 @@
+import json
+from itertools import groupby
+from typing import Dict, List, Optional, Set, Tuple, Type, Union
+
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+# try:
+#     from safetensors.torch import safe_open
+#     from safetensors.torch import save_file as safe_save
+
+#     safetensors_available = True
+# except ImportError:
+#     from .safe_open import safe_open
+
+#     def safe_save(
+#         tensors: Dict[str, torch.Tensor],
+#         filename: str,
+#         metadata: Optional[Dict[str, str]] = None,
+#     ) -> None:
+#         raise EnvironmentError(
+#             "Saving safetensors requires the safetensors library. Please install with pip or similar."
+#         )
+
+#     safetensors_available = False
+
+
+class LoraInjectedLinear(nn.Module):
+    def __init__(
+        self, in_features, out_features, bias=False, r=4, dropout_p=0.1, scale=1.0
+    ):
+        super().__init__()
+
+        if r > min(in_features, out_features):
+            raise ValueError(
+                f"LoRA rank {r} must be less or equal than {min(in_features, out_features)}"
+            )
+        self.r = r
+        self.linear = nn.Linear(in_features, out_features, bias)
+        self.lora_down = nn.Linear(in_features, r, bias=False)
+        self.dropout = nn.Dropout(dropout_p)
+        self.lora_up = nn.Linear(r, out_features, bias=False)
+        self.scale = scale
+        self.selector = nn.Identity()
+
+        nn.init.normal_(self.lora_down.weight, std=1 / r)
+        nn.init.zeros_(self.lora_up.weight)
+
+    def forward(self, input):
+        return (
+            self.linear(input)
+            + self.dropout(self.lora_up(self.selector(self.lora_down(input))))
+            * self.scale
+        )
+
+    def realize_as_lora(self):
+        return self.lora_up.weight.data * self.scale, self.lora_down.weight.data
+
+    def set_selector_from_diag(self, diag: torch.Tensor):
+        # diag is a 1D tensor of size (r,)
+        assert diag.shape == (self.r,)
+        self.selector = nn.Linear(self.r, self.r, bias=False)
+        self.selector.weight.data = torch.diag(diag)
+        self.selector.weight.data = self.selector.weight.data.to(
+            self.lora_up.weight.device
+        ).to(self.lora_up.weight.dtype)
+
+
+class LoraInjectedConv2d(nn.Module):
+    def __init__(
+        self,
+        in_channels: int,
+        out_channels: int,
+        kernel_size,
+        stride=1,
+        padding=0,
+        dilation=1,
+        groups: int = 1,
+        bias: bool = True,
+        r: int = 4,
+        dropout_p: float = 0.1,
+        scale: float = 1.0,
+    ):
+        super().__init__()
+        if r > min(in_channels, out_channels):
+            raise ValueError(
+                f"LoRA rank {r} must be less or equal than {min(in_channels, out_channels)}"
+            )
+        self.r = r
+        self.conv = nn.Conv2d(
+            in_channels=in_channels,
+            out_channels=out_channels,
+            kernel_size=kernel_size,
+            stride=stride,
+            padding=padding,
+            dilation=dilation,
+            groups=groups,
+            bias=bias,
+        )
+
+        self.lora_down = nn.Conv2d(
+            in_channels=in_channels,
+            out_channels=r,
+            kernel_size=kernel_size,
+            stride=stride,
+            padding=padding,
+            dilation=dilation,
+            groups=groups,
+            bias=False,
+        )
+        self.dropout = nn.Dropout(dropout_p)
+        self.lora_up = nn.Conv2d(
+            in_channels=r,
+            out_channels=out_channels,
+            kernel_size=1,
+            stride=1,
+            padding=0,
+            bias=False,
+        )
+        self.selector = nn.Identity()
+        self.scale = scale
+
+        nn.init.normal_(self.lora_down.weight, std=1 / r)
+        nn.init.zeros_(self.lora_up.weight)
+
+    def forward(self, input):
+        return (
+            self.conv(input)
+            + self.dropout(self.lora_up(self.selector(self.lora_down(input))))
+            * self.scale
+        )
+
+    def realize_as_lora(self):
+        return self.lora_up.weight.data * self.scale, self.lora_down.weight.data
+
+    def set_selector_from_diag(self, diag: torch.Tensor):
+        # diag is a 1D tensor of size (r,)
+        assert diag.shape == (self.r,)
+        self.selector = nn.Conv2d(
+            in_channels=self.r,
+            out_channels=self.r,
+            kernel_size=1,
+            stride=1,
+            padding=0,
+            bias=False,
+        )
+        self.selector.weight.data = torch.diag(diag)
+
+        # same device + dtype as lora_up
+        self.selector.weight.data = self.selector.weight.data.to(
+            self.lora_up.weight.device
+        ).to(self.lora_up.weight.dtype)
+
+
+UNET_DEFAULT_TARGET_REPLACE = {"MemoryEfficientCrossAttention","CrossAttention", "Attention", "GEGLU"}
+
+UNET_EXTENDED_TARGET_REPLACE = {"TimestepEmbedSequential","SpatialTemporalTransformer", "MemoryEfficientCrossAttention","CrossAttention", "Attention", "GEGLU"}
+
+TEXT_ENCODER_DEFAULT_TARGET_REPLACE = {"CLIPAttention"}
+
+TEXT_ENCODER_EXTENDED_TARGET_REPLACE = {"CLIPMLP","CLIPAttention"}
+
+DEFAULT_TARGET_REPLACE = UNET_DEFAULT_TARGET_REPLACE
+
+EMBED_FLAG = "<embed>"
+
+
+def _find_children(
+    model,
+    search_class: List[Type[nn.Module]] = [nn.Linear],
+):
+    """
+    Find all modules of a certain class (or union of classes).
+
+    Returns all matching modules, along with the parent of those moduless and the
+    names they are referenced by.
+    """
+    # For each target find every linear_class module that isn't a child of a LoraInjectedLinear
+    for parent in model.modules():
+        for name, module in parent.named_children():
+            if any([isinstance(module, _class) for _class in search_class]):
+                yield parent, name, module
+
+
+def _find_modules_v2(
+    model,
+    ancestor_class: Optional[Set[str]] = None,
+    search_class: List[Type[nn.Module]] = [nn.Linear],
+    exclude_children_of: Optional[List[Type[nn.Module]]] = [
+        LoraInjectedLinear,
+        LoraInjectedConv2d,
+    ],
+):
+    """
+    Find all modules of a certain class (or union of classes) that are direct or
+    indirect descendants of other modules of a certain class (or union of classes).
+
+    Returns all matching modules, along with the parent of those moduless and the
+    names they are referenced by.
+    """
+
+    # Get the targets we should replace all linears under
+    if type(ancestor_class) is not set:
+        ancestor_class = set(ancestor_class)
+        print(ancestor_class)
+    if ancestor_class is not None:
+        ancestors = (
+            module
+            for module in model.modules()
+            if module.__class__.__name__ in ancestor_class
+        )
+    else:
+        # this, incase you want to naively iterate over all modules.
+        ancestors = [module for module in model.modules()]
+
+    # For each target find every linear_class module that isn't a child of a LoraInjectedLinear
+    for ancestor in ancestors:
+        for fullname, module in ancestor.named_children():
+            if any([isinstance(module, _class) for _class in search_class]):
+                # Find the direct parent if this is a descendant, not a child, of target
+                *path, name = fullname.split(".")
+                parent = ancestor
+                while path:
+                    parent = parent.get_submodule(path.pop(0))
+                # Skip this linear if it's a child of a LoraInjectedLinear
+                if exclude_children_of and any(
+                    [isinstance(parent, _class) for _class in exclude_children_of]
+                ):
+                    continue
+                # Otherwise, yield it
+                yield parent, name, module
+
+
+def _find_modules_old(
+    model,
+    ancestor_class: Set[str] = DEFAULT_TARGET_REPLACE,
+    search_class: List[Type[nn.Module]] = [nn.Linear],
+    exclude_children_of: Optional[List[Type[nn.Module]]] = [LoraInjectedLinear],
+):
+    ret = []
+    for _module in model.modules():
+        if _module.__class__.__name__ in ancestor_class:
+
+            for name, _child_module in _module.named_children():
+                if _child_module.__class__ in search_class:
+                    ret.append((_module, name, _child_module))
+    print(ret)
+    return ret
+
+
+_find_modules = _find_modules_v2
+
+
+def inject_trainable_lora(
+    model: nn.Module,
+    target_replace_module: Set[str] = DEFAULT_TARGET_REPLACE,
+    r: int = 4,
+    loras=None,  # path to lora .pt
+    verbose: bool = False,
+    dropout_p: float = 0.0,
+    scale: float = 1.0,
+):
+    """
+    inject lora into model, and returns lora parameter groups.
+    """
+
+    require_grad_params = []
+    names = []
+
+    if loras != None:
+        loras = torch.load(loras)
+
+    for _module, name, _child_module in _find_modules(
+        model, target_replace_module, search_class=[nn.Linear]
+    ):
+        weight = _child_module.weight
+        bias = _child_module.bias
+        if verbose:
+            print("LoRA Injection : injecting lora into ", name)
+            print("LoRA Injection : weight shape", weight.shape)
+        _tmp = LoraInjectedLinear(
+            _child_module.in_features,
+            _child_module.out_features,
+            _child_module.bias is not None,
+            r=r,
+            dropout_p=dropout_p,
+            scale=scale,
+        )
+        _tmp.linear.weight = weight
+        if bias is not None:
+            _tmp.linear.bias = bias
+
+        # switch the module
+        _tmp.to(_child_module.weight.device).to(_child_module.weight.dtype)
+        _module._modules[name] = _tmp
+
+        require_grad_params.append(_module._modules[name].lora_up.parameters())
+        require_grad_params.append(_module._modules[name].lora_down.parameters())
+
+        if loras != None:
+            _module._modules[name].lora_up.weight = loras.pop(0)
+            _module._modules[name].lora_down.weight = loras.pop(0)
+
+        _module._modules[name].lora_up.weight.requires_grad = True
+        _module._modules[name].lora_down.weight.requires_grad = True
+        names.append(name)
+
+    return require_grad_params, names
+
+
+def inject_trainable_lora_extended(
+    model: nn.Module,
+    target_replace_module: Set[str] = UNET_EXTENDED_TARGET_REPLACE,
+    r: int = 4,
+    loras=None,  # path to lora .pt
+):
+    """
+    inject lora into model, and returns lora parameter groups.
+    """
+
+    require_grad_params = []
+    names = []
+
+    if loras != None:
+        loras = torch.load(loras)
+
+    for _module, name, _child_module in _find_modules(
+        model, target_replace_module, search_class=[nn.Linear, nn.Conv2d]
+    ):
+        if _child_module.__class__ == nn.Linear:
+            weight = _child_module.weight
+            bias = _child_module.bias
+            _tmp = LoraInjectedLinear(
+                _child_module.in_features,
+                _child_module.out_features,
+                _child_module.bias is not None,
+                r=r,
+            )
+            _tmp.linear.weight = weight
+            if bias is not None:
+                _tmp.linear.bias = bias
+        elif _child_module.__class__ == nn.Conv2d:
+            weight = _child_module.weight
+            bias = _child_module.bias
+            _tmp = LoraInjectedConv2d(
+                _child_module.in_channels,
+                _child_module.out_channels,
+                _child_module.kernel_size,
+                _child_module.stride,
+                _child_module.padding,
+                _child_module.dilation,
+                _child_module.groups,
+                _child_module.bias is not None,
+                r=r,
+            )
+
+            _tmp.conv.weight = weight
+            if bias is not None:
+                _tmp.conv.bias = bias
+
+        # switch the module
+        _tmp.to(_child_module.weight.device).to(_child_module.weight.dtype)
+        if bias is not None:
+            _tmp.to(_child_module.bias.device).to(_child_module.bias.dtype)
+
+        _module._modules[name] = _tmp
+
+        require_grad_params.append(_module._modules[name].lora_up.parameters())
+        require_grad_params.append(_module._modules[name].lora_down.parameters())
+
+        if loras != None:
+            _module._modules[name].lora_up.weight = loras.pop(0)
+            _module._modules[name].lora_down.weight = loras.pop(0)
+
+        _module._modules[name].lora_up.weight.requires_grad = True
+        _module._modules[name].lora_down.weight.requires_grad = True
+        names.append(name)
+
+    return require_grad_params, names
+
+
+def extract_lora_ups_down(model, target_replace_module=DEFAULT_TARGET_REPLACE):
+
+    loras = []
+
+    for _m, _n, _child_module in _find_modules(
+        model,
+        target_replace_module,
+        search_class=[LoraInjectedLinear, LoraInjectedConv2d],
+    ):
+        loras.append((_child_module.lora_up, _child_module.lora_down))
+
+    if len(loras) == 0:
+        raise ValueError("No lora injected.")
+
+    return loras
+
+
+def extract_lora_as_tensor(
+    model, target_replace_module=DEFAULT_TARGET_REPLACE, as_fp16=True
+):
+
+    loras = []
+
+    for _m, _n, _child_module in _find_modules(
+        model,
+        target_replace_module,
+        search_class=[LoraInjectedLinear, LoraInjectedConv2d],
+    ):
+        up, down = _child_module.realize_as_lora()
+        if as_fp16:
+            up = up.to(torch.float16)
+            down = down.to(torch.float16)
+
+        loras.append((up, down))
+
+    if len(loras) == 0:
+        raise ValueError("No lora injected.")
+
+    return loras
+
+
+def save_lora_weight(
+    model,
+    path="./lora.pt",
+    target_replace_module=DEFAULT_TARGET_REPLACE,
+):
+    weights = []
+    for _up, _down in extract_lora_ups_down(
+        model, target_replace_module=target_replace_module
+    ):
+        weights.append(_up.weight.to("cpu").to(torch.float16))
+        weights.append(_down.weight.to("cpu").to(torch.float16))
+
+    torch.save(weights, path)
+
+
+def save_lora_as_json(model, path="./lora.json"):
+    weights = []
+    for _up, _down in extract_lora_ups_down(model):
+        weights.append(_up.weight.detach().cpu().numpy().tolist())
+        weights.append(_down.weight.detach().cpu().numpy().tolist())
+
+    import json
+
+    with open(path, "w") as f:
+        json.dump(weights, f)
+
+
+def save_safeloras_with_embeds(
+    modelmap: Dict[str, Tuple[nn.Module, Set[str]]] = {},
+    embeds: Dict[str, torch.Tensor] = {},
+    outpath="./lora.safetensors",
+):
+    """
+    Saves the Lora from multiple modules in a single safetensor file.
+
+    modelmap is a dictionary of {
+        "module name": (module, target_replace_module)
+    }
+    """
+    weights = {}
+    metadata = {}
+
+    for name, (model, target_replace_module) in modelmap.items():
+        metadata[name] = json.dumps(list(target_replace_module))
+
+        for i, (_up, _down) in enumerate(
+            extract_lora_as_tensor(model, target_replace_module)
+        ):
+            rank = _down.shape[0]
+
+            metadata[f"{name}:{i}:rank"] = str(rank)
+            weights[f"{name}:{i}:up"] = _up
+            weights[f"{name}:{i}:down"] = _down
+
+    for token, tensor in embeds.items():
+        metadata[token] = EMBED_FLAG
+        weights[token] = tensor
+
+    print(f"Saving weights to {outpath}")
+    safe_save(weights, outpath, metadata)
+
+
+def save_safeloras(
+    modelmap: Dict[str, Tuple[nn.Module, Set[str]]] = {},
+    outpath="./lora.safetensors",
+):
+    return save_safeloras_with_embeds(modelmap=modelmap, outpath=outpath)
+
+
+def convert_loras_to_safeloras_with_embeds(
+    modelmap: Dict[str, Tuple[str, Set[str], int]] = {},
+    embeds: Dict[str, torch.Tensor] = {},
+    outpath="./lora.safetensors",
+):
+    """
+    Converts the Lora from multiple pytorch .pt files into a single safetensor file.
+
+    modelmap is a dictionary of {
+        "module name": (pytorch_model_path, target_replace_module, rank)
+    }
+    """
+
+    weights = {}
+    metadata = {}
+
+    for name, (path, target_replace_module, r) in modelmap.items():
+        metadata[name] = json.dumps(list(target_replace_module))
+
+        lora = torch.load(path)
+        for i, weight in enumerate(lora):
+            is_up = i % 2 == 0
+            i = i // 2
+
+            if is_up:
+                metadata[f"{name}:{i}:rank"] = str(r)
+                weights[f"{name}:{i}:up"] = weight
+            else:
+                weights[f"{name}:{i}:down"] = weight
+
+    for token, tensor in embeds.items():
+        metadata[token] = EMBED_FLAG
+        weights[token] = tensor
+
+    print(f"Saving weights to {outpath}")
+    safe_save(weights, outpath, metadata)
+
+
+def convert_loras_to_safeloras(
+    modelmap: Dict[str, Tuple[str, Set[str], int]] = {},
+    outpath="./lora.safetensors",
+):
+    convert_loras_to_safeloras_with_embeds(modelmap=modelmap, outpath=outpath)
+
+
+def parse_safeloras(
+    safeloras,
+) -> Dict[str, Tuple[List[nn.parameter.Parameter], List[int], List[str]]]:
+    """
+    Converts a loaded safetensor file that contains a set of module Loras
+    into Parameters and other information
+
+    Output is a dictionary of {
+        "module name": (
+            [list of weights],
+            [list of ranks],
+            target_replacement_modules
+        )
+    }
+    """
+    loras = {}
+    metadata = safeloras.metadata()
+
+    get_name = lambda k: k.split(":")[0]
+
+    keys = list(safeloras.keys())
+    keys.sort(key=get_name)
+
+    for name, module_keys in groupby(keys, get_name):
+        info = metadata.get(name)
+
+        if not info:
+            raise ValueError(
+                f"Tensor {name} has no metadata - is this a Lora safetensor?"
+            )
+
+        # Skip Textual Inversion embeds
+        if info == EMBED_FLAG:
+            continue
+
+        # Handle Loras
+        # Extract the targets
+        target = json.loads(info)
+
+        # Build the result lists - Python needs us to preallocate lists to insert into them
+        module_keys = list(module_keys)
+        ranks = [4] * (len(module_keys) // 2)
+        weights = [None] * len(module_keys)
+
+        for key in module_keys:
+            # Split the model name and index out of the key
+            _, idx, direction = key.split(":")
+            idx = int(idx)
+
+            # Add the rank
+            ranks[idx] = int(metadata[f"{name}:{idx}:rank"])
+
+            # Insert the weight into the list
+            idx = idx * 2 + (1 if direction == "down" else 0)
+            weights[idx] = nn.parameter.Parameter(safeloras.get_tensor(key))
+
+        loras[name] = (weights, ranks, target)
+
+    return loras
+
+
+def parse_safeloras_embeds(
+    safeloras,
+) -> Dict[str, torch.Tensor]:
+    """
+    Converts a loaded safetensor file that contains Textual Inversion embeds into
+    a dictionary of embed_token: Tensor
+    """
+    embeds = {}
+    metadata = safeloras.metadata()
+
+    for key in safeloras.keys():
+        # Only handle Textual Inversion embeds
+        meta = metadata.get(key)
+        if not meta or meta != EMBED_FLAG:
+            continue
+
+        embeds[key] = safeloras.get_tensor(key)
+
+    return embeds
+
+def net_load_lora(net, checkpoint_path, alpha=1.0, remove=False):
+    visited=[]
+    state_dict = torch.load(checkpoint_path)
+    for k, v in state_dict.items():
+        state_dict[k] = v.to(net.device)
+    # import pdb;pdb.set_trace()
+    for key in state_dict:
+        if ".alpha" in key or key in visited:
+            continue
+        layer_infos = key.split(".")[:-2] # remove lora_up and down weight
+        curr_layer = net
+        # find the target layer
+        temp_name = layer_infos.pop(0)
+        while len(layer_infos) > -1:
+            curr_layer = curr_layer.__getattr__(temp_name)
+            if len(layer_infos) > 0:
+                temp_name = layer_infos.pop(0)
+            elif len(layer_infos) == 0:
+                break
+        if curr_layer.__class__ not in [nn.Linear, nn.Conv2d]:
+            print('missing param at:', key)
+            continue
+        pair_keys = []
+        if "lora_down" in key:
+            pair_keys.append(key.replace("lora_down", "lora_up"))
+            pair_keys.append(key)
+        else:
+            pair_keys.append(key)
+            pair_keys.append(key.replace("lora_up", "lora_down"))
+
+        # update weight
+        if len(state_dict[pair_keys[0]].shape) == 4:
+            # for conv
+            weight_up = state_dict[pair_keys[0]].squeeze(3).squeeze(2).to(torch.float32)
+            weight_down = state_dict[pair_keys[1]].squeeze(3).squeeze(2).to(torch.float32)
+            if remove:
+                curr_layer.weight.data -= alpha * torch.mm(weight_up, weight_down).unsqueeze(2).unsqueeze(3)
+            else:
+                curr_layer.weight.data += alpha * torch.mm(weight_up, weight_down).unsqueeze(2).unsqueeze(3)
+        else:
+            # for linear
+            weight_up = state_dict[pair_keys[0]].to(torch.float32)
+            weight_down = state_dict[pair_keys[1]].to(torch.float32)
+            if remove:
+                curr_layer.weight.data -= alpha * torch.mm(weight_up, weight_down)
+            else:
+                curr_layer.weight.data += alpha * torch.mm(weight_up, weight_down)
+
+        # update visited list
+        for item in pair_keys:
+            visited.append(item)
+    print('load_weight_num:',len(visited))
+    return 
+
+def change_lora(model, inject_lora=False, lora_scale=1.0, lora_path='', last_time_lora='', last_time_lora_scale=1.0):
+    # remove lora
+    if last_time_lora != '':
+        net_load_lora(model, last_time_lora, alpha=last_time_lora_scale, remove=True)
+    # add new lora
+    if inject_lora:
+        net_load_lora(model, lora_path, alpha=lora_scale)
+
+
+
+def load_safeloras(path, device="cpu"):
+    safeloras = safe_open(path, framework="pt", device=device)
+    return parse_safeloras(safeloras)
+
+
+def load_safeloras_embeds(path, device="cpu"):
+    safeloras = safe_open(path, framework="pt", device=device)
+    return parse_safeloras_embeds(safeloras)
+
+
+def load_safeloras_both(path, device="cpu"):
+    safeloras = safe_open(path, framework="pt", device=device)
+    return parse_safeloras(safeloras), parse_safeloras_embeds(safeloras)
+
+
+def collapse_lora(model, alpha=1.0):
+
+    for _module, name, _child_module in _find_modules(
+        model,
+        UNET_EXTENDED_TARGET_REPLACE | TEXT_ENCODER_EXTENDED_TARGET_REPLACE,
+        search_class=[LoraInjectedLinear, LoraInjectedConv2d],
+    ):
+
+        if isinstance(_child_module, LoraInjectedLinear):
+            print("Collapsing Lin Lora in", name)
+
+            _child_module.linear.weight = nn.Parameter(
+                _child_module.linear.weight.data
+                + alpha
+                * (
+                    _child_module.lora_up.weight.data
+                    @ _child_module.lora_down.weight.data
+                )
+                .type(_child_module.linear.weight.dtype)
+                .to(_child_module.linear.weight.device)
+            )
+
+        else:
+            print("Collapsing Conv Lora in", name)
+            _child_module.conv.weight = nn.Parameter(
+                _child_module.conv.weight.data
+                + alpha
+                * (
+                    _child_module.lora_up.weight.data.flatten(start_dim=1)
+                    @ _child_module.lora_down.weight.data.flatten(start_dim=1)
+                )
+                .reshape(_child_module.conv.weight.data.shape)
+                .type(_child_module.conv.weight.dtype)
+                .to(_child_module.conv.weight.device)
+            )
+
+
+def monkeypatch_or_replace_lora(
+    model,
+    loras,
+    target_replace_module=DEFAULT_TARGET_REPLACE,
+    r: Union[int, List[int]] = 4,
+):
+    for _module, name, _child_module in _find_modules(
+        model, target_replace_module, search_class=[nn.Linear, LoraInjectedLinear]
+    ):
+        _source = (
+            _child_module.linear
+            if isinstance(_child_module, LoraInjectedLinear)
+            else _child_module
+        )
+
+        weight = _source.weight
+        bias = _source.bias
+        _tmp = LoraInjectedLinear(
+            _source.in_features,
+            _source.out_features,
+            _source.bias is not None,
+            r=r.pop(0) if isinstance(r, list) else r,
+        )
+        _tmp.linear.weight = weight
+
+        if bias is not None:
+            _tmp.linear.bias = bias
+
+        # switch the module
+        _module._modules[name] = _tmp
+
+        up_weight = loras.pop(0)
+        down_weight = loras.pop(0)
+
+        _module._modules[name].lora_up.weight = nn.Parameter(
+            up_weight.type(weight.dtype)
+        )
+        _module._modules[name].lora_down.weight = nn.Parameter(
+            down_weight.type(weight.dtype)
+        )
+
+        _module._modules[name].to(weight.device)
+
+
+def monkeypatch_or_replace_lora_extended(
+    model,
+    loras,
+    target_replace_module=DEFAULT_TARGET_REPLACE,
+    r: Union[int, List[int]] = 4,
+):
+    for _module, name, _child_module in _find_modules(
+        model,
+        target_replace_module,
+        search_class=[nn.Linear, LoraInjectedLinear, nn.Conv2d, LoraInjectedConv2d],
+    ):
+
+        if (_child_module.__class__ == nn.Linear) or (
+            _child_module.__class__ == LoraInjectedLinear
+        ):
+            if len(loras[0].shape) != 2:
+                continue
+
+            _source = (
+                _child_module.linear
+                if isinstance(_child_module, LoraInjectedLinear)
+                else _child_module
+            )
+
+            weight = _source.weight
+            bias = _source.bias
+            _tmp = LoraInjectedLinear(
+                _source.in_features,
+                _source.out_features,
+                _source.bias is not None,
+                r=r.pop(0) if isinstance(r, list) else r,
+            )
+            _tmp.linear.weight = weight
+
+            if bias is not None:
+                _tmp.linear.bias = bias
+
+        elif (_child_module.__class__ == nn.Conv2d) or (
+            _child_module.__class__ == LoraInjectedConv2d
+        ):
+            if len(loras[0].shape) != 4:
+                continue
+            _source = (
+                _child_module.conv
+                if isinstance(_child_module, LoraInjectedConv2d)
+                else _child_module
+            )
+
+            weight = _source.weight
+            bias = _source.bias
+            _tmp = LoraInjectedConv2d(
+                _source.in_channels,
+                _source.out_channels,
+                _source.kernel_size,
+                _source.stride,
+                _source.padding,
+                _source.dilation,
+                _source.groups,
+                _source.bias is not None,
+                r=r.pop(0) if isinstance(r, list) else r,
+            )
+
+            _tmp.conv.weight = weight
+
+            if bias is not None:
+                _tmp.conv.bias = bias
+
+        # switch the module
+        _module._modules[name] = _tmp
+
+        up_weight = loras.pop(0)
+        down_weight = loras.pop(0)
+
+        _module._modules[name].lora_up.weight = nn.Parameter(
+            up_weight.type(weight.dtype)
+        )
+        _module._modules[name].lora_down.weight = nn.Parameter(
+            down_weight.type(weight.dtype)
+        )
+
+        _module._modules[name].to(weight.device)
+
+
+def monkeypatch_or_replace_safeloras(models, safeloras):
+    loras = parse_safeloras(safeloras)
+
+    for name, (lora, ranks, target) in loras.items():
+        model = getattr(models, name, None)
+
+        if not model:
+            print(f"No model provided for {name}, contained in Lora")
+            continue
+
+        monkeypatch_or_replace_lora_extended(model, lora, target, ranks)
+
+
+def monkeypatch_remove_lora(model):
+    for _module, name, _child_module in _find_modules(
+        model, search_class=[LoraInjectedLinear, LoraInjectedConv2d]
+    ):
+        if isinstance(_child_module, LoraInjectedLinear):
+            _source = _child_module.linear
+            weight, bias = _source.weight, _source.bias
+
+            _tmp = nn.Linear(
+                _source.in_features, _source.out_features, bias is not None
+            )
+
+            _tmp.weight = weight
+            if bias is not None:
+                _tmp.bias = bias
+
+        else:
+            _source = _child_module.conv
+            weight, bias = _source.weight, _source.bias
+
+            _tmp = nn.Conv2d(
+                in_channels=_source.in_channels,
+                out_channels=_source.out_channels,
+                kernel_size=_source.kernel_size,
+                stride=_source.stride,
+                padding=_source.padding,
+                dilation=_source.dilation,
+                groups=_source.groups,
+                bias=bias is not None,
+            )
+
+            _tmp.weight = weight
+            if bias is not None:
+                _tmp.bias = bias
+
+        _module._modules[name] = _tmp
+
+
+def monkeypatch_add_lora(
+    model,
+    loras,
+    target_replace_module=DEFAULT_TARGET_REPLACE,
+    alpha: float = 1.0,
+    beta: float = 1.0,
+):
+    for _module, name, _child_module in _find_modules(
+        model, target_replace_module, search_class=[LoraInjectedLinear]
+    ):
+        weight = _child_module.linear.weight
+
+        up_weight = loras.pop(0)
+        down_weight = loras.pop(0)
+
+        _module._modules[name].lora_up.weight = nn.Parameter(
+            up_weight.type(weight.dtype).to(weight.device) * alpha
+            + _module._modules[name].lora_up.weight.to(weight.device) * beta
+        )
+        _module._modules[name].lora_down.weight = nn.Parameter(
+            down_weight.type(weight.dtype).to(weight.device) * alpha
+            + _module._modules[name].lora_down.weight.to(weight.device) * beta
+        )
+
+        _module._modules[name].to(weight.device)
+
+
+def tune_lora_scale(model, alpha: float = 1.0):
+    for _module in model.modules():
+        if _module.__class__.__name__ in ["LoraInjectedLinear", "LoraInjectedConv2d"]:
+            _module.scale = alpha
+
+
+def set_lora_diag(model, diag: torch.Tensor):
+    for _module in model.modules():
+        if _module.__class__.__name__ in ["LoraInjectedLinear", "LoraInjectedConv2d"]:
+            _module.set_selector_from_diag(diag)
+
+
+def _text_lora_path(path: str) -> str:
+    assert path.endswith(".pt"), "Only .pt files are supported"
+    return ".".join(path.split(".")[:-1] + ["text_encoder", "pt"])
+
+
+def _ti_lora_path(path: str) -> str:
+    assert path.endswith(".pt"), "Only .pt files are supported"
+    return ".".join(path.split(".")[:-1] + ["ti", "pt"])
+
+
+def apply_learned_embed_in_clip(
+    learned_embeds,
+    text_encoder,
+    tokenizer,
+    token: Optional[Union[str, List[str]]] = None,
+    idempotent=False,
+):
+    if isinstance(token, str):
+        trained_tokens = [token]
+    elif isinstance(token, list):
+        assert len(learned_embeds.keys()) == len(
+            token
+        ), "The number of tokens and the number of embeds should be the same"
+        trained_tokens = token
+    else:
+        trained_tokens = list(learned_embeds.keys())
+
+    for token in trained_tokens:
+        print(token)
+        embeds = learned_embeds[token]
+
+        # cast to dtype of text_encoder
+        dtype = text_encoder.get_input_embeddings().weight.dtype
+        num_added_tokens = tokenizer.add_tokens(token)
+
+        i = 1
+        if not idempotent:
+            while num_added_tokens == 0:
+                print(f"The tokenizer already contains the token {token}.")
+                token = f"{token[:-1]}-{i}>"
+                print(f"Attempting to add the token {token}.")
+                num_added_tokens = tokenizer.add_tokens(token)
+                i += 1
+        elif num_added_tokens == 0 and idempotent:
+            print(f"The tokenizer already contains the token {token}.")
+            print(f"Replacing {token} embedding.")
+
+        # resize the token embeddings
+        text_encoder.resize_token_embeddings(len(tokenizer))
+
+        # get the id for the token and assign the embeds
+        token_id = tokenizer.convert_tokens_to_ids(token)
+        text_encoder.get_input_embeddings().weight.data[token_id] = embeds
+    return token
+
+
+def load_learned_embed_in_clip(
+    learned_embeds_path,
+    text_encoder,
+    tokenizer,
+    token: Optional[Union[str, List[str]]] = None,
+    idempotent=False,
+):
+    learned_embeds = torch.load(learned_embeds_path)
+    apply_learned_embed_in_clip(
+        learned_embeds, text_encoder, tokenizer, token, idempotent
+    )
+
+
+def patch_pipe(
+    pipe,
+    maybe_unet_path,
+    token: Optional[str] = None,
+    r: int = 4,
+    patch_unet=True,
+    patch_text=True,
+    patch_ti=True,
+    idempotent_token=True,
+    unet_target_replace_module=DEFAULT_TARGET_REPLACE,
+    text_target_replace_module=TEXT_ENCODER_DEFAULT_TARGET_REPLACE,
+):
+    if maybe_unet_path.endswith(".pt"):
+        # torch format
+
+        if maybe_unet_path.endswith(".ti.pt"):
+            unet_path = maybe_unet_path[:-6] + ".pt"
+        elif maybe_unet_path.endswith(".text_encoder.pt"):
+            unet_path = maybe_unet_path[:-16] + ".pt"
+        else:
+            unet_path = maybe_unet_path
+
+        ti_path = _ti_lora_path(unet_path)
+        text_path = _text_lora_path(unet_path)
+
+        if patch_unet:
+            print("LoRA : Patching Unet")
+            monkeypatch_or_replace_lora(
+                pipe.unet,
+                torch.load(unet_path),
+                r=r,
+                target_replace_module=unet_target_replace_module,
+            )
+
+        if patch_text:
+            print("LoRA : Patching text encoder")
+            monkeypatch_or_replace_lora(
+                pipe.text_encoder,
+                torch.load(text_path),
+                target_replace_module=text_target_replace_module,
+                r=r,
+            )
+        if patch_ti:
+            print("LoRA : Patching token input")
+            token = load_learned_embed_in_clip(
+                ti_path,
+                pipe.text_encoder,
+                pipe.tokenizer,
+                token=token,
+                idempotent=idempotent_token,
+            )
+
+    elif maybe_unet_path.endswith(".safetensors"):
+        safeloras = safe_open(maybe_unet_path, framework="pt", device="cpu")
+        monkeypatch_or_replace_safeloras(pipe, safeloras)
+        tok_dict = parse_safeloras_embeds(safeloras)
+        if patch_ti:
+            apply_learned_embed_in_clip(
+                tok_dict,
+                pipe.text_encoder,
+                pipe.tokenizer,
+                token=token,
+                idempotent=idempotent_token,
+            )
+        return tok_dict
+
+
+@torch.no_grad()
+def inspect_lora(model):
+    moved = {}
+
+    for name, _module in model.named_modules():
+        if _module.__class__.__name__ in ["LoraInjectedLinear", "LoraInjectedConv2d"]:
+            ups = _module.lora_up.weight.data.clone()
+            downs = _module.lora_down.weight.data.clone()
+
+            wght: torch.Tensor = ups.flatten(1) @ downs.flatten(1)
+
+            dist = wght.flatten().abs().mean().item()
+            if name in moved:
+                moved[name].append(dist)
+            else:
+                moved[name] = [dist]
+
+    return moved
+
+
+def save_all(
+    unet,
+    text_encoder,
+    save_path,
+    placeholder_token_ids=None,
+    placeholder_tokens=None,
+    save_lora=True,
+    save_ti=True,
+    target_replace_module_text=TEXT_ENCODER_DEFAULT_TARGET_REPLACE,
+    target_replace_module_unet=DEFAULT_TARGET_REPLACE,
+    safe_form=True,
+):
+    if not safe_form:
+        # save ti
+        if save_ti:
+            ti_path = _ti_lora_path(save_path)
+            learned_embeds_dict = {}
+            for tok, tok_id in zip(placeholder_tokens, placeholder_token_ids):
+                learned_embeds = text_encoder.get_input_embeddings().weight[tok_id]
+                print(
+                    f"Current Learned Embeddings for {tok}:, id {tok_id} ",
+                    learned_embeds[:4],
+                )
+                learned_embeds_dict[tok] = learned_embeds.detach().cpu()
+
+            torch.save(learned_embeds_dict, ti_path)
+            print("Ti saved to ", ti_path)
+
+        # save text encoder
+        if save_lora:
+
+            save_lora_weight(
+                unet, save_path, target_replace_module=target_replace_module_unet
+            )
+            print("Unet saved to ", save_path)
+
+            save_lora_weight(
+                text_encoder,
+                _text_lora_path(save_path),
+                target_replace_module=target_replace_module_text,
+            )
+            print("Text Encoder saved to ", _text_lora_path(save_path))
+
+    else:
+        assert save_path.endswith(
+            ".safetensors"
+        ), f"Save path : {save_path} should end with .safetensors"
+
+        loras = {}
+        embeds = {}
+
+        if save_lora:
+
+            loras["unet"] = (unet, target_replace_module_unet)
+            loras["text_encoder"] = (text_encoder, target_replace_module_text)
+
+        if save_ti:
+            for tok, tok_id in zip(placeholder_tokens, placeholder_token_ids):
+                learned_embeds = text_encoder.get_input_embeddings().weight[tok_id]
+                print(
+                    f"Current Learned Embeddings for {tok}:, id {tok_id} ",
+                    learned_embeds[:4],
+                )
+                embeds[tok] = learned_embeds.detach().cpu()
+
+        save_safeloras_with_embeds(loras, embeds, save_path)

lvdm/models/modules/openaimodel3d.py

@@ -0,0 +1,662 @@
+from abc import abstractmethod
+import math
+from einops import rearrange
+from functools import partial
+import numpy as np
+import torch as th
+import torch.nn as nn
+import torch.nn.functional as F
+from omegaconf.listconfig import ListConfig
+
+from lvdm.models.modules.util import (
+    checkpoint,
+    conv_nd,
+    linear,
+    avg_pool_nd,
+    zero_module,
+    normalization,
+    timestep_embedding,
+    nonlinearity,
+)
+
+# dummy replace
+def convert_module_to_f16(x):
+    pass
+
+def convert_module_to_f32(x):
+    pass
+
+## go
+# ---------------------------------------------------------------------------------------------------
+class TimestepBlock(nn.Module):
+    """
+    Any module where forward() takes timestep embeddings as a second argument.
+    """
+
+    @abstractmethod
+    def forward(self, x, emb):
+        """
+        Apply the module to `x` given `emb` timestep embeddings.
+        """
+
+
+# ---------------------------------------------------------------------------------------------------
+class TimestepEmbedSequential(nn.Sequential, TimestepBlock):
+    """
+    A sequential module that passes timestep embeddings to the children that
+    support it as an extra input.
+    """
+
+    def forward(self, x, emb, context, **kwargs):
+        for layer in self:
+            if isinstance(layer, TimestepBlock):
+                x = layer(x, emb, **kwargs)
+            elif isinstance(layer, STTransformerClass):
+                x = layer(x, context, **kwargs)
+            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, 
+        kernel_size_t=3,
+        padding_t=1,
+    ):
+        super().__init__()
+        self.channels = channels
+        self.out_channels = out_channels or channels
+        self.use_conv = use_conv
+        self.dims = dims
+        if use_conv:
+            self.conv = conv_nd(dims, self.channels, self.out_channels, (kernel_size_t, 3,3), padding=(padding_t, 1,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 TransposedUpsample(nn.Module):
+    'Learned 2x upsampling without padding'
+    def __init__(self, channels, out_channels=None, ks=5):
+        super().__init__()
+        self.channels = channels
+        self.out_channels = out_channels or channels
+
+        self.up = nn.ConvTranspose2d(self.channels,self.out_channels,kernel_size=ks,stride=2)
+
+    def forward(self,x):
+        return self.up(x)
+
+
+# ---------------------------------------------------------------------------------------------------
+class Downsample(nn.Module):
+    """
+    A downsampling layer with an optional convolution.
+    :param channels: channels in the inputs and outputs.
+    :param use_conv: a bool determining if a convolution is applied.
+    :param dims: determines if the signal is 1D, 2D, or 3D. If 3D, then
+                 downsampling occurs in the inner-two dimensions.
+    """
+
+    def __init__(self, channels, use_conv, dims=2, out_channels=None,
+        kernel_size_t=3,
+        padding_t=1,
+    ):
+        super().__init__()
+        self.channels = channels
+        self.out_channels = out_channels or channels
+        self.use_conv = use_conv
+        self.dims = dims
+        stride = 2 if dims != 3 else (1, 2, 2)
+        if use_conv:
+            self.op = conv_nd(
+                dims, self.channels, self.out_channels, (kernel_size_t, 3,3), stride=stride, padding=(padding_t, 1,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,
+        # temporal
+        kernel_size_t=3,
+        padding_t=1,
+        nonlinearity_type='silu',
+        **kwargs
+    ):
+        super().__init__()
+        self.channels = channels
+        self.emb_channels = emb_channels
+        self.dropout = dropout
+        self.out_channels = out_channels or channels
+        self.use_conv = use_conv
+        self.use_checkpoint = use_checkpoint
+        self.use_scale_shift_norm = use_scale_shift_norm
+        self.nonlinearity_type = nonlinearity_type
+
+        self.in_layers = nn.Sequential(
+            normalization(channels),
+            nonlinearity(nonlinearity_type),
+            conv_nd(dims, channels, self.out_channels, (kernel_size_t, 3,3), padding=(padding_t, 1,1)),
+        )
+
+        self.updown = up or down
+
+        if up:
+            self.h_upd = Upsample(channels, False, dims, kernel_size_t=kernel_size_t, padding_t=padding_t)
+            self.x_upd = Upsample(channels, False, dims, kernel_size_t=kernel_size_t, padding_t=padding_t)
+        elif down:
+            self.h_upd = Downsample(channels, False, dims, kernel_size_t=kernel_size_t, padding_t=padding_t)
+            self.x_upd = Downsample(channels, False, dims, kernel_size_t=kernel_size_t, padding_t=padding_t)
+        else:
+            self.h_upd = self.x_upd = nn.Identity()
+
+        self.emb_layers = nn.Sequential(
+            nonlinearity(nonlinearity_type),
+            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),
+            nonlinearity(nonlinearity_type),
+            nn.Dropout(p=dropout),
+            zero_module(
+                conv_nd(dims, self.out_channels, self.out_channels, (kernel_size_t, 3,3), padding=(padding_t, 1,1))
+            ),
+        )
+
+        if self.out_channels == channels:
+            self.skip_connection = nn.Identity()
+        elif use_conv:
+            self.skip_connection = conv_nd(
+                dims, channels, self.out_channels, (kernel_size_t, 3,3), padding=(padding_t, 1,1)
+            )
+        else:
+            self.skip_connection = conv_nd(dims, channels, self.out_channels, 1)
+        
+
+    def forward(self, x, emb, **kwargs):
+        """
+        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)
+        if emb_out.dim() == 3: # btc for video data
+            emb_out = rearrange(emb_out, 'b t c -> b c t')
+        while len(emb_out.shape) < h.dim():
+            emb_out = emb_out[..., None] # bct -> bct11 or bc -> bc111
+        
+        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)
+
+        out = self.skip_connection(x) + h
+        
+        return out
+
+# ---------------------------------------------------------------------------------------------------
+def make_spatialtemporal_transformer(module_name='attention_temporal', class_name='SpatialTemporalTransformer'):
+    module = __import__(f"lvdm.models.modules.{module_name}", fromlist=[class_name])
+    global STTransformerClass
+    STTransformerClass = getattr(module, class_name)
+    return STTransformerClass
+
+# ---------------------------------------------------------------------------------------------------
+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, # not used in UNetModel
+        in_channels,
+        model_channels,
+        out_channels,
+        num_res_blocks,
+        attention_resolutions,
+        dropout=0,
+        channel_mult=(1, 2, 4, 8),
+        conv_resample=True,
+        dims=3,
+        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,
+        transformer_depth=1,              # custom transformer support
+        context_dim=None,                 # custom transformer support
+        legacy=True,
+        # temporal related
+        kernel_size_t=1,
+        padding_t=1,
+        use_temporal_transformer=True,
+        temporal_length=None,
+        use_relative_position=False,
+        cross_attn_on_tempoal=False,
+        temporal_crossattn_type="crossattn",
+        order="stst",
+        nonlinearity_type='silu',
+        temporalcrossfirst=False,
+        split_stcontext=False,
+        temporal_context_dim=None,
+        use_tempoal_causal_attn=False,
+        ST_transformer_module='attention_temporal',
+        ST_transformer_class='SpatialTemporalTransformer',
+        **kwargs,
+    ):
+        super().__init__()
+        assert(use_temporal_transformer)
+        if context_dim is not None:
+            if type(context_dim) == ListConfig:
+                context_dim = list(context_dim)
+
+        if num_heads_upsample == -1:
+            num_heads_upsample = num_heads
+
+        if num_heads == -1:
+            assert num_head_channels != -1, 'Either num_heads or num_head_channels has to be set'
+
+        if num_head_channels == -1:
+            assert num_heads != -1, 'Either num_heads or num_head_channels has to be set'
+
+        self.image_size = image_size
+        self.in_channels = in_channels
+        self.model_channels = model_channels
+        self.out_channels = out_channels
+        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
+
+        self.use_relative_position = use_relative_position
+        self.temporal_length = temporal_length
+        self.cross_attn_on_tempoal = cross_attn_on_tempoal
+        self.temporal_crossattn_type = temporal_crossattn_type
+        self.order = order
+        self.temporalcrossfirst = temporalcrossfirst
+        self.split_stcontext = split_stcontext
+        self.temporal_context_dim = temporal_context_dim
+        self.nonlinearity_type = nonlinearity_type
+        self.use_tempoal_causal_attn = use_tempoal_causal_attn
+        
+
+        time_embed_dim = model_channels * 4
+        self.time_embed_dim = time_embed_dim
+        self.time_embed = nn.Sequential(
+            linear(model_channels, time_embed_dim),
+            nonlinearity(nonlinearity_type),
+            linear(time_embed_dim, time_embed_dim),
+        )
+
+        if self.num_classes is not None:
+            self.label_emb = nn.Embedding(num_classes, time_embed_dim)
+        
+        STTransformerClass = make_spatialtemporal_transformer(module_name=ST_transformer_module, 
+            class_name=ST_transformer_class)
+
+        self.input_blocks = nn.ModuleList(
+            [
+                TimestepEmbedSequential(
+                    conv_nd(dims, in_channels, model_channels, (kernel_size_t, 3,3), padding=(padding_t, 1,1))
+                )
+            ]
+        )
+        self._feature_size = model_channels
+        input_block_chans = [model_channels]
+        ch = model_channels
+        ds = 1
+        for level, mult in enumerate(channel_mult):
+            for _ in range(num_res_blocks):
+                layers = [
+                    ResBlock(
+                        ch,
+                        time_embed_dim,
+                        dropout,
+                        out_channels=mult * model_channels,
+                        dims=dims,
+                        use_checkpoint=use_checkpoint,
+                        use_scale_shift_norm=use_scale_shift_norm,
+                        kernel_size_t=kernel_size_t,
+                        padding_t=padding_t,
+                        nonlinearity_type=nonlinearity_type,
+                        **kwargs
+                    )
+                ]
+                ch = mult * model_channels
+                if ds in attention_resolutions:
+                    if num_head_channels == -1:
+                        dim_head = ch // num_heads
+                    else:
+                        num_heads = ch // num_head_channels
+                        dim_head = num_head_channels
+                    if legacy:
+                        dim_head = ch // num_heads if use_temporal_transformer else num_head_channels
+                    layers.append(STTransformerClass(
+                            ch, num_heads, dim_head, depth=transformer_depth, context_dim=context_dim,
+                            # temporal related
+                            temporal_length=temporal_length,
+                            use_relative_position=use_relative_position,
+                            cross_attn_on_tempoal=cross_attn_on_tempoal,
+                            temporal_crossattn_type=temporal_crossattn_type,
+                            order=order,
+                            temporalcrossfirst=temporalcrossfirst,
+                            split_stcontext=split_stcontext,
+                            temporal_context_dim=temporal_context_dim,
+                            use_tempoal_causal_attn=use_tempoal_causal_attn,
+                            **kwargs,
+                            ))
+                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,
+                            kernel_size_t=kernel_size_t,
+                            padding_t=padding_t,
+                            nonlinearity_type=nonlinearity_type,
+                            **kwargs
+                        )
+                        if resblock_updown
+                        else Downsample(
+                            ch, conv_resample, dims=dims, out_channels=out_ch, kernel_size_t=kernel_size_t, padding_t=padding_t
+                        )
+                    )
+                )
+                ch = out_ch
+                input_block_chans.append(ch)
+                ds *= 2
+                self._feature_size += ch
+
+        if num_head_channels == -1:
+            dim_head = ch // num_heads
+        else:
+            num_heads = ch // num_head_channels
+            dim_head = num_head_channels
+        if legacy:
+            dim_head = ch // num_heads if use_temporal_transformer else num_head_channels
+        self.middle_block = TimestepEmbedSequential(
+            ResBlock(
+                ch,
+                time_embed_dim,
+                dropout,
+                dims=dims,
+                use_checkpoint=use_checkpoint,
+                use_scale_shift_norm=use_scale_shift_norm,
+                kernel_size_t=kernel_size_t,
+                padding_t=padding_t,
+                nonlinearity_type=nonlinearity_type,
+                **kwargs
+            ),
+            STTransformerClass(
+                            ch, num_heads, dim_head, depth=transformer_depth, context_dim=context_dim,
+                            # temporal related
+                            temporal_length=temporal_length,
+                            use_relative_position=use_relative_position,
+                            cross_attn_on_tempoal=cross_attn_on_tempoal,
+                            temporal_crossattn_type=temporal_crossattn_type,
+                            order=order,
+                            temporalcrossfirst=temporalcrossfirst,
+                            split_stcontext=split_stcontext,
+                            temporal_context_dim=temporal_context_dim,
+                            use_tempoal_causal_attn=use_tempoal_causal_attn,
+                            **kwargs,
+                        ),
+            ResBlock(
+                ch,
+                time_embed_dim,
+                dropout,
+                dims=dims,
+                use_checkpoint=use_checkpoint,
+                use_scale_shift_norm=use_scale_shift_norm,
+                kernel_size_t=kernel_size_t,
+                padding_t=padding_t,
+                nonlinearity_type=nonlinearity_type,
+                **kwargs
+            ),
+        )
+        self._feature_size += ch
+
+        self.output_blocks = nn.ModuleList([])
+        for level, mult in list(enumerate(channel_mult))[::-1]:
+            for i in range(num_res_blocks + 1):
+                ich = input_block_chans.pop()
+                layers = [
+                    ResBlock(
+                        ch + ich,
+                        time_embed_dim,
+                        dropout,
+                        out_channels=model_channels * mult,
+                        dims=dims,
+                        use_checkpoint=use_checkpoint,
+                        use_scale_shift_norm=use_scale_shift_norm,
+                        kernel_size_t=kernel_size_t,
+                        padding_t=padding_t,
+                        nonlinearity_type=nonlinearity_type,
+                        **kwargs
+                    )
+                ]
+                ch = model_channels * mult
+                if ds in attention_resolutions:
+                    if num_head_channels == -1:
+                        dim_head = ch // num_heads
+                    else:
+                        num_heads = ch // num_head_channels
+                        dim_head = num_head_channels
+                    if legacy:
+                        dim_head = ch // num_heads if use_temporal_transformer else num_head_channels
+                    layers.append(
+                        STTransformerClass(
+                            ch, num_heads, dim_head, depth=transformer_depth, context_dim=context_dim,
+                            # temporal related
+                            temporal_length=temporal_length,
+                            use_relative_position=use_relative_position,
+                            cross_attn_on_tempoal=cross_attn_on_tempoal,
+                            temporal_crossattn_type=temporal_crossattn_type,
+                            order=order,
+                            temporalcrossfirst=temporalcrossfirst,
+                            split_stcontext=split_stcontext,
+                            temporal_context_dim=temporal_context_dim,
+                            use_tempoal_causal_attn=use_tempoal_causal_attn,
+                            **kwargs,
+                        )
+                    )
+                if level and i == num_res_blocks:
+                    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,
+                            kernel_size_t=kernel_size_t,
+                            padding_t=padding_t,
+                            nonlinearity_type=nonlinearity_type,
+                            **kwargs
+                        )
+                        if resblock_updown
+                        else Upsample(ch, conv_resample, dims=dims, out_channels=out_ch, kernel_size_t=kernel_size_t, padding_t=padding_t)
+                    )
+                    ds //= 2
+                self.output_blocks.append(TimestepEmbedSequential(*layers))
+                self._feature_size += ch
+
+        self.out = nn.Sequential(
+            normalization(ch),
+            nonlinearity(nonlinearity_type),
+            zero_module(conv_nd(dims, model_channels, out_channels, (kernel_size_t, 3,3), padding=(padding_t, 1,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=None, time_emb_replace=None, context=None, y=None, **kwargs):
+        """
+        Apply the model to an input batch.
+        :param x: an [N x C x ...] Tensor of inputs.
+        :param timesteps: a 1-D batch of timesteps.
+        :param context: conditioning plugged in via crossattn
+        :param y: an [N] Tensor of labels, if class-conditional.
+        :return: an [N x C x ...] Tensor of outputs.
+        """
+        
+        hs = []
+        if time_emb_replace is None:
+            t_emb = timestep_embedding(timesteps, self.model_channels, repeat_only=False)
+            emb = self.time_embed(t_emb)
+        else:
+            emb = time_emb_replace
+        
+        if y is not None: # if class-conditional model, inject class labels
+            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, context, **kwargs)
+            hs.append(h)
+        h = self.middle_block(h, emb, context, **kwargs)
+        for module in self.output_blocks:
+            h = th.cat([h, hs.pop()], dim=1)
+            h = module(h, emb, context, **kwargs)
+        h = h.type(x.dtype)
+        return self.out(h)

lvdm/models/modules/util.py

@@ -0,0 +1,348 @@
+import math
+from inspect import isfunction
+
+import torch
+import numpy as np
+import torch.nn as nn
+from einops import repeat
+import torch.nn.functional as F
+
+from lvdm.utils.common_utils import instantiate_from_config
+
+
+def make_beta_schedule(schedule, n_timestep, linear_start=1e-4, linear_end=2e-2, cosine_s=8e-3):
+    if schedule == "linear":
+        betas = (
+                torch.linspace(linear_start ** 0.5, linear_end ** 0.5, n_timestep, dtype=torch.float64) ** 2
+        )
+    elif schedule == "cosine":
+        timesteps = (
+                torch.arange(n_timestep + 1, dtype=torch.float64) / n_timestep + cosine_s
+        )
+        alphas = timesteps / (1 + cosine_s) * np.pi / 2
+        alphas = torch.cos(alphas).pow(2)
+        alphas = alphas / alphas[0]
+        betas = 1 - alphas[1:] / alphas[:-1]
+        betas = np.clip(betas, a_min=0, a_max=0.999)
+    elif schedule == "sqrt_linear":
+        betas = torch.linspace(linear_start, linear_end, n_timestep, dtype=torch.float64)
+    elif schedule == "sqrt":
+        betas = torch.linspace(linear_start, linear_end, n_timestep, dtype=torch.float64) ** 0.5
+    else:
+        raise ValueError(f"schedule '{schedule}' unknown.")
+    return betas.numpy()
+
+
+def make_ddim_timesteps(ddim_discr_method, num_ddim_timesteps, num_ddpm_timesteps, verbose=True):
+    if ddim_discr_method == 'uniform':
+        c = num_ddpm_timesteps // num_ddim_timesteps
+        ddim_timesteps = np.asarray(list(range(0, num_ddpm_timesteps, c)))
+    elif ddim_discr_method == 'quad':
+        ddim_timesteps = ((np.linspace(0, np.sqrt(num_ddpm_timesteps * .8), num_ddim_timesteps)) ** 2).astype(int)
+    else:
+        raise NotImplementedError(f'There is no ddim discretization method called "{ddim_discr_method}"')
+
+    # add one to get the final alpha values right (the ones from first scale to data during sampling)
+    steps_out = ddim_timesteps + 1
+    if verbose:
+        print(f'Selected timesteps for ddim sampler: {steps_out}')
+    return steps_out
+
+
+def make_ddim_sampling_parameters(alphacums, ddim_timesteps, eta, verbose=True):
+    # select alphas for computing the variance schedule
+    alphas = alphacums[ddim_timesteps]
+    alphas_prev = np.asarray([alphacums[0]] + alphacums[ddim_timesteps[:-1]].tolist())
+
+    # according the the formula provided in https://arxiv.org/abs/2010.02502
+    sigmas = eta * np.sqrt((1 - alphas_prev) / (1 - alphas) * (1 - alphas / alphas_prev))
+    if verbose:
+        print(f'Selected alphas for ddim sampler: a_t: {alphas}; a_(t-1): {alphas_prev}')
+        print(f'For the chosen value of eta, which is {eta}, '
+              f'this results in the following sigma_t schedule for ddim sampler {sigmas}')
+    return sigmas, alphas, alphas_prev
+
+
+def betas_for_alpha_bar(num_diffusion_timesteps, alpha_bar, max_beta=0.999):
+    """
+    Create a beta schedule that discretizes the given alpha_t_bar function,
+    which defines the cumulative product of (1-beta) over time from t = [0,1].
+    :param num_diffusion_timesteps: the number of betas to produce.
+    :param alpha_bar: a lambda that takes an argument t from 0 to 1 and
+                      produces the cumulative product of (1-beta) up to that
+                      part of the diffusion process.
+    :param max_beta: the maximum beta to use; use values lower than 1 to
+                     prevent singularities.
+    """
+    betas = []
+    for i in range(num_diffusion_timesteps):
+        t1 = i / num_diffusion_timesteps
+        t2 = (i + 1) / num_diffusion_timesteps
+        betas.append(min(1 - alpha_bar(t2) / alpha_bar(t1), max_beta))
+    return np.array(betas)
+
+
+def extract_into_tensor(a, t, x_shape):
+    b, *_ = t.shape
+    out = a.gather(-1, t)
+    return out.reshape(b, *((1,) * (len(x_shape) - 1)))
+
+
+def checkpoint(func, inputs, params, flag):
+    """
+    Evaluate a function without caching intermediate activations, allowing for
+    reduced memory at the expense of extra compute in the backward pass.
+    :param func: the function to evaluate.
+    :param inputs: the argument sequence to pass to `func`.
+    :param params: a sequence of parameters `func` depends on but does not
+                   explicitly take as arguments.
+    :param flag: if False, disable gradient checkpointing.
+    """
+    if flag:
+        args = tuple(inputs) + tuple(params)
+        return CheckpointFunction.apply(func, len(inputs), *args)
+    else:
+        return func(*inputs)
+
+
+class CheckpointFunction(torch.autograd.Function):
+    @staticmethod
+    @torch.cuda.amp.custom_fwd
+    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 torch.no_grad():
+            output_tensors = ctx.run_function(*ctx.input_tensors)
+        return output_tensors
+
+    @staticmethod
+    @torch.cuda.amp.custom_bwd
+    def backward(ctx, *output_grads):
+        ctx.input_tensors = [x.detach().requires_grad_(True) for x in ctx.input_tensors]
+        with torch.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 = torch.autograd.grad(
+            output_tensors,
+            ctx.input_tensors + ctx.input_params,
+            output_grads,
+            allow_unused=True,
+        )
+        del ctx.input_tensors
+        del ctx.input_params
+        del output_tensors
+        return (None, None) + input_grads
+
+
+def timestep_embedding(timesteps, dim, max_period=10000, repeat_only=False):
+    """
+    Create sinusoidal timestep embeddings.
+    :param timesteps: a 1-D Tensor of N indices, one per batch element.
+                      These may be fractional.
+    :param dim: the dimension of the output.
+    :param max_period: controls the minimum frequency of the embeddings.
+    :return: an [N x dim] Tensor of positional embeddings.
+    """
+    if not repeat_only:
+        half = dim // 2
+        freqs = torch.exp(
+            -math.log(max_period) * torch.arange(start=0, end=half, dtype=torch.float32) / half
+        ).to(device=timesteps.device)
+        args = timesteps[:, None].float() * freqs[None]
+        embedding = torch.cat([torch.cos(args), torch.sin(args)], dim=-1)
+        if dim % 2:
+            embedding = torch.cat([embedding, torch.zeros_like(embedding[:, :1])], dim=-1)
+    else:
+        embedding = repeat(timesteps, 'b -> b d', d=dim)
+    return embedding
+
+
+def zero_module(module):
+    """
+    Zero out the parameters of a module and return it.
+    """
+    for p in module.parameters():
+        p.detach().zero_()
+    return module
+
+
+def scale_module(module, scale):
+    """
+    Scale the parameters of a module and return it.
+    """
+    for p in module.parameters():
+        p.detach().mul_(scale)
+    return module
+
+
+def mean_flat(tensor):
+    """
+    Take the mean over all non-batch dimensions.
+    """
+    return tensor.mean(dim=list(range(1, len(tensor.shape))))
+
+
+def normalization(channels):
+    """
+    Make a standard normalization layer.
+    :param channels: number of input channels.
+    :return: an nn.Module for normalization.
+    """
+    return GroupNorm32(32, channels)
+
+def Normalize(in_channels):
+    return torch.nn.GroupNorm(num_groups=32, num_channels=in_channels, eps=1e-6, affine=True)
+
+def identity(*args, **kwargs):
+    return nn.Identity()
+
+class Normalization(nn.Module):
+    def __init__(self, output_size, eps=1e-5, norm_type='gn'):
+        super(Normalization, self).__init__()
+        # epsilon to avoid dividing by 0
+        self.eps = eps
+        self.norm_type = norm_type
+
+        if self.norm_type in ['bn', 'in']:
+            self.register_buffer('stored_mean', torch.zeros(output_size))
+            self.register_buffer('stored_var', torch.ones(output_size))
+    
+    def forward(self, x):
+        if self.norm_type == 'bn':
+            out = F.batch_norm(x, self.stored_mean, self.stored_var, None,
+                                None,
+                                self.training, 0.1, self.eps)
+        elif self.norm_type == 'in':
+            out = F.instance_norm(x, self.stored_mean, self.stored_var,
+                                    None, None,
+                                    self.training, 0.1, self.eps)
+        elif self.norm_type == 'gn':
+            out = F.group_norm(x, 32)
+        elif self.norm_type == 'nonorm':
+            out = x
+        return out
+
+
+class CCNormalization(nn.Module):
+    def __init__(self, embed_dim, feature_dim, *args, **kwargs):
+        super(CCNormalization, self).__init__()
+
+        self.embed_dim = embed_dim
+        self.feature_dim = feature_dim
+        self.norm = Normalization(feature_dim, *args, **kwargs)
+        
+        self.gain = nn.Linear(self.embed_dim, self.feature_dim)
+        self.bias = nn.Linear(self.embed_dim, self.feature_dim)
+        
+    def forward(self, x, y):
+        shape = [1] * (x.dim() - 2)
+        gain = (1 + self.gain(y)).view(y.size(0), -1, *shape)
+        bias = self.bias(y).view(y.size(0), -1, *shape)
+        return self.norm(x) * gain + bias
+
+
+def nonlinearity(type='silu'):
+    if type == 'silu':
+        return nn.SiLU()
+    elif type == 'leaky_relu':
+        return nn.LeakyReLU()
+
+
+class GEGLU(nn.Module):
+    def __init__(self, dim_in, dim_out):
+        super().__init__()
+        self.proj = nn.Linear(dim_in, dim_out * 2)
+
+    def forward(self, x):
+        x, gate = self.proj(x).chunk(2, dim=-1)
+        return x * F.gelu(gate)
+
+
+class SiLU(nn.Module):
+    def forward(self, x):
+        return x * torch.sigmoid(x)
+
+
+class GroupNorm32(nn.GroupNorm):
+    def forward(self, x):
+        return super().forward(x.float()).type(x.dtype)
+
+
+def conv_nd(dims, *args, **kwargs):
+    """
+    Create a 1D, 2D, or 3D convolution module.
+    """
+    if dims == 1:
+        return nn.Conv1d(*args, **kwargs)
+    elif dims == 2:
+        return nn.Conv2d(*args, **kwargs)
+    elif dims == 3:
+        return nn.Conv3d(*args, **kwargs)
+    raise ValueError(f"unsupported dimensions: {dims}")
+
+
+def linear(*args, **kwargs):
+    """
+    Create a linear module.
+    """
+    return nn.Linear(*args, **kwargs)
+
+
+def avg_pool_nd(dims, *args, **kwargs):
+    """
+    Create a 1D, 2D, or 3D average pooling module.
+    """
+    if dims == 1:
+        return nn.AvgPool1d(*args, **kwargs)
+    elif dims == 2:
+        return nn.AvgPool2d(*args, **kwargs)
+    elif dims == 3:
+        return nn.AvgPool3d(*args, **kwargs)
+    raise ValueError(f"unsupported dimensions: {dims}")
+
+
+class HybridConditioner(nn.Module):
+
+    def __init__(self, c_concat_config, c_crossattn_config):
+        super().__init__()
+        self.concat_conditioner = instantiate_from_config(c_concat_config)
+        self.crossattn_conditioner = instantiate_from_config(c_crossattn_config)
+
+    def forward(self, c_concat, c_crossattn):
+        c_concat = self.concat_conditioner(c_concat)
+        c_crossattn = self.crossattn_conditioner(c_crossattn)
+        return {'c_concat': [c_concat], 'c_crossattn': [c_crossattn]}
+
+
+def noise_like(shape, device, repeat=False):
+    repeat_noise = lambda: torch.randn((1, *shape[1:]), device=device).repeat(shape[0], *((1,) * (len(shape) - 1)))
+    noise = lambda: torch.randn(shape, device=device)
+    return repeat_noise() if repeat else noise()
+
+
+def init_(tensor):
+    dim = tensor.shape[-1]
+    std = 1 / math.sqrt(dim)
+    tensor.uniform_(-std, std)
+    return tensor
+
+
+def exists(val):
+    return val is not None
+
+
+def uniq(arr):
+    return{el: True for el in arr}.keys()
+
+
+def default(val, d):
+    if exists(val):
+        return val
+    return d() if isfunction(d) else d
+
+

lvdm/samplers/ddim.py

@@ -0,0 +1,267 @@
+"""SAMPLING ONLY."""
+
+import torch
+import numpy as np
+from tqdm import tqdm
+
+from lvdm.models.modules.util import make_ddim_sampling_parameters, make_ddim_timesteps, noise_like
+
+
+class DDIMSampler(object):
+    def __init__(self, model, schedule="linear", **kwargs):
+        super().__init__()
+        self.model = model
+        self.ddpm_num_timesteps = model.num_timesteps
+        self.schedule = schedule
+        self.counter = 0
+
+    def register_buffer(self, name, attr):
+        if type(attr) == torch.Tensor:
+            if attr.device != torch.device("cuda"):
+                attr = attr.to(torch.device("cuda"))
+        setattr(self, name, attr)
+
+    def make_schedule(self, ddim_num_steps, ddim_discretize="uniform", ddim_eta=0., verbose=True):
+        self.ddim_timesteps = make_ddim_timesteps(ddim_discr_method=ddim_discretize, num_ddim_timesteps=ddim_num_steps,
+                                                  num_ddpm_timesteps=self.ddpm_num_timesteps,verbose=verbose)
+        alphas_cumprod = self.model.alphas_cumprod
+        assert alphas_cumprod.shape[0] == self.ddpm_num_timesteps, 'alphas have to be defined for each timestep'
+        to_torch = lambda x: x.clone().detach().to(torch.float32).to(self.model.device)
+
+        self.register_buffer('betas', to_torch(self.model.betas))
+        self.register_buffer('alphas_cumprod', to_torch(alphas_cumprod))
+        self.register_buffer('alphas_cumprod_prev', to_torch(self.model.alphas_cumprod_prev))
+
+        # calculations for diffusion q(x_t | x_{t-1}) and others
+        self.register_buffer('sqrt_alphas_cumprod', to_torch(np.sqrt(alphas_cumprod.cpu())))
+        self.register_buffer('sqrt_one_minus_alphas_cumprod', to_torch(np.sqrt(1. - alphas_cumprod.cpu())))
+        self.register_buffer('log_one_minus_alphas_cumprod', to_torch(np.log(1. - alphas_cumprod.cpu())))
+        self.register_buffer('sqrt_recip_alphas_cumprod', to_torch(np.sqrt(1. / alphas_cumprod.cpu())))
+        self.register_buffer('sqrt_recipm1_alphas_cumprod', to_torch(np.sqrt(1. / alphas_cumprod.cpu() - 1)))
+
+        # ddim sampling parameters
+        ddim_sigmas, ddim_alphas, ddim_alphas_prev = make_ddim_sampling_parameters(alphacums=alphas_cumprod.cpu(),
+                                                                                   ddim_timesteps=self.ddim_timesteps,
+                                                                                   eta=ddim_eta,verbose=verbose)
+        self.register_buffer('ddim_sigmas', ddim_sigmas)
+        self.register_buffer('ddim_alphas', ddim_alphas)
+        self.register_buffer('ddim_alphas_prev', ddim_alphas_prev)
+        self.register_buffer('ddim_sqrt_one_minus_alphas', np.sqrt(1. - ddim_alphas))
+        sigmas_for_original_sampling_steps = ddim_eta * torch.sqrt(
+            (1 - self.alphas_cumprod_prev) / (1 - self.alphas_cumprod) * (
+                        1 - self.alphas_cumprod / self.alphas_cumprod_prev))
+        self.register_buffer('ddim_sigmas_for_original_num_steps', sigmas_for_original_sampling_steps)
+
+    @torch.no_grad()
+    def sample(self,
+               S,
+               batch_size,
+               shape,
+               conditioning=None,
+               callback=None,
+               img_callback=None,
+               quantize_x0=False,
+               eta=0.,
+               mask=None,
+               x0=None,
+               temperature=1.,
+               noise_dropout=0.,
+               score_corrector=None,
+               corrector_kwargs=None,
+               verbose=True,
+               schedule_verbose=False,
+               x_T=None,
+               log_every_t=100,
+               unconditional_guidance_scale=1.,
+               unconditional_conditioning=None,
+               postprocess_fn=None,
+               sample_noise=None,
+               cond_fn=None,
+               # this has to come in the same format as the conditioning, # e.g. as encoded tokens, ...
+               **kwargs
+               ):
+        
+        # check condition bs
+        if conditioning is not None:
+            if isinstance(conditioning, dict):
+                try:
+                    cbs = conditioning[list(conditioning.keys())[0]].shape[0]
+                    if cbs != batch_size:
+                        print(f"Warning: Got {cbs} conditionings but batch-size is {batch_size}")
+                except:
+                    # cbs = conditioning[list(conditioning.keys())[0]][0].shape[0]
+                    pass
+            else:
+                if conditioning.shape[0] != batch_size:
+                    print(f"Warning: Got {conditioning.shape[0]} conditionings but batch-size is {batch_size}")
+
+        self.make_schedule(ddim_num_steps=S, ddim_eta=eta, verbose=schedule_verbose)
+        
+        # make shape
+        if len(shape) == 3:
+            C, H, W = shape
+            size = (batch_size, C, H, W)
+        elif len(shape) == 4:
+            C, T, H, W = shape
+            size = (batch_size, C, T, H, W)
+        
+        samples, intermediates = self.ddim_sampling(conditioning, size,
+                                                    callback=callback,
+                                                    img_callback=img_callback,
+                                                    quantize_denoised=quantize_x0,
+                                                    mask=mask, x0=x0,
+                                                    ddim_use_original_steps=False,
+                                                    noise_dropout=noise_dropout,
+                                                    temperature=temperature,
+                                                    score_corrector=score_corrector,
+                                                    corrector_kwargs=corrector_kwargs,
+                                                    x_T=x_T,
+                                                    log_every_t=log_every_t,
+                                                    unconditional_guidance_scale=unconditional_guidance_scale,
+                                                    unconditional_conditioning=unconditional_conditioning,
+                                                    postprocess_fn=postprocess_fn,
+                                                    sample_noise=sample_noise,
+                                                    cond_fn=cond_fn,
+                                                    verbose=verbose,
+                                                    **kwargs
+                                                    )
+        return samples, intermediates
+
+    @torch.no_grad()
+    def ddim_sampling(self, cond, shape,
+                      x_T=None, ddim_use_original_steps=False,
+                      callback=None, timesteps=None, quantize_denoised=False,
+                      mask=None, x0=None, img_callback=None, log_every_t=100,
+                      temperature=1., noise_dropout=0., score_corrector=None, corrector_kwargs=None,
+                      unconditional_guidance_scale=1., unconditional_conditioning=None,
+                      postprocess_fn=None,sample_noise=None,cond_fn=None,
+                      uc_type=None, verbose=True, **kwargs,
+                      ):
+
+        device = self.model.betas.device
+        
+        b = shape[0]
+        if x_T is None:
+            img = torch.randn(shape, device=device)
+        else:
+            img = x_T
+        
+        if timesteps is None:
+            timesteps = self.ddpm_num_timesteps if ddim_use_original_steps else self.ddim_timesteps
+        elif timesteps is not None and not ddim_use_original_steps:
+            subset_end = int(min(timesteps / self.ddim_timesteps.shape[0], 1) * self.ddim_timesteps.shape[0]) - 1
+            timesteps = self.ddim_timesteps[:subset_end]
+        intermediates = {'x_inter': [img], 'pred_x0': [img]}
+        time_range = reversed(range(0,timesteps)) if ddim_use_original_steps else np.flip(timesteps)
+        total_steps = timesteps if ddim_use_original_steps else timesteps.shape[0]
+        if verbose:
+            iterator = tqdm(time_range, desc='DDIM Sampler', total=total_steps)
+        else:
+            iterator = time_range
+
+        for i, step in enumerate(iterator):
+            index = total_steps - i - 1
+            ts = torch.full((b,), step, device=device, dtype=torch.long)
+
+            if postprocess_fn is not None:
+                img = postprocess_fn(img, ts)
+            
+            outs = self.p_sample_ddim(img, cond, ts, index=index, use_original_steps=ddim_use_original_steps,
+                                      quantize_denoised=quantize_denoised, temperature=temperature,
+                                      noise_dropout=noise_dropout, score_corrector=score_corrector,
+                                      corrector_kwargs=corrector_kwargs,
+                                      unconditional_guidance_scale=unconditional_guidance_scale,
+                                      unconditional_conditioning=unconditional_conditioning,
+                                      sample_noise=sample_noise,cond_fn=cond_fn,uc_type=uc_type, **kwargs,)
+            img, pred_x0 = outs
+
+            if mask is not None:
+                # use mask to blend x_known_t-1 & x_sample_t-1
+                assert x0 is not None
+                x0 = x0.to(img.device)
+                mask = mask.to(img.device)
+                t = torch.tensor([step-1]*x0.shape[0], dtype=torch.long, device=img.device)
+                img_known = self.model.q_sample(x0, t)
+                img = img_known * mask + (1. - mask) * img
+            
+            if callback: callback(i)
+            if img_callback: img_callback(pred_x0, i)
+
+            if index % log_every_t == 0 or index == total_steps - 1:
+                intermediates['x_inter'].append(img)
+                intermediates['pred_x0'].append(pred_x0)
+
+        return img, intermediates
+
+    @torch.no_grad()
+    def p_sample_ddim(self, x, c, t, index, repeat_noise=False, use_original_steps=False, quantize_denoised=False,
+                      temperature=1., noise_dropout=0., score_corrector=None, corrector_kwargs=None,
+                      unconditional_guidance_scale=1., unconditional_conditioning=None, sample_noise=None,
+                      cond_fn=None,uc_type=None, model_kwargs={}, 
+                      **kwargs,
+                      ):
+        b, *_, device = *x.shape, x.device
+        if x.dim() == 5:
+            is_video = True
+        else:
+            is_video = False
+        if unconditional_conditioning is None or unconditional_guidance_scale == 1.:
+            e_t = self.model.apply_model(x, t, c, **model_kwargs) # unet denoiser
+        else:
+            # with unconditional condition
+            if isinstance(c, torch.Tensor):
+                e_t = self.model.apply_model(x, t, c, **model_kwargs)
+                e_t_uncond = self.model.apply_model(x, t, unconditional_conditioning, **model_kwargs)
+            elif isinstance(c, dict):
+                e_t = self.model.apply_model(x, t, c, **model_kwargs)
+                e_t_uncond = self.model.apply_model(x, t, unconditional_conditioning, **model_kwargs)
+            else:
+                raise NotImplementedError
+            # text cfg
+            if uc_type is None:
+                e_t = e_t_uncond + unconditional_guidance_scale * (e_t - e_t_uncond)
+            else:
+                if uc_type == 'cfg_original':
+                    e_t = e_t + unconditional_guidance_scale * (e_t - e_t_uncond)
+                elif uc_type == 'cfg_ours':
+                    e_t = e_t + unconditional_guidance_scale * (e_t_uncond - e_t)
+                else:
+                    raise NotImplementedError
+            
+        if score_corrector is not None:
+            assert self.model.parameterization == "eps"
+            e_t = score_corrector.modify_score(self.model, e_t, x, t, c, **corrector_kwargs)
+
+        alphas = self.model.alphas_cumprod if use_original_steps else self.ddim_alphas
+        alphas_prev = self.model.alphas_cumprod_prev if use_original_steps else self.ddim_alphas_prev
+        sqrt_one_minus_alphas = self.model.sqrt_one_minus_alphas_cumprod if use_original_steps else self.ddim_sqrt_one_minus_alphas
+        sigmas = self.model.ddim_sigmas_for_original_num_steps if use_original_steps else self.ddim_sigmas
+        # select parameters corresponding to the currently considered timestep
+        
+        if is_video:
+            size = (b, 1, 1, 1, 1)
+        else:
+            size = (b, 1, 1, 1)
+        a_t = torch.full(size, alphas[index], device=device)
+        a_prev = torch.full(size, alphas_prev[index], device=device)
+        sigma_t = torch.full(size, sigmas[index], device=device)
+        sqrt_one_minus_at = torch.full(size, sqrt_one_minus_alphas[index],device=device)
+
+        # current prediction for x_0
+        pred_x0 = (x - sqrt_one_minus_at * e_t) / a_t.sqrt()
+        # print(f't={t}, pred_x0, min={torch.min(pred_x0)}, max={torch.max(pred_x0)}',file=f)
+        if quantize_denoised:
+            pred_x0, _, *_ = self.model.first_stage_model.quantize(pred_x0)
+        # direction pointing to x_t
+        dir_xt = (1. - a_prev - sigma_t**2).sqrt() * e_t
+        
+        if sample_noise is None:
+            noise = sigma_t * noise_like(x.shape, device, repeat_noise) * temperature
+            if noise_dropout > 0.:
+                noise = torch.nn.functional.dropout(noise, p=noise_dropout)
+        else:
+            noise = sigma_t * sample_noise * temperature
+        
+        x_prev = a_prev.sqrt() * pred_x0 + dir_xt + noise
+        
+        return x_prev, pred_x0

lvdm/utils/common_utils.py

@@ -0,0 +1,132 @@
+
+import importlib
+
+import torch
+import numpy as np
+
+from inspect import isfunction
+from PIL import Image, ImageDraw, ImageFont
+
+
+def str2bool(v):
+    if isinstance(v, bool):
+        return v
+    if v.lower() in ('yes', 'true', 't', 'y', '1'):
+        return True
+    elif v.lower() in ('no', 'false', 'f', 'n', '0'):
+        return False
+    else:
+        raise ValueError('Boolean value expected.')
+
+
+def instantiate_from_config(config):
+    if not "target" in config:
+        if config == '__is_first_stage__':
+            return None
+        elif config == "__is_unconditional__":
+            return None
+        raise KeyError("Expected key `target` to instantiate.")
+
+    return get_obj_from_str(config["target"])(**config.get("params", dict()))
+
+def get_obj_from_str(string, reload=False):
+    module, cls = string.rsplit(".", 1)
+    if reload:
+        module_imp = importlib.import_module(module)
+        importlib.reload(module_imp)
+    return getattr(importlib.import_module(module, package=None), cls)
+
+def log_txt_as_img(wh, xc, size=10):
+    # wh a tuple of (width, height)
+    # xc a list of captions to plot
+    b = len(xc)
+    txts = list()
+    for bi in range(b):
+        txt = Image.new("RGB", wh, color="white")
+        draw = ImageDraw.Draw(txt)
+        font = ImageFont.truetype('data/DejaVuSans.ttf', size=size)
+        nc = int(40 * (wh[0] / 256))
+        lines = "\n".join(xc[bi][start:start + nc] for start in range(0, len(xc[bi]), nc))
+
+        try:
+            draw.text((0, 0), lines, fill="black", font=font)
+        except UnicodeEncodeError:
+            print("Cant encode string for logging. Skipping.")
+
+        txt = np.array(txt).transpose(2, 0, 1) / 127.5 - 1.0
+        txts.append(txt)
+    txts = np.stack(txts)
+    txts = torch.tensor(txts)
+    return txts
+
+
+def ismap(x):
+    if not isinstance(x, torch.Tensor):
+        return False
+    return (len(x.shape) == 4) and (x.shape[1] > 3)
+
+
+def isimage(x):
+    if not isinstance(x,torch.Tensor):
+        return False
+    return (len(x.shape) == 4) and (x.shape[1] == 3 or x.shape[1] == 1)
+
+
+def exists(x):
+    return x is not None
+
+
+def default(val, d):
+    if exists(val):
+        return val
+    return d() if isfunction(d) else d
+
+
+def mean_flat(tensor):
+    """
+    https://github.com/openai/guided-diffusion/blob/27c20a8fab9cb472df5d6bdd6c8d11c8f430b924/guided_diffusion/nn.py#L86
+    Take the mean over all non-batch dimensions.
+    """
+    return tensor.mean(dim=list(range(1, len(tensor.shape))))
+
+
+def count_params(model, verbose=False):
+    total_params = sum(p.numel() for p in model.parameters())
+    if verbose:
+        print(f"{model.__class__.__name__} has {total_params*1.e-6:.2f} M params.")
+    return total_params
+
+
+def instantiate_from_config(config):
+    if not "target" in config:
+        if config == '__is_first_stage__':
+            return None
+        elif config == "__is_unconditional__":
+            return None
+        raise KeyError("Expected key `target` to instantiate.")
+
+    if "instantiate_with_dict" in config and config["instantiate_with_dict"]:
+        # input parameter is one dict
+        return get_obj_from_str(config["target"])(config.get("params", dict()), **kwargs)
+    else:
+        return get_obj_from_str(config["target"])(**config.get("params", dict()))
+
+
+def get_obj_from_str(string, reload=False):
+    module, cls = string.rsplit(".", 1)
+    if reload:
+        module_imp = importlib.import_module(module)
+        importlib.reload(module_imp)
+    return getattr(importlib.import_module(module, package=None), cls)
+
+
+def check_istarget(name, para_list):
+    """ 
+    name: full name of source para
+    para_list: partial name of target para 
+    """
+    istarget=False
+    for para in para_list:
+        if para in name:
+            return True
+    return istarget

lvdm/utils/dist_utils.py

@@ -0,0 +1,19 @@
+import torch
+import torch.distributed as dist
+
+def setup_dist(local_rank):
+    if dist.is_initialized():
+        return
+    torch.cuda.set_device(local_rank)
+    torch.distributed.init_process_group(
+        'nccl',
+        init_method='env://'
+    )
+
+def gather_data(data, return_np=True):
+    ''' gather data from multiple processes to one list '''
+    data_list = [torch.zeros_like(data) for _ in range(dist.get_world_size())]
+    dist.all_gather(data_list, data)  # gather not supported with NCCL
+    if return_np:
+        data_list = [data.cpu().numpy() for data in data_list]
+    return data_list

lvdm/utils/saving_utils.py

@@ -0,0 +1,251 @@
+import numpy as np
+import cv2
+import os
+import time
+import imageio
+from tqdm import tqdm
+from PIL import Image
+import os
+import sys
+sys.path.insert(1, os.path.join(sys.path[0], '..'))
+import torch
+import torchvision
+from torchvision.utils import make_grid
+from torch import Tensor
+from torchvision.transforms.functional import to_tensor
+
+# ----------------------------------------------------------------------------------------------
+def savenp2sheet(imgs, savepath, nrow=None):
+    """ save multiple imgs (in numpy array type) to a img sheet.
+        img sheet is one row.
+
+    imgs: 
+        np array of size [N, H, W, 3] or List[array] with array size = [H,W,3] 
+    """
+    if imgs.ndim == 4:
+        img_list = [imgs[i] for i in range(imgs.shape[0])]
+        imgs = img_list
+    
+    imgs_new = []
+    for i, img in enumerate(imgs):
+        if img.ndim == 3 and img.shape[0] == 3:
+            img = np.transpose(img,(1,2,0))
+        
+        assert(img.ndim == 3 and img.shape[-1] == 3), img.shape # h,w,3
+        img = cv2.cvtColor(img, cv2.COLOR_RGB2BGR)
+        imgs_new.append(img)
+    n = len(imgs)
+    if nrow is not None:
+        n_cols = nrow
+    else:
+        n_cols=int(n**0.5)
+    n_rows=int(np.ceil(n/n_cols))
+    print(n_cols)
+    print(n_rows)
+
+    imgsheet = cv2.vconcat([cv2.hconcat(imgs_new[i*n_cols:(i+1)*n_cols]) for i in range(n_rows)])
+    cv2.imwrite(savepath, imgsheet)
+    print(f'saved in {savepath}')
+
+# ----------------------------------------------------------------------------------------------
+def save_np_to_img(img, path, norm=True):
+    if norm:
+        img = (img + 1) / 2 * 255
+    img = img.astype(np.uint8)
+    image = Image.fromarray(img)
+    image.save(path, q=95)
+
+# ----------------------------------------------------------------------------------------------
+def npz_to_imgsheet_5d(data_path, res_dir, nrow=None,):
+    if isinstance(data_path, str):
+        imgs = np.load(data_path)['arr_0'] # NTHWC
+    elif isinstance(data_path, np.ndarray):
+        imgs = data_path
+    else:
+        raise Exception
+    
+    if os.path.isdir(res_dir):
+        res_path = os.path.join(res_dir, f'samples.jpg')
+    else:
+        assert(res_dir.endswith('.jpg'))
+        res_path = res_dir
+    imgs = np.concatenate([imgs[i] for i in range(imgs.shape[0])], axis=0)
+    savenp2sheet(imgs, res_path, nrow=nrow)
+
+# ----------------------------------------------------------------------------------------------
+def npz_to_imgsheet_4d(data_path, res_path, nrow=None,):
+    if isinstance(data_path, str):
+        imgs = np.load(data_path)['arr_0'] # NHWC
+    elif isinstance(data_path, np.ndarray):
+        imgs = data_path
+    else:
+        raise Exception
+    print(imgs.shape)
+    savenp2sheet(imgs, res_path, nrow=nrow)
+
+
+# ----------------------------------------------------------------------------------------------
+def tensor_to_imgsheet(tensor, save_path):
+    """ 
+        save a batch of videos in one image sheet with shape of [batch_size * num_frames].
+        data: [b,c,t,h,w]
+    """
+    assert(tensor.dim() == 5)
+    b,c,t,h,w = tensor.shape
+    imgs = [tensor[bi,:,ti, :, :] for bi in range(b) for ti in range(t)]
+    torchvision.utils.save_image(imgs, save_path, normalize=True, nrow=t)
+
+
+# ----------------------------------------------------------------------------------------------
+def npz_to_frames(data_path, res_dir, norm, num_frames=None, num_samples=None):
+    start = time.time()
+    arr = np.load(data_path)
+    imgs = arr['arr_0'] # [N, T, H, W, 3]
+    print('original data shape: ', imgs.shape)
+
+    if num_samples is not None:
+        imgs = imgs[:num_samples, :, :, :, :]
+        print('after sample selection: ', imgs.shape)
+    
+    if num_frames is not None:
+        imgs = imgs[:, :num_frames, :, :, :]
+        print('after frame selection: ', imgs.shape)
+
+    for vid in tqdm(range(imgs.shape[0]), desc='Video'):
+        video_dir = os.path.join(res_dir, f'video{vid:04d}')
+        os.makedirs(video_dir, exist_ok=True)
+        for fid in range(imgs.shape[1]):
+            frame = imgs[vid, fid, :, :, :] #HW3
+            save_np_to_img(frame, os.path.join(video_dir, f'frame{fid:04d}.jpg'), norm=norm)
+    print('Finish')
+    print(f'Total time = {time.time()- start}')
+
+# ----------------------------------------------------------------------------------------------
+def npz_to_gifs(data_path, res_dir, duration=0.2, start_idx=0, num_videos=None, mode='gif'):
+    os.makedirs(res_dir, exist_ok=True)
+    if isinstance(data_path, str):
+        imgs = np.load(data_path)['arr_0'] # NTHWC
+    elif isinstance(data_path, np.ndarray):
+        imgs = data_path
+    else:
+        raise Exception
+
+    for i in range(imgs.shape[0]):
+        frames = [imgs[i,j,:,:,:] for j in range(imgs[i].shape[0])] # [(h,w,3)]
+        if mode == 'gif':
+            imageio.mimwrite(os.path.join(res_dir, f'samples_{start_idx+i}.gif'), frames, format='GIF', duration=duration)
+        elif mode == 'mp4':
+            frames = [torch.from_numpy(frame) for frame in frames]
+            frames = torch.stack(frames, dim=0).to(torch.uint8) # [T, H, W, C]
+            torchvision.io.write_video(os.path.join(res_dir, f'samples_{start_idx+i}.mp4'),
+                frames, fps=0.5, video_codec='h264', options={'crf': '10'})
+        if i+ 1 == num_videos:
+            break
+
+# ----------------------------------------------------------------------------------------------
+def fill_with_black_squares(video, desired_len: int) -> Tensor:
+    if len(video) >= desired_len:
+        return video
+
+    return torch.cat([
+        video,
+        torch.zeros_like(video[0]).unsqueeze(0).repeat(desired_len - len(video), 1, 1, 1),
+    ], dim=0)
+
+# ----------------------------------------------------------------------------------------------
+def load_num_videos(data_path, num_videos):
+    # data_path can be either data_path of np array 
+    if isinstance(data_path, str):
+        videos = np.load(data_path)['arr_0'] # NTHWC
+    elif isinstance(data_path, np.ndarray):
+        videos = data_path
+    else:
+        raise Exception
+
+    if num_videos is not None:
+        videos = videos[:num_videos, :, :, :, :]
+    return videos
+
+# ----------------------------------------------------------------------------------------------
+def npz_to_video_grid(data_path, out_path, num_frames=None, fps=8, num_videos=None, nrow=None, verbose=True):
+    if isinstance(data_path, str):
+        videos = load_num_videos(data_path, num_videos)
+    elif isinstance(data_path, np.ndarray):
+        videos = data_path
+    else:
+        raise Exception
+    n,t,h,w,c = videos.shape
+
+    videos_th = []
+    for i in range(n):
+        video = videos[i, :,:,:,:]
+        images = [video[j, :,:,:] for j in range(t)]
+        images = [to_tensor(img) for img in images]
+        video = torch.stack(images)
+        videos_th.append(video)
+    
+    if num_frames is None:
+        num_frames = videos.shape[1]
+    if verbose:
+        videos = [fill_with_black_squares(v, num_frames) for v in tqdm(videos_th, desc='Adding empty frames')] # NTCHW
+    else:
+        videos = [fill_with_black_squares(v, num_frames) for v in videos_th] # NTCHW
+
+    frame_grids = torch.stack(videos).permute(1, 0, 2, 3, 4) # [T, N, C, H, W]
+    if nrow is None:
+        nrow = int(np.ceil(np.sqrt(n)))
+    if verbose:
+        frame_grids = [make_grid(fs, nrow=nrow) for fs in tqdm(frame_grids, desc='Making grids')]
+    else:
+        frame_grids = [make_grid(fs, nrow=nrow) for fs in frame_grids]
+
+    if os.path.dirname(out_path) != "":
+        os.makedirs(os.path.dirname(out_path), exist_ok=True)
+    frame_grids = (torch.stack(frame_grids) * 255).to(torch.uint8).permute(0, 2, 3, 1) # [T, H, W, C]
+    torchvision.io.write_video(out_path, frame_grids, fps=fps, video_codec='h264', options={'crf': '10'})
+
+# ----------------------------------------------------------------------------------------------
+def npz_to_gif_grid(data_path, out_path, n_cols=None, num_videos=20):
+    arr = np.load(data_path)
+    imgs = arr['arr_0'] # [N, T, H, W, 3]
+    imgs = imgs[:num_videos]
+    n, t, h, w, c = imgs.shape
+    assert(n == num_videos)
+    n_cols = n_cols if n_cols else imgs.shape[0]
+    n_rows = np.ceil(imgs.shape[0] / n_cols).astype(np.int8)
+    H, W = h * n_rows, w * n_cols
+    grid = np.zeros((t, H, W, c), dtype=np.uint8)
+
+    for i in range(n_rows):
+        for j in range(n_cols):
+            if i*n_cols+j < imgs.shape[0]:
+                grid[:, i*h:(i+1)*h, j*w:(j+1)*w, :] = imgs[i*n_cols+j, :, :, :, :]
+    
+    videos = [grid[i] for i in range(grid.shape[0])] # grid: TH'W'C
+    imageio.mimwrite(out_path, videos, format='GIF', duration=0.5,palettesize=256)
+
+
+# ----------------------------------------------------------------------------------------------
+def torch_to_video_grid(videos, out_path, num_frames, fps, num_videos=None, nrow=None, verbose=True):
+    """
+    videos: -1 ~ 1, torch.Tensor, BCTHW
+    """
+    n,t,h,w,c = videos.shape
+    videos_th = [videos[i, ...] for i in range(n)]
+    if verbose:
+        videos = [fill_with_black_squares(v, num_frames) for v in tqdm(videos_th, desc='Adding empty frames')] # NTCHW
+    else:
+        videos = [fill_with_black_squares(v, num_frames) for v in videos_th] # NTCHW
+
+    frame_grids = torch.stack(videos).permute(1, 0, 2, 3, 4) # [T, N, C, H, W]
+    if nrow is None:
+        nrow = int(np.ceil(np.sqrt(n)))
+    if verbose:
+        frame_grids = [make_grid(fs, nrow=nrow) for fs in tqdm(frame_grids, desc='Making grids')]
+    else:
+        frame_grids = [make_grid(fs, nrow=nrow) for fs in frame_grids]
+
+    if os.path.dirname(out_path) != "":
+        os.makedirs(os.path.dirname(out_path), exist_ok=True)
+    frame_grids = ((torch.stack(frame_grids) + 1) / 2 * 255).to(torch.uint8).permute(0, 2, 3, 1) # [T, H, W, C]
+    torchvision.io.write_video(out_path, frame_grids, fps=fps, video_codec='h264', options={'crf': '10'})

models/base_t2v/model_config.yaml

@@ -0,0 +1,72 @@
+model:
+  target: lvdm.models.ddpm3d.LatentDiffusion
+  params:
+    linear_start: 0.00085
+    linear_end: 0.012
+    num_timesteps_cond: 1
+    log_every_t: 200
+    timesteps: 1000
+    first_stage_key: video
+    cond_stage_key: caption
+    image_size:
+    - 32
+    - 32
+    video_length: 16
+    channels: 4
+    cond_stage_trainable: false
+    conditioning_key: crossattn
+    scale_by_std: false
+    scale_factor: 0.18215
+
+    unet_config:
+      target: lvdm.models.modules.openaimodel3d.UNetModel
+      params:
+        image_size: 32
+        in_channels: 4
+        out_channels: 4
+        model_channels: 320
+        attention_resolutions:
+        - 4
+        - 2
+        - 1
+        num_res_blocks: 2
+        channel_mult:
+        - 1
+        - 2
+        - 4
+        - 4
+        num_heads: 8
+        transformer_depth: 1
+        context_dim: 768
+        use_checkpoint: true
+        legacy: false
+        kernel_size_t: 1
+        padding_t: 0
+        temporal_length: 16
+        use_relative_position: true
+        
+    first_stage_config:
+      target: lvdm.models.autoencoder.AutoencoderKL
+      params:
+        embed_dim: 4
+        monitor: val/rec_loss
+        ddconfig:
+          double_z: true
+          z_channels: 4
+          resolution: 256
+          in_channels: 3
+          out_ch: 3
+          ch: 128
+          ch_mult:
+          - 1
+          - 2
+          - 4
+          - 4
+          num_res_blocks: 2
+          attn_resolutions: []
+          dropout: 0.0
+        lossconfig:
+          target: torch.nn.Identity
+
+    cond_stage_config:
+      target: lvdm.models.modules.condition_modules.FrozenCLIPEmbedder

requirements.txt

@@ -0,0 +1,20 @@
+decord==0.6.0
+einops==0.3.0
+imageio==2.9.0
+numpy==1.24.2
+omegaconf==2.1.1
+opencv_python
+pandas==2.0.0
+Pillow==9.5.0
+pytorch_lightning==1.8.3
+PyYAML==6.0
+setuptools==65.6.3
+torch==2.0.0
+torchvision
+tqdm==4.65.0
+transformers==4.25.1
+moviepy
+av
+xformers
+gradio
+-e .

sample_text2video.sh

@@ -0,0 +1,16 @@
+
+PROMPT="astronaut riding a horse" # OR: PROMPT="input/prompts.txt" for sampling multiple prompts
+OUTDIR="results/"
+
+BASE_PATH="models/base_t2v/model.ckpt"
+CONFIG_PATH="models/base_t2v/model_config.yaml"
+
+python scripts/sample_text2video.py \
+    --ckpt_path $BASE_PATH \
+    --config_path $CONFIG_PATH \
+    --prompt "$PROMPT" \
+    --save_dir $OUTDIR \
+    --n_samples 1 \
+    --batch_size 1 \
+    --seed 1000 \
+    --show_denoising_progress

sample_text2video_multiGPU.sh

@@ -0,0 +1,18 @@
+
+PROMPT="astronaut riding a horse" # OR: PROMPT="input/prompts.txt" for sampling multiple prompts
+OUTDIR="results/"
+
+BASE_PATH="models/base_t2v/model.ckpt"
+CONFIG_PATH="models/base_t2v/model_config.ckpt"
+
+NGPU=8
+
+python -m torch.distributed.launch --nproc_per_node=$NGPU scripts/sample_text2video.py \
+    --ckpt_path $BASE_PATH \
+    --config_path $CONFIG_PATH \
+    --prompt "$PROMPT" \
+    --save_dir $OUTDIR \
+    --n_samples 1 \
+    --batch_size 1 \
+    --seed 1000 \
+    --ddp

sample_videolora.sh

@@ -0,0 +1,24 @@
+
+PROMPT="astronaut riding a horse" # OR: PROMPT="input/prompts.txt" for sampling multiple prompts
+OUTDIR="results/videolora"
+
+BASE_PATH="models/base_t2v/model.ckpt"
+CONFIG_PATH="models/base_t2v/model_config.yaml"
+
+# lora args
+LORA_PATH="models/videolora/lora_001_Loving_Vincent_style.ckpt"
+TAG=", Loving Vincent style"
+
+python scripts/sample_text2video.py \
+    --ckpt_path $BASE_PATH \
+    --config_path $CONFIG_PATH \
+    --prompt "$PROMPT" \
+    --save_dir $OUTDIR \
+    --n_samples 1 \
+    --batch_size 1 \
+    --seed 1000 \
+    --show_denoising_progress \
+    --inject_lora \
+    --lora_path $LORA_PATH \
+    --lora_trigger_word "$TAG" \
+    --lora_scale 1.0

scripts/sample_text2video.py

@@ -0,0 +1,260 @@
+import os
+import time
+import argparse
+import yaml, math
+from tqdm import trange
+import torch
+import numpy as np
+from omegaconf import OmegaConf
+import torch.distributed as dist
+from pytorch_lightning import seed_everything
+
+from lvdm.samplers.ddim import DDIMSampler
+from lvdm.utils.common_utils import str2bool
+from lvdm.utils.dist_utils import setup_dist, gather_data
+from lvdm.utils.saving_utils import npz_to_video_grid, npz_to_imgsheet_5d
+from scripts.sample_utils import load_model, get_conditions, make_model_input_shape, torch_to_np
+
+
+# ------------------------------------------------------------------------------------------
+def get_parser():
+    parser = argparse.ArgumentParser()
+    # basic args
+    parser.add_argument("--ckpt_path", type=str, help="model checkpoint path")
+    parser.add_argument("--config_path", type=str, help="model config path (a yaml file)")
+    parser.add_argument("--prompt", type=str, help="input text prompts for text2video (a sentence OR a txt file).")
+    parser.add_argument("--save_dir", type=str, help="results saving dir", default="results/")
+    # device args
+    parser.add_argument("--ddp", action='store_true', help="whether use pytorch ddp mode for parallel sampling (recommend for multi-gpu case)", default=False)
+    parser.add_argument("--local_rank", type=int, help="is used for pytorch ddp mode", default=0)
+    parser.add_argument("--gpu_id", type=int, help="choose a specific gpu", default=0)
+    # sampling args
+    parser.add_argument("--n_samples", type=int, help="how many samples for each text prompt", default=2)
+    parser.add_argument("--batch_size", type=int, help="video batch size for sampling", default=1)
+    parser.add_argument("--decode_frame_bs", type=int, help="frame batch size for framewise decoding", default=1)
+    parser.add_argument("--sample_type", type=str, help="ddpm or ddim", default="ddim", choices=["ddpm", "ddim"])
+    parser.add_argument("--ddim_steps", type=int, help="ddim sampling -- number of ddim denoising timesteps", default=50)
+    parser.add_argument("--eta", type=float, help="ddim sampling -- eta (0.0 yields deterministic sampling, 1.0 yields random sampling)", default=1.0)
+    parser.add_argument("--cfg_scale", type=float, default=15.0, help="classifier-free guidance scale")
+    parser.add_argument("--seed", type=int, default=None, help="fix a seed for randomness (If you want to reproduce the sample results)")
+    parser.add_argument("--show_denoising_progress", action='store_true', default=False, help="whether show denoising progress during sampling one batch",)
+    # lora args
+    parser.add_argument("--lora_path", type=str, help="lora checkpoint path")
+    parser.add_argument("--inject_lora", action='store_true', default=False, help="",)
+    parser.add_argument("--lora_scale", type=float, default=None, help="scale for lora weight")
+    parser.add_argument("--lora_trigger_word", type=str, default="", help="",)
+    # saving args
+    parser.add_argument("--save_mp4", type=str2bool, default=True, help="whether save samples in separate mp4 files", choices=["True", "true", "False", "false"])
+    parser.add_argument("--save_mp4_sheet", action='store_true', default=False, help="whether save samples in mp4 file",)
+    parser.add_argument("--save_npz", action='store_true', default=False, help="whether save samples in npz file",)
+    parser.add_argument("--save_jpg", action='store_true', default=False, help="whether save samples in jpg file",)
+    parser.add_argument("--save_fps", type=int, default=8, help="fps of saved mp4 videos",)
+    return parser
+
+# ------------------------------------------------------------------------------------------
+def sample_denoising_batch(model, noise_shape, condition, *args,
+                           sample_type="ddim", sampler=None, 
+                           ddim_steps=None, eta=None,
+                           unconditional_guidance_scale=1.0, uc=None,
+                           denoising_progress=False,
+                           **kwargs,
+                           ):
+    
+    if sample_type == "ddpm":
+        samples = model.p_sample_loop(cond=condition, shape=noise_shape,
+                                      return_intermediates=False, 
+                                      verbose=denoising_progress,
+                                      **kwargs,
+                                      )
+    elif sample_type == "ddim":
+        assert(sampler is not None)
+        assert(ddim_steps is not None)
+        assert(eta is not None)
+        ddim_sampler = sampler
+        samples, _ = ddim_sampler.sample(S=ddim_steps,
+                                         conditioning=condition,
+                                         batch_size=noise_shape[0],
+                                         shape=noise_shape[1:],
+                                         verbose=denoising_progress,
+                                         unconditional_guidance_scale=unconditional_guidance_scale,
+                                         unconditional_conditioning=uc,
+                                         eta=eta,
+                                         **kwargs,
+                                        )
+    else:
+        raise ValueError
+    return samples
+
+
+# ------------------------------------------------------------------------------------------
+@torch.no_grad()
+def sample_text2video(model, prompt, n_samples, batch_size,
+                      sample_type="ddim", sampler=None, 
+                      ddim_steps=50, eta=1.0, cfg_scale=7.5, 
+                      decode_frame_bs=1,
+                      ddp=False, all_gather=True, 
+                      batch_progress=True, show_denoising_progress=False,
+                      ):
+    # get cond vector
+    assert(model.cond_stage_model is not None)
+    cond_embd = get_conditions(prompt, model, batch_size)
+    uncond_embd = get_conditions("", model, batch_size) if cfg_scale != 1.0 else None
+
+    # sample batches
+    all_videos = []
+    n_iter = math.ceil(n_samples / batch_size)
+    iterator  = trange(n_iter, desc="Sampling Batches (text-to-video)") if batch_progress else range(n_iter)
+    for _ in iterator:
+        noise_shape = make_model_input_shape(model, batch_size)
+        samples_latent = sample_denoising_batch(model, noise_shape, cond_embd,
+                                            sample_type=sample_type,
+                                            sampler=sampler,
+                                            ddim_steps=ddim_steps,
+                                            eta=eta,
+                                            unconditional_guidance_scale=cfg_scale, 
+                                            uc=uncond_embd,
+                                            denoising_progress=show_denoising_progress,
+                                            )
+        samples = model.decode_first_stage(samples_latent, decode_bs=decode_frame_bs, return_cpu=False)
+        
+        # gather samples from multiple gpus
+        if ddp and all_gather:
+            data_list = gather_data(samples, return_np=False)
+            all_videos.extend([torch_to_np(data) for data in data_list])
+        else:
+            all_videos.append(torch_to_np(samples))
+    
+    all_videos = np.concatenate(all_videos, axis=0)
+    assert(all_videos.shape[0] >= n_samples)
+    return all_videos
+
+
+# ------------------------------------------------------------------------------------------
+def save_results(videos, save_dir, 
+                 save_name="results", save_fps=8, save_mp4=True, 
+                 save_npz=False, save_mp4_sheet=False, save_jpg=False
+                 ):
+    if save_mp4:
+        save_subdir = os.path.join(save_dir, "videos")
+        os.makedirs(save_subdir, exist_ok=True)
+        for i in range(videos.shape[0]):
+            npz_to_video_grid(videos[i:i+1,...], 
+                              os.path.join(save_subdir, f"{save_name}_{i:03d}.mp4"), 
+                              fps=save_fps)
+        print(f'Successfully saved videos in {save_subdir}')
+    
+    if save_npz:
+        save_path = os.path.join(save_dir, f"{save_name}.npz")
+        np.savez(save_path, videos)
+        print(f'Successfully saved npz in {save_path}')
+    
+    if save_mp4_sheet:
+        save_path = os.path.join(save_dir, f"{save_name}.mp4")
+        npz_to_video_grid(videos, save_path, fps=save_fps)
+        print(f'Successfully saved mp4 sheet in {save_path}')
+
+    if save_jpg:
+        save_path = os.path.join(save_dir, f"{save_name}.jpg")
+        npz_to_imgsheet_5d(videos, save_path, nrow=videos.shape[1])
+        print(f'Successfully saved jpg sheet in {save_path}')
+
+
+# ------------------------------------------------------------------------------------------
+def main():
+    """
+    text-to-video generation
+    """
+    parser = get_parser()
+    opt, unknown = parser.parse_known_args()
+    os.makedirs(opt.save_dir, exist_ok=True)
+    
+    # set device
+    if opt.ddp:
+        setup_dist(opt.local_rank)
+        opt.n_samples = math.ceil(opt.n_samples / dist.get_world_size())
+        gpu_id = None
+    else:
+        gpu_id = opt.gpu_id
+        os.environ["CUDA_VISIBLE_DEVICES"] = f"{gpu_id}"
+    
+    # set random seed
+    if opt.seed is not None:
+        if opt.ddp:
+            seed = opt.local_rank + opt.seed
+        else:
+            seed = opt.seed
+        seed_everything(seed)
+
+    # dump args
+    fpath = os.path.join(opt.save_dir, "sampling_args.yaml")
+    with open(fpath, 'w') as f:
+        yaml.dump(vars(opt), f, default_flow_style=False)
+
+    # load & merge config
+    config = OmegaConf.load(opt.config_path)
+    cli = OmegaConf.from_dotlist(unknown)
+    config = OmegaConf.merge(config, cli)
+    print("config: \n", config)
+
+    # get model & sampler
+    model, _, _ = load_model(config, opt.ckpt_path, 
+                             inject_lora=opt.inject_lora, 
+                             lora_scale=opt.lora_scale, 
+                             lora_path=opt.lora_path
+                             )
+    ddim_sampler = DDIMSampler(model) if opt.sample_type == "ddim" else None
+
+    # prepare prompt
+    if opt.prompt.endswith(".txt"):
+        opt.prompt_file = opt.prompt
+        opt.prompt = None
+    else:
+        opt.prompt_file = None
+
+    if opt.prompt_file is not None:
+        f = open(opt.prompt_file, 'r')
+        prompts, line_idx = [], []
+        for idx, line in enumerate(f.readlines()):
+            l = line.strip()
+            if len(l) != 0:
+                prompts.append(l)
+                line_idx.append(idx)
+        f.close()
+        cmd = f"cp {opt.prompt_file} {opt.save_dir}"
+        os.system(cmd)
+    else:
+        prompts = [opt.prompt]
+        line_idx = [None]
+
+    if opt.inject_lora:
+        assert(opt.lora_trigger_word != '')
+        prompts = [p + opt.lora_trigger_word for p in prompts]
+    
+    # go
+    start = time.time()  
+    for prompt in prompts:
+        # sample
+        samples = sample_text2video(model, prompt, opt.n_samples, opt.batch_size,
+                          sample_type=opt.sample_type, sampler=ddim_sampler,
+                          ddim_steps=opt.ddim_steps, eta=opt.eta, 
+                          cfg_scale=opt.cfg_scale,
+                          decode_frame_bs=opt.decode_frame_bs,
+                          ddp=opt.ddp, show_denoising_progress=opt.show_denoising_progress,
+                          )
+        # save
+        if (opt.ddp and dist.get_rank() == 0) or (not opt.ddp):
+            prompt_str = prompt.replace("/", "_slash_") if "/" in prompt else prompt
+            save_name = prompt_str.replace(" ", "_") if " " in prompt else prompt_str
+            if opt.seed is not None:
+                save_name = save_name + f"_seed{seed:05d}"
+            save_results(samples, opt.save_dir, save_name=save_name, save_fps=opt.save_fps)
+    print("Finish sampling!")
+    print(f"Run time = {(time.time() - start):.2f} seconds")
+
+    if opt.ddp:
+        dist.destroy_process_group()
+
+
+# ------------------------------------------------------------------------------------------
+if __name__ == "__main__":
+    main()

scripts/sample_utils.py

@@ -0,0 +1,129 @@
+import os
+import torch
+from PIL import Image
+
+from lvdm.models.modules.lora import net_load_lora
+from lvdm.utils.common_utils import instantiate_from_config
+
+
+# ------------------------------------------------------------------------------------------
+def load_model(config, ckpt_path, gpu_id=None, inject_lora=False, lora_scale=1.0, lora_path=''):
+    print(f"Loading model from {ckpt_path}")
+    
+    # load sd
+    pl_sd = torch.load(ckpt_path, map_location="cpu")
+    try:
+        global_step = pl_sd["global_step"]
+        epoch = pl_sd["epoch"]
+    except:
+        global_step = -1
+        epoch = -1
+    
+    # load sd to model
+    try:
+        sd = pl_sd["state_dict"]
+    except:
+        sd = pl_sd
+    model = instantiate_from_config(config.model)
+    model.load_state_dict(sd, strict=True)
+
+    if inject_lora:
+        net_load_lora(model, lora_path, alpha=lora_scale)
+    
+    # move to device & eval
+    if gpu_id is not None:
+        model.to(f"cuda:{gpu_id}")
+    else:
+        model.cuda()
+    model.eval()
+
+    return model, global_step, epoch
+
+
+# ------------------------------------------------------------------------------------------
+@torch.no_grad()
+def get_conditions(prompts, model, batch_size, cond_fps=None,):
+    
+    if isinstance(prompts, str) or isinstance(prompts, int):
+        prompts = [prompts]
+    if isinstance(prompts, list):
+        if len(prompts) == 1:
+            prompts = prompts * batch_size
+        elif len(prompts) == batch_size:
+            pass
+        else:
+            raise ValueError(f"invalid prompts length: {len(prompts)}")
+    else:
+        raise ValueError(f"invalid prompts: {prompts}")
+    assert(len(prompts) == batch_size)
+    
+    # content condition: text / class label
+    c = model.get_learned_conditioning(prompts)
+    key = 'c_concat' if model.conditioning_key == 'concat' else 'c_crossattn'
+    c = {key: [c]}
+
+    # temporal condition: fps
+    if getattr(model, 'cond_stage2_config', None) is not None:
+        if model.cond_stage2_key == "temporal_context":
+            assert(cond_fps is not None)
+            batch = {'fps': torch.tensor([cond_fps] * batch_size).long().to(model.device)}
+            fps_embd = model.cond_stage2_model(batch)
+            c[model.cond_stage2_key] = fps_embd
+    
+    return c
+
+
+# ------------------------------------------------------------------------------------------
+def make_model_input_shape(model, batch_size, T=None):
+    image_size = [model.image_size, model.image_size] if isinstance(model.image_size, int) else model.image_size
+    C = model.model.diffusion_model.in_channels
+    if T is None:
+        T = model.model.diffusion_model.temporal_length
+    shape = [batch_size, C, T, *image_size]
+    return shape
+
+
+# ------------------------------------------------------------------------------------------
+def custom_to_pil(x):
+    x = x.detach().cpu()
+    x = torch.clamp(x, -1., 1.)
+    x = (x + 1.) / 2.
+    x = x.permute(1, 2, 0).numpy()
+    x = (255 * x).astype(np.uint8)
+    x = Image.fromarray(x)
+    if not x.mode == "RGB":
+        x = x.convert("RGB")
+    return x
+
+def torch_to_np(x):
+    # saves the batch in adm style as in https://github.com/openai/guided-diffusion/blob/main/scripts/image_sample.py
+    sample = x.detach().cpu()
+    sample = ((sample + 1) * 127.5).clamp(0, 255).to(torch.uint8)
+    if sample.dim() == 5:
+        sample = sample.permute(0, 2, 3, 4, 1)
+    else:
+        sample = sample.permute(0, 2, 3, 1)
+    sample = sample.contiguous()
+    return sample
+
+def make_sample_dir(opt, global_step=None, epoch=None):
+    if not getattr(opt, 'not_automatic_logdir', False):
+        gs_str = f"globalstep{global_step:09}" if global_step is not None else "None"
+        e_str = f"epoch{epoch:06}" if epoch is not None else "None"
+        ckpt_dir = os.path.join(opt.logdir, f"{gs_str}_{e_str}")
+        
+        # subdir name
+        if opt.prompt_file is not None:
+            subdir = f"prompts_{os.path.splitext(os.path.basename(opt.prompt_file))[0]}"
+        else:
+            subdir = f"prompt_{opt.prompt[:10]}"
+        subdir += "_DDPM" if opt.vanilla_sample else f"_DDIM{opt.custom_steps}steps"
+        subdir += f"_CfgScale{opt.scale}"
+        if opt.cond_fps is not None:
+            subdir += f"_fps{opt.cond_fps}"
+        if opt.seed is not None:
+            subdir += f"_seed{opt.seed}"
+
+        return os.path.join(ckpt_dir, subdir)
+    else:
+        return opt.logdir

setup.py

@@ -0,0 +1,9 @@
+from setuptools import setup, find_packages
+
+setup(
+    name='lvdm',
+    version='0.0.1',
+    description='generic video generation models',
+    packages=find_packages(),
+    install_requires=[],
+)

videocrafter_test.py

@@ -0,0 +1,85 @@
+import os
+import time
+import yaml, math
+from tqdm import trange
+import torch
+import numpy as np
+from omegaconf import OmegaConf
+import torch.distributed as dist
+from pytorch_lightning import seed_everything
+
+from lvdm.samplers.ddim import DDIMSampler
+from lvdm.utils.common_utils import str2bool
+from lvdm.utils.saving_utils import npz_to_video_grid, npz_to_imgsheet_5d
+from scripts.sample_text2video import sample_text2video
+from scripts.sample_utils import load_model, get_conditions, make_model_input_shape, torch_to_np
+from lvdm.models.modules.lora import change_lora
+
+from huggingface_hub import hf_hub_download
+
+
+def save_results(videos, save_dir, 
+                 save_name="results", save_fps=8
+                 ):
+    save_subdir = os.path.join(save_dir, "videos")
+    os.makedirs(save_subdir, exist_ok=True)
+    for i in range(videos.shape[0]):
+        npz_to_video_grid(videos[i:i+1,...], 
+                            os.path.join(save_subdir, f"{save_name}_{i:03d}.mp4"), 
+                            fps=save_fps)
+    print(f'Successfully saved videos in {save_subdir}')
+    video_path_list = [os.path.join(save_subdir, f"{save_name}_{i:03d}.mp4") for i in range(videos.shape[0])]
+    return video_path_list
+    
+
+class Text2Video():
+    def __init__(self,result_dir='./tmp/') -> None:
+        self.download_model()
+        config_file = 'models/base_t2v/model_config.yaml'
+        ckpt_path = 'models/base_t2v/model.ckpt'
+        config = OmegaConf.load(config_file)
+        self.lora_path_list = ['','models/videolora/lora_001_Loving_Vincent_style.ckpt',
+                                'models/videolora/lora_002_frozenmovie_style.ckpt',
+                                'models/videolora/lora_003_MakotoShinkaiYourName_style.ckpt',
+                                'models/videolora/lora_004_coco_style.ckpt']
+
+        model, _, _ = load_model(config, ckpt_path, gpu_id=0, inject_lora=False)
+        self.model = model
+        self.last_time_lora = ''
+        self.last_time_lora_scale = 1.0
+        self.result_dir = result_dir
+        self.save_fps = 8
+        self.ddim_sampler = DDIMSampler(model) 
+
+    def get_prompt(self, input_text, steps=50, model_index=0, eta=1.0, cfg_scale=15.0, lora_scale=1.0, trigger_word=''):
+        if trigger_word !='':
+            input_text = input_text + ', ' + trigger_word
+        inject_lora = model_index > 0
+        change_lora(self.model, inject_lora=inject_lora, lora_scale=lora_scale, lora_path=self.lora_path_list[model_index],
+                    last_time_lora=self.last_time_lora, last_time_lora_scale=self.last_time_lora_scale)
+
+        all_videos = sample_text2video(self.model, input_text, n_samples=1, batch_size=1,
+                        sample_type='ddim', sampler=self.ddim_sampler,
+                        ddim_steps=steps, eta=eta, 
+                        cfg_scale=cfg_scale,
+                        )
+        prompt = input_text
+        prompt_str = prompt.replace("/", "_slash_") if "/" in prompt else prompt
+        prompt_str = prompt_str.replace(" ", "_") if " " in prompt else prompt_str
+        self.last_time_lora=self.lora_path_list[model_index]
+        self.last_time_lora_scale = lora_scale
+        video_path_list = save_results(all_videos, self.result_dir, save_name=prompt_str, save_fps=self.save_fps)
+        return video_path_list[0]
+    
+    def download_model(self):
+        REPO_ID = 'VideoCrafter/t2v-version-1-1'
+        filename_list = ['models/base_t2v/model.ckpt',
+                        'models/videolora/lora_001_Loving_Vincent_style.ckpt',
+                        'models/videolora/lora_002_frozenmovie_style.ckpt',
+                        'models/videolora/lora_003_MakotoShinkaiYourName_style.ckpt',
+                        'models/videolora/lora_004_coco_style.ckpt']
+        for filename in filename_list:
+            if not os.path.exists(filename):
+                hf_hub_download(repo_id=REPO_ID, filename=filename, local_dir='./', local_dir_use_symlinks=False)
+
+