CCEdit-main/sgm/models/diffusion.py

from contextlib import contextmanager
from typing import Any, Dict, List, Tuple, Union

import einops
import pytorch_lightning as pl
import torch
from omegaconf import ListConfig, OmegaConf
from safetensors.torch import load_file as load_safetensors
from torch.optim.lr_scheduler import LambdaLR

from sgm.modules.encoders.modules import VAEEmbedder
from sgm.modules.encoders.modules import (
    LineartEncoder,
    DepthZoeEncoder,
    DepthMidasEncoder,
    SoftEdgeEncoder,
    NormalBaeEncoder,
    ScribbleHEDEncoder,
    ScribblePidiNetEncoder,
    OpenposeEncoder,
    OutpaintingEncoder,
    InpaintingEncoder,
)

import os
import numpy as np
import torch.nn as nn

from ..modules import UNCONDITIONAL_CONFIG
from ..modules.diffusionmodules.wrappers import (
    OPENAIUNETWRAPPER,
    OPENAIUNETWRAPPERRAIG,
    OPENAIUNETWRAPPERCONTROLLDM3D,
    OPENAIUNETWRAPPERCONTROLLDM3DSSN,
    OPENAIUNETWRAPPERCONTROLLDM3DTV2V,
    OPENAIUNETWRAPPERCONTROLLDM3DTV2V_INTERPOLATE,
)
from ..modules.ema import LitEma
from ..util import (
    default,
    disabled_train,
    get_obj_from_str,
    instantiate_from_config,
    log_txt_as_img,
)

class DiffusionEngine(pl.LightningModule):
    def __init__(
        self,
        network_config,
        denoiser_config,
        first_stage_config,
        conditioner_config: Union[None, Dict, ListConfig, OmegaConf] = None,
        sampler_config: Union[None, Dict, ListConfig, OmegaConf] = None,
        optimizer_config: Union[None, Dict, ListConfig, OmegaConf] = None,
        scheduler_config: Union[None, Dict, ListConfig, OmegaConf] = None,
        loss_fn_config: Union[None, Dict, ListConfig, OmegaConf] = None,
        network_wrapper: Union[None, str] = None,
        ckpt_path: Union[None, str] = None,
        use_ema: bool = False,
        ema_decay_rate: float = 0.9999,
        scale_factor: float = 1.0,
        disable_first_stage_autocast=False,
        input_key: str = "jpg",
        log_keys: Union[List, None] = None,
        no_cond_log: bool = False,
        compile_model: bool = False,
    ):
        super().__init__()
        self.log_keys = log_keys
        self.input_key = input_key
        self.optimizer_config = default(
            optimizer_config, {"target": "torch.optim.AdamW"}
        )
        model = instantiate_from_config(network_config)
        wrapper_type = (
            self.wrapper_type if hasattr(self, "wrapper_type") else OPENAIUNETWRAPPER
        )
        self.model = get_obj_from_str(default(network_wrapper, wrapper_type))(
            model, compile_model=compile_model
        )

        self.denoiser = instantiate_from_config(denoiser_config)
        self.sampler = (
            instantiate_from_config(sampler_config)
            if sampler_config is not None
            else None
        )
        self.conditioner = instantiate_from_config(
            default(conditioner_config, UNCONDITIONAL_CONFIG)
        )
        self.scheduler_config = scheduler_config
        self._init_first_stage(first_stage_config)

        self.loss_fn = (
            instantiate_from_config(loss_fn_config)
            if loss_fn_config is not None
            else None
        )

        self.use_ema = use_ema
        if self.use_ema:
            self.model_ema = LitEma(self.model, decay=ema_decay_rate)
            print(f"Keeping EMAs of {len(list(self.model_ema.buffers()))}.")

        self.scale_factor = scale_factor
        self.disable_first_stage_autocast = disable_first_stage_autocast
        self.no_cond_log = no_cond_log

        if ckpt_path is not None:
            self.init_from_ckpt(ckpt_path)

    def init_from_ckpt(
        self,
        path: str,
    ) -> None:
        print(f"Loading checkpoint from {path} ... ")
        if path.endswith("ckpt"):
            # sd = torch.load(path, map_location="cpu")["state_dict"]
            if "deepspeed" in path:
                sd = torch.load(path, map_location="cpu")
                sd = {k.replace("_forward_module.", ""): v for k, v in sd.items()}
            else:
                sd = torch.load(path, map_location="cpu")["state_dict"]
        elif path.endswith("safetensors"):
            sd = load_safetensors(path)
        else:
            raise NotImplementedError

        missing, unexpected = self.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 _init_first_stage(self, config):
        model = instantiate_from_config(config).eval()
        model.train = disabled_train
        for param in model.parameters():
            param.requires_grad = False
        self.first_stage_model = model

    def get_input(self, batch):
        # assuming unified data format, dataloader returns a dict.
        # image tensors should be scaled to -1 ... 1 and in bchw format
        return batch[self.input_key]

    @torch.no_grad()
    def decode_first_stage(self, z):
        z = 1.0 / self.scale_factor * z
        with torch.autocast("cuda", enabled=not self.disable_first_stage_autocast):
            out = self.first_stage_model.decode(z)
        return out

    @torch.no_grad()
    def encode_first_stage(self, x):
        with torch.autocast("cuda", enabled=not self.disable_first_stage_autocast):
            z = self.first_stage_model.encode(x)
        z = self.scale_factor * z
        return z

    def forward(self, x, batch):
        loss = self.loss_fn(self.model, self.denoiser, self.conditioner, x, batch)
        loss_mean = loss.mean()
        loss_dict = {"loss": loss_mean}
        return loss_mean, loss_dict

    def shared_step(self, batch: Dict) -> Any:
        x = self.get_input(batch)
        x = self.encode_first_stage(x)
        batch["global_step"] = self.global_step
        loss, loss_dict = self(x, batch)
        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=False
        )

        self.log(
            "global_step",
            self.global_step,
            prog_bar=True,
            logger=True,
            on_step=True,
            on_epoch=False,
        )

        if self.scheduler_config is not None:
            lr = self.optimizers().param_groups[0]["lr"]
            self.log(
                "lr_abs", lr, prog_bar=True, logger=True, on_step=True, on_epoch=False
            )

        return loss

    def on_train_start(self, *args, **kwargs):
        if self.sampler is None or self.loss_fn is None:
            raise ValueError("Sampler and loss function need to be set for training.")

    def on_train_batch_end(self, *args, **kwargs):
        if self.use_ema:
            self.model_ema(self.model)

    @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 instantiate_optimizer_from_config(self, params, lr, cfg):
        return get_obj_from_str(cfg["target"])(
            params, lr=lr, **cfg.get("params", dict())
        )

    def configure_optimizers(self):
        lr = self.learning_rate
        params = list(self.model.parameters())
        for embedder in self.conditioner.embedders:
            if embedder.is_trainable:
                params = params + list(embedder.parameters())
        opt = self.instantiate_optimizer_from_config(params, lr, self.optimizer_config)
        if self.scheduler_config is not None:
            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 sample(
        self,
        cond: Dict,
        uc: Union[Dict, None] = None,
        batch_size: int = 16,
        shape: Union[None, Tuple, List] = None,
        **kwargs,
    ):
        randn = torch.randn(batch_size, *shape).to(self.device)

        denoiser = lambda input, sigma, c: self.denoiser(
            self.model, input, sigma, c, **kwargs
        )
        samples = self.sampler(denoiser, randn, cond, uc=uc)
        return samples

    @torch.no_grad()
    def log_conditionings(self, batch: Dict, n: int) -> Dict:
        """
        Defines heuristics to log different conditionings.
        These can be lists of strings (text-to-image), tensors, ints, ...
        """
        image_h, image_w = batch[self.input_key].shape[2:]
        log = dict()

        for embedder in self.conditioner.embedders:
            if (
                (self.log_keys is None) or (embedder.input_key in self.log_keys)
            ) and not self.no_cond_log:
                x = batch[embedder.input_key][:n]
                if isinstance(x, torch.Tensor):
                    if x.dim() == 1:
                        # class-conditional, convert integer to string
                        x = [str(x[i].item()) for i in range(x.shape[0])]
                        xc = log_txt_as_img((image_h, image_w), x, size=image_h // 4)
                    elif x.dim() == 2:
                        # size and crop cond and the like
                        x = [
                            "x".join([str(xx) for xx in x[i].tolist()])
                            for i in range(x.shape[0])
                        ]
                        xc = log_txt_as_img((image_h, image_w), x, size=image_h // 20)
                    else:
                        raise NotImplementedError()
                elif isinstance(x, (List, ListConfig)):
                    if isinstance(x[0], str):
                        # strings
                        # xc = log_txt_as_img((image_h, image_w), x, size=image_h // 20)
                        # xc = log_txt_as_img((image_w * 2, image_h), x, size=image_h // 15)
                        xc = log_txt_as_img(
                            (image_w * 2, image_h), x, size=image_h // 25
                        )
                    else:
                        raise NotImplementedError()
                else:
                    raise NotImplementedError()
                log[embedder.input_key] = xc
        return log

    @torch.no_grad()
    def log_images(
        self,
        batch: Dict,
        N: int = 8,
        sample: bool = True,
        ucg_keys: List[str] = None,
        **kwargs,
    ) -> Dict:
        conditioner_input_keys = [e.input_key for e in self.conditioner.embedders]
        if ucg_keys:
            assert all(map(lambda x: x in conditioner_input_keys, ucg_keys)), (
                "Each defined ucg key for sampling must be in the provided conditioner input keys,"
                f"but we have {ucg_keys} vs. {conditioner_input_keys}"
            )
        else:
            ucg_keys = conditioner_input_keys
        log = dict()

        x = self.get_input(batch)

        c, uc = self.conditioner.get_unconditional_conditioning(
            batch,
            force_uc_zero_embeddings=ucg_keys
            if len(self.conditioner.embedders) > 0
            else [],
        )

        sampling_kwargs = {}

        N = min(x.shape[0], N)
        x = x.to(self.device)[:N]
        log["inputs"] = x
        z = self.encode_first_stage(x)
        log["reconstructions"] = self.decode_first_stage(z)
        log.update(self.log_conditionings(batch, N))

        for k in c:
            if isinstance(c[k], torch.Tensor):
                c[k], uc[k] = map(lambda y: y[k][:N].to(self.device), (c, uc))

        if sample:
            with self.ema_scope("Plotting"):
                samples = self.sample(
                    c, shape=z.shape[1:], uc=uc, batch_size=N, **sampling_kwargs
                )
            samples = self.decode_first_stage(samples)
            log["samples"] = samples
        return log


class VideoDiffusionEngine(DiffusionEngine):
    def __init__(
        self,
        freeze_model="none",
        wrapper_type="OPENAIUNETWRAPPERCONTROLLDM3D",
        *args,
        **kwargs,
    ):
        self.wrapper_type = eval(wrapper_type)
        super().__init__(*args, **kwargs)
        self.freeze_model = freeze_model

        self.setup_vaeembedder()

    def setup_vaeembedder(self):
        for embedder in self.conditioner.embedders:
            if isinstance(embedder, VAEEmbedder):
                embedder.first_stage_model = (
                    self.first_stage_model
                )  # TODO: should we add .clone()
                embedder.disable_first_stage_autocast = (
                    self.disable_first_stage_autocast
                )
                embedder.scale_factor = self.scale_factor
                embedder.freeze()

    def get_input(self, batch):
        # assuming unified data format, dataloader returns a dict.
        # video tensors should be scaled to -1 ... 1 and in bcthw format
        out_data = batch[self.input_key]
        return out_data

    def shared_step(self, batch: Dict) -> Any:
        x = self.get_input(batch)
        x = self.encode_first_stage(x)
        batch["global_step"] = self.global_step
        loss, loss_dict = self(x, batch)
        return loss, loss_dict

    @torch.no_grad()
    def log_conditionings(self, batch: Dict, n: int) -> Dict:
        """
        Defines heuristics to log different conditionings.
        These can be lists of strings (text-to-image), tensors, ints, ...
        """
        image_h, image_w = batch[self.input_key].shape[-2:]
        log = dict()

        for embedder in self.conditioner.embedders:
            if (
                (self.log_keys is None) or (embedder.input_key in self.log_keys)
            ) and not self.no_cond_log:
                x = batch[embedder.input_key][:n]
                if isinstance(x, torch.Tensor):
                    if x.dim() == 1:
                        # class-conditional, convert integer to string
                        x = [str(x[i].item()) for i in range(x.shape[0])]
                        xc = log_txt_as_img((image_h, image_w), x, size=image_h // 4)
                    elif x.dim() == 2:
                        # size and crop cond and the like
                        x = [
                            "x".join([str(xx) for xx in x[i].tolist()])
                            for i in range(x.shape[0])
                        ]
                        xc = log_txt_as_img((image_h, image_w), x, size=image_h // 20)
                    else:
                        raise NotImplementedError()
                elif isinstance(x, (List, ListConfig)):
                    if isinstance(x[0], str):
                        # strings
                        # xc = log_txt_as_img((image_w, image_h), x, size=image_h // 20)
                        xc = log_txt_as_img(
                            (image_w, image_h), x, size=image_h // 10, split_loc=15
                        )
                        # xc = log_txt_as_img((image_w * 2, image_h), x, size=image_h // 15, split_loc=20)
                        # xc = log_txt_as_img(
                        #     (image_w * 3, image_h), x, size=image_h // 5, split_loc=15
                        # )
                    else:
                        raise NotImplementedError()
                else:
                    raise NotImplementedError()
                log[embedder.input_key] = xc
        return log

    @torch.no_grad()
    def log_images(
        self,
        batch: Dict,
        N: int = 8,
        sample: bool = True,
        ucg_keys: List[str] = None,
        **kwargs,
    ) -> Dict:
        # TODO: refactor this
        conditioner_input_keys = [e.input_key for e in self.conditioner.embedders]
        if ucg_keys:
            assert all(map(lambda x: x in conditioner_input_keys, ucg_keys)), (
                "Each defined ucg key for sampling must be in the provided conditioner input keys,"
                f"but we have {ucg_keys} vs. {conditioner_input_keys}"
            )
        else:
            ucg_keys = conditioner_input_keys
        log = dict()

        x = self.get_input(batch)

        c, uc = self.conditioner.get_unconditional_conditioning(
            batch,
            force_uc_zero_embeddings=ucg_keys
            if len(self.conditioner.embedders) > 0
            else [],
        )

        sampling_kwargs = {
            key: batch[key] for key in self.loss_fn.batch2model_keys.intersection(batch)
        }

        N = min(x.shape[0], N)
        x = x.to(self.device)[:N]
        log["inputs"] = x
        log["inputs-video"] = x
        log["cond_img"] = batch["cond_img"]
        z = self.encode_first_stage(x)
        log["reconstructions"] = self.decode_first_stage(z)
        log["reconstructions-video"] = self.decode_first_stage(z)
        log.update(self.log_conditionings(batch, N))

        for k in c:
            if isinstance(c[k], torch.Tensor):
                c[k], uc[k] = map(lambda y: y[k][:N].to(self.device), (c, uc))

        if sample:
            with self.ema_scope("Plotting"):
                samples = self.sample(
                    c, shape=z.shape[1:], uc=uc, batch_size=N, **sampling_kwargs
                )
            samples = self.decode_first_stage(samples)
            log["samples"] = samples
            log["samples-video"] = samples

        # concat the inputs and outputs for visualization
        log["inputs_samples"] = torch.cat([log["inputs"], log["samples"]], dim=3)
        del log["inputs"]
        del log["samples"]
        # log['inputs_samples-video'] = torch.cat([log['inputs-video'], log['samples-video']], dim=3)
        # del log['inputs-video']
        # del log['samples-video']
        return log

    def configure_optimizers(self):
        lr = self.learning_rate

        if self.freeze_model == "none":
            params = list(self.model.diffusion_model.parameters())
            for name, param in self.model.diffusion_model.named_parameters():
                print(f"Setting {name} to trainable")
                param.requires_grad = True  # TODO: why this?
        elif self.freeze_model == "spatial":
            params = []
            if hasattr(self.model.diffusion_model, "controlnet"):
                params += list(self.model.diffusion_model.controlnet.parameters())
            for name, param in self.model.diffusion_model.named_parameters():
                if "controlnet" not in name:
                    if "temporal" in name:
                        params.append(param)
                    else:
                        param.requires_grad = False
        elif self.freeze_model == "spatial_openlora":
            params = []
            if hasattr(self.model.diffusion_model, "controlnet"):
                params += list(self.model.diffusion_model.controlnet.parameters())
            for name, param in self.model.diffusion_model.named_parameters():
                if "controlnet" not in name:
                    if "temporal" in name or "lora" in name:
                        params.append(param)
                    else:
                        param.requires_grad = False
        else:
            raise NotImplementedError

        for embedder in self.conditioner.embedders:
            if embedder.is_trainable:
                params = params + list(embedder.parameters())
        opt = self.instantiate_optimizer_from_config(params, lr, self.optimizer_config)
        if self.scheduler_config is not None:
            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

# -----------------------------------------------------
class VideoDiffusionEngineTV2V(VideoDiffusionEngine):
    def __init__(self, *args, **kwargs):
        # kwargs['wrapper_type'] = OPENAIUNETWRAPPERCONTROLLDM3DTV2V
        kwargs["wrapper_type"] = kwargs.get(
            "wrapper_type", "OPENAIUNETWRAPPERCONTROLLDM3DTV2V"
        )
        super().__init__(*args, **kwargs)

        # freeze the controlnet (load pre-trained weights, no need to train)
        self.model.diffusion_model.controlnet.eval()
        for name, param in self.model.diffusion_model.controlnet.named_parameters():
            param.requires_grad = False

        if hasattr(self.model.diffusion_model, "controlnet_img"):
            print('Setting controlnet_img to trainable ... ')
            # open the controlnet_img
            for (
                name,
                param,
            ) in self.model.diffusion_model.controlnet_img.named_parameters():
                param.requires_grad = True

    def init_from_ckpt(
        self,
        path: str,
    ) -> None:
        print(f"Loading checkpoint from {path} ... ")
        if path.endswith("ckpt"):
            if "deepspeed" in path:
                sd = torch.load(path, map_location="cpu")
                sd = {k.replace("_forward_module.", ""): v for k, v in sd.items()}
            else:
                sd = torch.load(path, map_location="cpu")["state_dict"]
        elif path.endswith("safetensors"):
            sd = load_safetensors(path)
        else:
            raise NotImplementedError

        missing, unexpected = self.load_state_dict(sd, strict=False)

        print(
            f"Restored from {path} with {len(missing)} missing and {len(unexpected)} unexpected keys"
        )
        if len(missing) > 0:
            print(f"Missing Keys: {missing}")
        if len(unexpected) > 0:
            print(f"Unexpected Keys: {unexpected}")

    @torch.no_grad()
    def log_images(
        self,
        batch: Dict,
        N: int = 8,
        sample: bool = True,
        ucg_keys: List[str] = None,
        **kwargs,
    ) -> Dict:
        conditioner_input_keys = [e.input_key for e in self.conditioner.embedders]
        if ucg_keys:
            assert all(map(lambda x: x in conditioner_input_keys, ucg_keys)), (
                "Each defined ucg key for sampling must be in the provided conditioner input keys,"
                f"but we have {ucg_keys} vs. {conditioner_input_keys}"
            )
        else:
            ucg_keys = conditioner_input_keys
        log = dict()

        x = self.get_input(batch)

        negative_prompt = "ugly, low quality"
        batch_uc = {
            "txt": [negative_prompt for i in range(x.shape[0])],
            "control_hint": batch[
                "control_hint"
            ].clone(),  # to use the pretrained weights, we must use the same control_hint in the batch_uc
        }
        if "cond_img" in batch.keys():  # for TVI2V;
            # TODO: in fact, we can delete this, just use empty tensor as cond_img for batch_uc
            batch_uc["cond_img"] = batch["cond_img"].clone()  
            # batch_uc['cond_img'] = torch.zeros_like(batch['cond_img'])
        batch["txt"] = ["masterpiece, best quality, " + each for each in batch["txt"]]
        c, uc = self.conditioner.get_unconditional_conditioning(
            batch_c=batch,
            batch_uc=batch_uc,
        )

        sampling_kwargs = {
            key: batch[key] for key in self.loss_fn.batch2model_keys.intersection(batch)
        }

        N = min(x.shape[0], N)
        x = x.to(self.device)[:N]
        log["inputs"] = x
        log["inputs-video"] = x
        if "cond_img" in batch.keys():
            log["cond_img"] = batch["cond_img"]
        z = self.encode_first_stage(x)
        # log["reconstructions"] = self.decode_first_stage(z)
        # log["reconstructions-video"] = self.decode_first_stage(z)
        log.update(self.log_conditionings(batch, N))

        for k in c:
            if isinstance(c[k], torch.Tensor):
                c[k], uc[k] = map(lambda y: y[k][:N].to(self.device), (c, uc))

        if sample:
            with self.ema_scope("Plotting"):
                samples = self.sample(
                    c, shape=z.shape[1:], uc=uc, batch_size=N, **sampling_kwargs
                )
            samples = self.decode_first_stage(samples)
            log["samples"] = samples
            log["samples-video"] = samples

        for embedder in self.conditioner.embedders:
            if (
                isinstance(embedder, LineartEncoder)
                or isinstance(embedder, DepthZoeEncoder)
                or isinstance(embedder, DepthMidasEncoder)
                or isinstance(embedder, SoftEdgeEncoder)
                or isinstance(embedder, NormalBaeEncoder)
                or isinstance(embedder, ScribbleHEDEncoder)
                or isinstance(embedder, ScribblePidiNetEncoder)
                or isinstance(embedder, OpenposeEncoder)
                or isinstance(embedder, OutpaintingEncoder)
                or isinstance(embedder, InpaintingEncoder)
            ):
                # log['control_hint'] = embedder.encode(batch['control_hint'])
                # log['control_hint-video'] = embedder.encode(batch['control_hint'])
                log["control_hint"] = -embedder.encode(batch["control_hint"])
                log["control_hint-video"] = -embedder.encode(batch["control_hint"])
                break

        # concat the inputs and outputs for visualization
        log["inputs_samples_hint"] = torch.cat(
            [log["inputs"], log["samples"], log["control_hint"]], dim=3
        )
        del log["inputs"]
        del log["samples"]
        del log["control_hint"]

        log["inputs_samples_hint-video"] = torch.cat(
            [log["inputs-video"], log["samples-video"], log["control_hint-video"]],
            dim=3,
        )
        del log["inputs-video"]
        del log["samples-video"]
        del log["control_hint-video"]
        return log

    def configure_optimizers(self):
        lr = self.learning_rate

        if self.freeze_model == "none":
            params = list(self.model.diffusion_model.parameters())
            for name, param in self.model.diffusion_model.named_parameters():
                print(f"Setting {name} to trainable")
                param.requires_grad = True
        elif self.freeze_model == "spatial":
            params = []
            if hasattr(self.model.diffusion_model, "controlnet"):
                params += list(self.model.diffusion_model.controlnet.parameters())
            if hasattr(self.model.diffusion_model, "controlnet_img"):
                params += list(self.model.diffusion_model.controlnet_img.parameters())
            for name, param in self.model.diffusion_model.named_parameters():
                if "controlnet" not in name:
                    if "temporal" in name:
                        params.append(param)
                    else:
                        param.requires_grad = False
        else:
            raise NotImplementedError

        for embedder in self.conditioner.embedders:
            if embedder.is_trainable:
                params = params + list(embedder.parameters())
        opt = self.instantiate_optimizer_from_config(params, lr, self.optimizer_config)
        if self.scheduler_config is not None:
            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


class VideoDiffusionEngineTV2VInterpolate(VideoDiffusionEngineTV2V):
    def __init__(self, *args, **kwargs):
        kwargs["wrapper_type"] = "OPENAIUNETWRAPPERCONTROLLDM3DTV2V_INTERPOLATE"
        super().__init__(*args, **kwargs)

    @torch.no_grad()
    def log_images(
        self,
        batch: Dict,
        N: int = 8,
        sample: bool = True,
        ucg_keys: List[str] = None,
        **kwargs,
    ) -> Dict:
        conditioner_input_keys = [e.input_key for e in self.conditioner.embedders]
        if ucg_keys:
            assert all(map(lambda x: x in conditioner_input_keys, ucg_keys)), (
                "Each defined ucg key for sampling must be in the provided conditioner input keys,"
                f"but we have {ucg_keys} vs. {conditioner_input_keys}"
            )
        else:
            ucg_keys = conditioner_input_keys
        log = dict()

        x = self.get_input(batch)

        # negative_prompt = "ugly, low quality"
        negative_prompt = ''
        batch_uc = {
            "txt": [negative_prompt for i in range(x.shape[0])],
            "control_hint": batch["control_hint"].clone(),
            "interpolate_first_last": batch["interpolate_first_last"].clone(),
        }
        # TODO: specify this in the config file
        batch["txt"] = ['' for each in batch["txt"]]  # disbale text prompt
        # batch["txt"] = ["masterpiece, best quality, " + each for each in batch["txt"]]
        # batch['txt'] = ['masterpiece, best quality' for each in batch['txt']]  # disbale text prompt

        c, uc = self.conditioner.get_unconditional_conditioning(
            batch_c=batch,
            batch_uc=batch_uc,
        )

        sampling_kwargs = {
            key: batch[key] for key in self.loss_fn.batch2model_keys.intersection(batch)
        }

        N = min(x.shape[0], N)
        x = x.to(self.device)[:N]
        log["inputs"] = x
        log["inputs-video"] = x
        # log['interpolate_first_last'] = torch.cat([batch['interpolate_first'], batch['interpolate_last']], dim=2)
        from sgm.modules.encoders.modules import CustomIdentityEncoder, CustomIdentityDownCondEncoder

        for embedder in self.conditioner.embedders:
            if isinstance(embedder, CustomIdentityEncoder) or isinstance(embedder, CustomIdentityDownCondEncoder):
                log["interpolate_first_last"] = embedder.encode(batch["interpolate_first_last"])[:,:3,:,...]    # in case of more than 3
                break
        z = self.encode_first_stage(x)
        # log["reconstructions"] = self.decode_first_stage(z)
        # log["reconstructions-video"] = self.decode_first_stage(z)
        log.update(self.log_conditionings(batch, N))

        for k in c:
            if isinstance(c[k], torch.Tensor):
                c[k], uc[k] = map(lambda y: y[k][:N].to(self.device), (c, uc))

        if sample:
            with self.ema_scope("Plotting"):
                samples = self.sample(
                    c, shape=z.shape[1:], uc=uc, batch_size=N, **sampling_kwargs
                )
            samples = self.decode_first_stage(samples)
            log["samples"] = samples
            log["samples-video"] = samples

        for embedder in self.conditioner.embedders:
            if (
                isinstance(embedder, LineartEncoder)
                or isinstance(embedder, DepthZoeEncoder)
                or isinstance(embedder, DepthMidasEncoder)
                or isinstance(embedder, SoftEdgeEncoder)
                or isinstance(embedder, NormalBaeEncoder)
                or isinstance(embedder, ScribbleHEDEncoder)
                or isinstance(embedder, ScribblePidiNetEncoder)
                or isinstance(embedder, OpenposeEncoder)
                or isinstance(embedder, OutpaintingEncoder)
                or isinstance(embedder, InpaintingEncoder)
            ):
                log["control_hint"] = -embedder.encode(batch["control_hint"])
                log["control_hint-video"] = -embedder.encode(batch["control_hint"])
                break

        # concat the inputs and outputs for visualization
        log["inputs_samples_hint"] = torch.cat(
            [log["inputs"], log["samples"], log["control_hint"]], dim=3
        )
        del log["inputs"]
        del log["samples"]
        del log["control_hint"]

        log["inputs_samples_hint-video"] = torch.cat(
            [log["inputs-video"], log["samples-video"], log["control_hint-video"]],
            dim=3,
        )
        del log["inputs-video"]
        del log["samples-video"]
        del log["control_hint-video"]
        return log


if __name__ == "__main__":
    import logging

    import yaml

    open("output.log", "w").close()

    logging.basicConfig(
        level=logging.DEBUG,
        filename="output.log",
        datefmt="%Y/%m/%d %H:%M:%S",
        format="%(asctime)s - %(name)s - %(levelname)s - %(lineno)d - %(module)s - %(message)s",
    )
    logger = logging.getLogger(__name__)
    # logger.info('This is a log info')
    # logger.debug('Debugging')
    # logger.warning('Warning exists')
    # logger.info('Finish')

    BS = 2
    frame_length = 17
    # size = [BS, frame_length, 3, 320, 320]
    size = [BS, 3, 320, 320]
    batch = {
        "jpg": torch.randn(size).cuda(),
        "txt": BS * ["text"],
        "original_size_as_tuple": torch.tensor([320, 320]).repeat(BS, 1).cuda(),
        "crop_coords_top_left": torch.tensor([0, 0]).repeat(BS, 1).cuda(),
        "target_size_as_tuple": torch.tensor([320, 320]).repeat(BS, 1).cuda(),
    }

    model_config = yaml.load(
        open("configs/example_training/sd_xl_base-test.yaml"), Loader=yaml.Loader
    )["model"]

    learning_rate = model_config.pop("base_learning_rate")
    model = DiffusionEngine(**model_config["params"]).cuda()
    model.learning_rate = learning_rate
    logger.info(model)

    opt = model.configure_optimizers()

    while True:
        # out = model.shared_step(batch)
        loss = model.training_step(batch, 1)
        print(f"loss: {loss}")
        loss.backward()
        opt[0][0].step()
        opt[0][0].zero_grad()