Add files using upload-large-folder tool

CCEdit-main/configs/example_training/autoencoder/kl-f4/imagenet-attnfree-logvar.yaml

@@ -0,0 +1,115 @@
+model:
+  base_learning_rate: 4.5e-6
+  target: sgm.models.autoencoder.AutoencodingEngine
+  params:
+    input_key: jpg
+    monitor: val/rec_loss
+
+    loss_config:
+      target: sgm.modules.autoencoding.losses.GeneralLPIPSWithDiscriminator
+      params:
+        perceptual_weight: 0.25
+        disc_start: 20001
+        disc_weight: 0.5
+        learn_logvar: True
+
+        regularization_weights:
+          kl_loss: 1.0
+
+    regularizer_config:
+      target: sgm.modules.autoencoding.regularizers.DiagonalGaussianRegularizer
+
+    encoder_config:
+      target: sgm.modules.diffusionmodules.model.Encoder
+      params:
+        attn_type: none
+        double_z: True
+        z_channels: 4
+        resolution: 256
+        in_channels: 3
+        out_ch: 3
+        ch: 128
+        ch_mult: [ 1, 2, 4 ]
+        num_res_blocks: 4
+        attn_resolutions: [ ]
+        dropout: 0.0
+
+    decoder_config:
+      target: sgm.modules.diffusionmodules.model.Decoder
+      params:
+        attn_type: none
+        double_z: False
+        z_channels: 4
+        resolution: 256
+        in_channels: 3
+        out_ch: 3
+        ch: 128
+        ch_mult: [ 1, 2, 4 ]
+        num_res_blocks: 4
+        attn_resolutions: [ ]
+        dropout: 0.0
+
+data:
+  target: sgm.data.dataset.StableDataModuleFromConfig
+  params:
+    train:
+      datapipeline:
+        urls:
+          - "DATA-PATH"
+        pipeline_config:
+          shardshuffle: 10000
+          sample_shuffle: 10000
+
+        decoders:
+          - "pil"
+
+        postprocessors:
+          - target: sdata.mappers.TorchVisionImageTransforms
+            params:
+              key: 'jpg'
+              transforms:
+                - target: torchvision.transforms.Resize
+                  params:
+                    size: 256
+                    interpolation: 3
+                - target: torchvision.transforms.ToTensor
+          - target: sdata.mappers.Rescaler
+          - target: sdata.mappers.AddOriginalImageSizeAsTupleAndCropToSquare
+            params:
+              h_key: height
+              w_key: width
+
+      loader:
+        batch_size: 8
+        num_workers: 4
+
+
+lightning:
+  strategy:
+    target: pytorch_lightning.strategies.DDPStrategy
+    params:
+      find_unused_parameters: True
+
+  modelcheckpoint:
+    params:
+      every_n_train_steps: 5000
+
+  callbacks:
+    metrics_over_trainsteps_checkpoint:
+      params:
+        every_n_train_steps: 50000
+
+    image_logger:
+      target: main.ImageLogger
+      params:
+        enable_autocast: False
+        batch_frequency: 1000
+        max_images: 8
+        increase_log_steps: True
+
+  trainer:
+    devices: 0,
+    limit_val_batches: 50
+    benchmark: True
+    accumulate_grad_batches: 1
+    val_check_interval: 10000

CCEdit-main/configs/example_training/imagenet-f8_cond.yaml

@@ -0,0 +1,188 @@
+model:
+  base_learning_rate: 1.0e-4
+  target: sgm.models.diffusion.DiffusionEngine
+  params:
+    scale_factor: 0.13025
+    disable_first_stage_autocast: True
+    log_keys:
+      - cls
+
+    scheduler_config:
+      target: sgm.lr_scheduler.LambdaLinearScheduler
+      params:
+        warm_up_steps: [10000]
+        cycle_lengths: [10000000000000]
+        f_start: [1.e-6]
+        f_max: [1.]
+        f_min: [1.]
+
+    denoiser_config:
+      target: sgm.modules.diffusionmodules.denoiser.DiscreteDenoiser
+      params:
+        num_idx: 1000
+
+        weighting_config:
+          target: sgm.modules.diffusionmodules.denoiser_weighting.EpsWeighting
+        scaling_config:
+          target: sgm.modules.diffusionmodules.denoiser_scaling.EpsScaling
+        discretization_config:
+          target: sgm.modules.diffusionmodules.discretizer.LegacyDDPMDiscretization
+
+    network_config:
+      target: sgm.modules.diffusionmodules.openaimodel.UNetModel
+      params:
+        use_checkpoint: True
+        use_fp16: True
+        in_channels: 4
+        out_channels: 4
+        model_channels: 256
+        attention_resolutions: [1, 2, 4]
+        num_res_blocks: 2
+        channel_mult: [1, 2, 4]
+        num_head_channels: 64
+        num_classes: sequential
+        adm_in_channels: 1024
+        use_spatial_transformer: true
+        transformer_depth: 1
+        context_dim: 1024
+        spatial_transformer_attn_type: softmax-xformers
+
+    conditioner_config:
+      target: sgm.modules.GeneralConditioner
+      params:
+        emb_models:
+          # crossattn cond
+          - is_trainable: True
+            input_key: cls
+            ucg_rate: 0.2
+            target: sgm.modules.encoders.modules.ClassEmbedder
+            params:
+              add_sequence_dim: True  # will be used through crossattn then
+              embed_dim: 1024
+              n_classes: 1000
+          # vector cond
+          - is_trainable: False
+            ucg_rate: 0.2
+            input_key: original_size_as_tuple
+            target: sgm.modules.encoders.modules.ConcatTimestepEmbedderND
+            params:
+              outdim: 256  # multiplied by two
+          # vector cond
+          - is_trainable: False
+            input_key: crop_coords_top_left
+            ucg_rate: 0.2
+            target: sgm.modules.encoders.modules.ConcatTimestepEmbedderND
+            params:
+              outdim: 256  # multiplied by two
+
+    first_stage_config:
+      target: sgm.models.autoencoder.AutoencoderKLInferenceWrapper
+      params:
+        ckpt_path: CKPT_PATH
+        embed_dim: 4
+        monitor: val/rec_loss
+        ddconfig:
+          attn_type: vanilla-xformers
+          double_z: true
+          z_channels: 4
+          resolution: 256
+          in_channels: 3
+          out_ch: 3
+          ch: 128
+          ch_mult: [1, 2, 4, 4]
+          num_res_blocks: 2
+          attn_resolutions: []
+          dropout: 0.0
+        lossconfig:
+          target: torch.nn.Identity
+
+    loss_fn_config:
+      target: sgm.modules.diffusionmodules.loss.StandardDiffusionLoss
+      params:
+        sigma_sampler_config:
+          target: sgm.modules.diffusionmodules.sigma_sampling.DiscreteSampling
+          params:
+            num_idx: 1000
+
+            discretization_config:
+              target: sgm.modules.diffusionmodules.discretizer.LegacyDDPMDiscretization
+
+    sampler_config:
+      target: sgm.modules.diffusionmodules.sampling.EulerEDMSampler
+      params:
+        num_steps: 50
+
+        discretization_config:
+          target: sgm.modules.diffusionmodules.discretizer.LegacyDDPMDiscretization
+
+        guider_config:
+          target: sgm.modules.diffusionmodules.guiders.VanillaCFG
+          params:
+            scale: 5.0
+
+data:
+  target: sgm.data.dataset.StableDataModuleFromConfig
+  params:
+    train:
+      datapipeline:
+        urls:
+          # USER: adapt this path the root of your custom dataset
+          - "DATA_PATH"
+        pipeline_config:
+          shardshuffle: 10000
+          sample_shuffle: 10000 # USER: you might wanna adapt depending on your available RAM
+
+        decoders:
+          - "pil"
+
+        postprocessors:
+          - target: sdata.mappers.TorchVisionImageTransforms
+            params:
+              key: 'jpg' # USER: you might wanna adapt this for your custom dataset
+              transforms:
+                - target: torchvision.transforms.Resize
+                  params:
+                    size: 256
+                    interpolation: 3
+                - target: torchvision.transforms.ToTensor
+          - target: sdata.mappers.Rescaler
+
+          - target: sdata.mappers.AddOriginalImageSizeAsTupleAndCropToSquare
+            params:
+              h_key: height # USER: you might wanna adapt this for your custom dataset
+              w_key: width # USER: you might wanna adapt this for your custom dataset
+
+      loader:
+        batch_size: 64
+        num_workers: 6
+
+lightning:
+  modelcheckpoint:
+    params:
+      every_n_train_steps: 5000
+
+  callbacks:
+    metrics_over_trainsteps_checkpoint:
+      params:
+        every_n_train_steps: 25000
+
+    image_logger:
+      target: main.ImageLogger
+      params:
+        disabled: False
+        enable_autocast: False
+        batch_frequency: 1000
+        max_images: 8
+        increase_log_steps: True
+        log_first_step: False
+        log_images_kwargs:
+          use_ema_scope: False
+          N: 8
+          n_rows: 2
+
+  trainer:
+    devices: 0,
+    benchmark: True
+    num_sanity_val_steps: 0
+    accumulate_grad_batches: 1
+    max_epochs: 1000

CCEdit-main/configs/example_training/sd_1_5_controlldm-test-cp-no2ndca-add-cfca-depthmidas.yaml

@@ -0,0 +1,270 @@
+# tvi2v: condition on the frame, text, and video to generate the video
+# cp: copy weights from diffusion_model/unet to controlnet_img. Use VAE to extract the 8x downsampled image.
+# no2ndca: no second cross attention (text cross attention) in the temporal layers
+# add: add the features of reference image on the features of center frame of the main SD model
+# cfca: cross-frame cross-attention, in the main SD model, for each token as query, take the features of center image and current frame as the key and value
+
+
+
+InputFPS: &InputFPS 4
+FrameLength: &FrameLength 17
+BatchSize: &BatchSize 1
+NumGPU: &NumGPU 1
+NumNodes: &NumNodes 1
+BaseLearningRate: &BaseLearningRate 5.0e-5
+DataDir: &DataDir /PATH/TO/YOUR/DATA  # specify your data dir
+MetadataDir: &MetadataDir /PATH/TO/YOUR/METADATA  # specify your metadata dir
+ResolutionH: &ResolutionH 384
+ResolutionW: &ResolutionW 512
+Split: &Split "val" # * Debug setting
+Cut: &Cut "10M" # * Debug setting
+CkptPath: &CkptPath /PATH/TO/YOUR/CHECKPOINT  # specify your checkpoint dir
+
+Ckpt_log_every: &Ckpt_log_every 20000  # * Debug setting, 4000
+Image_log_every: &Image_log_every 10 # * Debug setting, 2000
+AccumulateGradBatches: &AccumulateGradBatches 1
+# DEBUG SETTINGS
+# Model_channels: &Model_channels 64
+Model_channels: &Model_channels 320
+
+model:
+  base_learning_rate: *BaseLearningRate
+  target: sgm.models.diffusion.VideoDiffusionEngineTV2V
+  params:
+    use_ema: False # Default is False
+    scale_factor: 0.18215
+    disable_first_stage_autocast: True
+    log_keys:
+      - txt
+    ckpt_path: *CkptPath  
+    freeze_model: spatial # none indicates no freezing
+
+    scheduler_config:
+      target: sgm.lr_scheduler.LambdaLinearScheduler
+      params:
+        warm_up_steps: [ 100 ]
+        cycle_lengths: [ 10000000000000 ]
+        f_start: [ 1.e-6 ]
+        f_max: [ 1. ]
+        f_min: [ 1. ]
+
+    denoiser_config:
+      target: sgm.modules.diffusionmodules.denoiser.DiscreteDenoiser
+      params:
+        num_idx: 1000
+
+        weighting_config:
+          target: sgm.modules.diffusionmodules.denoiser_weighting.EpsWeighting
+        scaling_config:
+          target: sgm.modules.diffusionmodules.denoiser_scaling.EpsScaling
+        discretization_config:
+          target: sgm.modules.diffusionmodules.discretizer.LegacyDDPMDiscretization
+
+    network_config:
+      target: sgm.modules.diffusionmodules.controlmodel.ControlledUNetModel3DTV2V
+      params:
+        use_checkpoint: True
+        in_channels: 4
+        out_channels: 4
+        model_channels: *Model_channels
+        attention_resolutions: [4, 2, 1]
+        num_res_blocks: 2
+        channel_mult: [1, 2, 4, 4]
+        num_heads: 8
+        use_spatial_transformer: True
+        transformer_depth: 1
+        context_dim: 768
+        legacy: False
+        disable_temporal_text_ca: True
+        # -> use "temporal_ca" modules
+        enable_attention3d_crossframe: True
+        ST3DCA_ca_type: 'center_self'
+        # crossframe_type: 'reference'  # not use the reference image as k,v, so comment it.
+        controlnet_config:
+          target: sgm.modules.diffusionmodules.controlmodel.ControlNet2D
+          params:
+            use_checkpoint: True
+            in_channels: 4
+            hint_channels: 3
+            model_channels: *Model_channels
+            attention_resolutions: [4, 2, 1]
+            num_res_blocks: 2
+            channel_mult: [1, 2, 4, 4]
+            num_heads: 8
+            use_spatial_transformer: True
+            transformer_depth: 1
+            context_dim: 768
+            legacy: False
+            control_scales: 1.0
+        controlnet_img_config:  # process the anchor frame
+          target: sgm.modules.diffusionmodules.controlmodel.ControlNet2D
+          params:
+            use_checkpoint: True
+            in_channels: 4
+            hint_channels: 3
+            model_channels: *Model_channels
+            attention_resolutions: [4, 2, 1]
+            num_res_blocks: 2
+            channel_mult: [1, 2, 4, 4]
+            num_heads: 8
+            use_spatial_transformer: True
+            transformer_depth: 1
+            context_dim: 768
+            legacy: False
+            # -> add on center frame, strengthen the control
+            control_scales: 1.0
+            # control_scales: 0.0 # use crossattention, instead of add in controlnet
+            # -> not add the noised x to controlnet_img
+            no_add_x: True # no need to add x
+            set_input_hint_block_as_identity: True # ATTENTION: newly added. default: False
+            # -> disbale the text cross attention in controlnet_img
+            disable_text_ca: True
+
+    conditioner_config:
+      target: sgm.modules.GeneralConditioner
+      params:
+        emb_models:
+          # crossattn cond
+          - is_trainable: False
+            input_key: txt
+            ucg_rate: 0.5 
+            legacy_ucg_value: ""
+            target: sgm.modules.encoders.modules.FrozenCLIPEmbedder
+            params:
+              freeze: true
+          - is_trainable: False
+            input_key: control_hint
+            ucg_rate: 0.0  
+            target: sgm.modules.encoders.modules.DepthMidasEncoder
+          - is_trainable: False
+            input_key: cond_img
+            ucg_rate: 0.0
+            target: sgm.modules.encoders.modules.VAEEmbedder
+
+    first_stage_config:
+      target: sgm.models.autoencoder.AutoencoderKLInferenceWrapper
+      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
+
+    loss_fn_config:
+      target: sgm.modules.diffusionmodules.loss.StandardDiffusionLoss
+      params:
+        sigma_sampler_config:
+          target: sgm.modules.diffusionmodules.sigma_sampling.DiscreteSampling
+          params:
+            num_idx: 1000
+
+            discretization_config:
+              target: sgm.modules.diffusionmodules.discretizer.LegacyDDPMDiscretization
+        offset_noise_level: 0.1
+        offset_noise_varying_dim: 3
+
+    sampler_config:
+      target: sgm.modules.diffusionmodules.sampling.EulerAncestralSampler # ATTENTION: newly add. Default: EulerEDMSampler
+      params:
+        num_steps: 30 # ATTENTION: newly add. default: 50
+
+        discretization_config:
+          target: sgm.modules.diffusionmodules.discretizer.LegacyDDPMDiscretization
+
+        guider_config:
+          target: sgm.modules.diffusionmodules.guiders.VanillaCFGTV2V
+          params:
+            scale: 7.5
+
+data:
+  target: sgm.data.detaset_webvid.DataModuleFromConfig
+  params:
+    batch_size: *BatchSize # TODO need to change batch_size
+    num_workers: 8
+    wrap: False
+    train:
+      target: sgm.data.webvid.webvid_dataset.WebVid
+      params:
+        dataset_name: WebVid
+        data_dir: *DataDir # TODO check the data_dir
+        metadata_dir: *MetadataDir
+        split: *Split
+        cut: *Cut
+        # key: *Key # TODO check data file name, default cleaned
+        subsample: 1
+        text_params:
+          input: text
+        video_params:
+          input_res_h:  *ResolutionH
+          input_res_w: *ResolutionW
+          tsfm_params:
+            norm_mean: [0.5, 0.5, 0.5]
+            norm_std: [0.5, 0.5, 0.5]
+            randcrop_scale: [0.8, 1.0]  # ATTENTION: newly add.
+          num_frames: *FrameLength 
+          prop_factor: *InputFPS
+          loading: lax
+        metadata_folder_name: webvid10m_meta
+        first_stage_key: jpg
+        cond_stage_key: txt
+        skip_missing_files: True
+        use_control_hint: True
+        # -> use center frame as the condition image
+        # random_cond_img: True
+
+lightning:
+  modelcheckpoint:
+    params:
+      every_n_train_steps: *Ckpt_log_every
+
+  callbacks:
+    metrics_over_trainsteps_checkpoint:
+      params:
+        every_n_train_steps: 25000
+
+    image_logger:
+      target: main.ImageLogger
+      params:
+        disabled: False
+        enable_autocast: False
+        batch_frequency: *Image_log_every
+        max_images: 32
+        increase_log_steps: False # default is True
+        log_first_step: False
+        log_images_kwargs:
+          use_ema_scope: False
+          N: 8
+          n_rows: *FrameLength
+          video_fps: *InputFPS
+
+  trainer:
+    precision: 16
+    devices: *NumGPU
+    num_nodes: *NumNodes
+    benchmark: True
+    num_sanity_val_steps: 0
+    accumulate_grad_batches: *AccumulateGradBatches
+    max_epochs: 1000
+
+  strategy:
+    target: pytorch_lightning.strategies.DDPStrategy
+    params:
+      find_unused_parameters: True
+
+  # strategy:
+    # target: pytorch_lightning.strategies.DeepSpeedStrategy
+    # params:
+    #   stage: 2
+    #   allgather_bucket_size: 8e8
+    #   reduce_bucket_size: 8e8
+    #   load_full_weights: True

CCEdit-main/configs/example_training/sd_1_5_controlldm-test-tvi2v-cp-no2ndca-add-cfca-depthmidas.yaml

@@ -0,0 +1,269 @@
+# tvi2v: condition on the frame, text, and video to generate the video
+# cp: copy weights from diffusion_model/unet to controlnet_img. Use VAE to extract the 8x downsampled image.
+# no2ndca: no second cross attention (text cross attention) in the temporal layers
+# add: add the features of reference image on the features of center frame of the main SD model
+# cfca: cross-frame cross-attention, in the main SD model, for each token as query, take the features of center image and current frame as the key and value
+
+
+
+InputFPS: &InputFPS 4
+FrameLength: &FrameLength 17
+BatchSize: &BatchSize 1
+NumGPU: &NumGPU 1
+NumNodes: &NumNodes 1
+BaseLearningRate: &BaseLearningRate 5.0e-5
+DataDir: &DataDir /PATH/TO/YOUR/DATA  # specify your data dir
+MetadataDir: &MetadataDir /PATH/TO/YOUR/METADATA  # specify your metadata dir
+ResolutionH: &ResolutionH 384
+ResolutionW: &ResolutionW 512
+Split: &Split "val" # * Debug setting
+Cut: &Cut "10M" # * Debug setting
+CkptPath: &CkptPath /PATH/TO/YOUR/CHECKPOINT  # specify your checkpoint dir
+Ckpt_log_every: &Ckpt_log_every 20000  # * Debug setting, 4000
+Image_log_every: &Image_log_every 10 # * Debug setting, 2000
+AccumulateGradBatches: &AccumulateGradBatches 1
+# DEBUG SETTINGS
+# Model_channels: &Model_channels 64
+Model_channels: &Model_channels 320
+
+model:
+  base_learning_rate: *BaseLearningRate
+  target: sgm.models.diffusion.VideoDiffusionEngineTV2V
+  params:
+    use_ema: False # Default is False
+    scale_factor: 0.18215
+    disable_first_stage_autocast: True
+    log_keys:
+      - txt
+    ckpt_path: *CkptPath  # TODO: for fast debugging, I comment this line
+    freeze_model: spatial # none indicates no freezing
+
+    scheduler_config:
+      target: sgm.lr_scheduler.LambdaLinearScheduler
+      params:
+        warm_up_steps: [ 100 ]
+        cycle_lengths: [ 10000000000000 ]
+        f_start: [ 1.e-6 ]
+        f_max: [ 1. ]
+        f_min: [ 1. ]
+
+    denoiser_config:
+      target: sgm.modules.diffusionmodules.denoiser.DiscreteDenoiser
+      params:
+        num_idx: 1000
+
+        weighting_config:
+          target: sgm.modules.diffusionmodules.denoiser_weighting.EpsWeighting
+        scaling_config:
+          target: sgm.modules.diffusionmodules.denoiser_scaling.EpsScaling
+        discretization_config:
+          target: sgm.modules.diffusionmodules.discretizer.LegacyDDPMDiscretization
+
+    network_config:
+      target: sgm.modules.diffusionmodules.controlmodel.ControlledUNetModel3DTV2V
+      params:
+        use_checkpoint: True
+        in_channels: 4
+        out_channels: 4
+        model_channels: *Model_channels
+        attention_resolutions: [4, 2, 1]
+        num_res_blocks: 2
+        channel_mult: [1, 2, 4, 4]
+        num_heads: 8
+        use_spatial_transformer: True
+        transformer_depth: 1
+        context_dim: 768
+        legacy: False
+        disable_temporal_text_ca: True
+        # -> use "temporal_ca" modules
+        enable_attention3d_crossframe: True
+        ST3DCA_ca_type: 'center_self'
+        # crossframe_type: 'reference'  # not use the reference image as k,v, so comment it.
+        controlnet_config:
+          target: sgm.modules.diffusionmodules.controlmodel.ControlNet2D
+          params:
+            use_checkpoint: True
+            in_channels: 4
+            hint_channels: 3
+            model_channels: *Model_channels
+            attention_resolutions: [4, 2, 1]
+            num_res_blocks: 2
+            channel_mult: [1, 2, 4, 4]
+            num_heads: 8
+            use_spatial_transformer: True
+            transformer_depth: 1
+            context_dim: 768
+            legacy: False
+            control_scales: 1.0
+        controlnet_img_config:  # process the anchor frame
+          target: sgm.modules.diffusionmodules.controlmodel.ControlNet2D
+          params:
+            use_checkpoint: True
+            in_channels: 4
+            hint_channels: 3
+            model_channels: *Model_channels
+            attention_resolutions: [4, 2, 1]
+            num_res_blocks: 2
+            channel_mult: [1, 2, 4, 4]
+            num_heads: 8
+            use_spatial_transformer: True
+            transformer_depth: 1
+            context_dim: 768
+            legacy: False
+            # -> add on center frame, strengthen the control
+            control_scales: 1.0
+            # control_scales: 0.0 # use crossattention, instead of add in controlnet
+            # -> not add the noised x to controlnet_img
+            no_add_x: True # no need to add x
+            set_input_hint_block_as_identity: True # ATTENTION: newly added. default: False
+            # -> disbale the text cross attention in controlnet_img
+            disable_text_ca: True
+
+    conditioner_config:
+      target: sgm.modules.GeneralConditioner
+      params:
+        emb_models:
+          # crossattn cond
+          - is_trainable: False
+            input_key: txt
+            ucg_rate: 0.5 
+            legacy_ucg_value: ""
+            target: sgm.modules.encoders.modules.FrozenCLIPEmbedder
+            params:
+              freeze: true
+          - is_trainable: False
+            input_key: control_hint
+            ucg_rate: 0.0  
+            target: sgm.modules.encoders.modules.DepthMidasEncoder
+          - is_trainable: False
+            input_key: cond_img
+            ucg_rate: 0.0
+            target: sgm.modules.encoders.modules.VAEEmbedder
+
+    first_stage_config:
+      target: sgm.models.autoencoder.AutoencoderKLInferenceWrapper
+      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
+
+    loss_fn_config:
+      target: sgm.modules.diffusionmodules.loss.StandardDiffusionLoss
+      params:
+        sigma_sampler_config:
+          target: sgm.modules.diffusionmodules.sigma_sampling.DiscreteSampling
+          params:
+            num_idx: 1000
+
+            discretization_config:
+              target: sgm.modules.diffusionmodules.discretizer.LegacyDDPMDiscretization
+        offset_noise_level: 0.1
+        offset_noise_varying_dim: 3
+
+    sampler_config:
+      target: sgm.modules.diffusionmodules.sampling.EulerAncestralSampler # ATTENTION: newly add. Default: EulerEDMSampler
+      params:
+        num_steps: 30 # ATTENTION: newly add. default: 50
+
+        discretization_config:
+          target: sgm.modules.diffusionmodules.discretizer.LegacyDDPMDiscretization
+
+        guider_config:
+          target: sgm.modules.diffusionmodules.guiders.VanillaCFGTV2V
+          params:
+            scale: 7.5
+
+data:
+  target: sgm.data.detaset_webvid.DataModuleFromConfig
+  params:
+    batch_size: *BatchSize # TODO need to change batch_size
+    num_workers: 8
+    wrap: False
+    train:
+      target: sgm.data.webvid.webvid_dataset.WebVid
+      params:
+        dataset_name: WebVid
+        data_dir: *DataDir # TODO check the data_dir
+        metadata_dir: *MetadataDir
+        split: *Split
+        cut: *Cut
+        # key: *Key # TODO check data file name, default cleaned
+        subsample: 1
+        text_params:
+          input: text
+        video_params:
+          input_res_h:  *ResolutionH
+          input_res_w: *ResolutionW
+          tsfm_params:
+            norm_mean: [0.5, 0.5, 0.5]
+            norm_std: [0.5, 0.5, 0.5]
+            randcrop_scale: [0.8, 1.0]  # ATTENTION: newly add.
+          num_frames: *FrameLength 
+          prop_factor: *InputFPS
+          loading: lax
+        metadata_folder_name: webvid10m_meta
+        first_stage_key: jpg
+        cond_stage_key: txt
+        skip_missing_files: True
+        use_control_hint: True
+        # -> use center frame as the condition image
+        # random_cond_img: True
+
+lightning:
+  modelcheckpoint:
+    params:
+      every_n_train_steps: *Ckpt_log_every
+
+  callbacks:
+    metrics_over_trainsteps_checkpoint:
+      params:
+        every_n_train_steps: 25000
+
+    image_logger:
+      target: main.ImageLogger
+      params:
+        disabled: False
+        enable_autocast: False
+        batch_frequency: *Image_log_every
+        max_images: 32
+        increase_log_steps: False # default is True
+        log_first_step: False
+        log_images_kwargs:
+          use_ema_scope: False
+          N: 8
+          n_rows: *FrameLength
+          video_fps: *InputFPS
+
+  trainer:
+    precision: 16
+    devices: *NumGPU
+    num_nodes: *NumNodes
+    benchmark: True
+    num_sanity_val_steps: 0
+    accumulate_grad_batches: *AccumulateGradBatches
+    max_epochs: 1000
+
+  strategy:
+    target: pytorch_lightning.strategies.DDPStrategy
+    params:
+      find_unused_parameters: True
+
+  # strategy:
+    # target: pytorch_lightning.strategies.DeepSpeedStrategy
+    # params:
+    #   stage: 2
+    #   allgather_bucket_size: 8e8
+    #   reduce_bucket_size: 8e8
+    #   load_full_weights: True

CCEdit-main/configs/example_training/toy/cifar10_cond.yaml

@@ -0,0 +1,99 @@
+model:
+  base_learning_rate: 1.0e-4
+  target: sgm.models.diffusion.DiffusionEngine
+  params:
+    denoiser_config:
+      target: sgm.modules.diffusionmodules.denoiser.Denoiser
+      params:
+        weighting_config:
+          target: sgm.modules.diffusionmodules.denoiser_weighting.EDMWeighting
+          params:
+            sigma_data: 1.0
+        scaling_config:
+          target: sgm.modules.diffusionmodules.denoiser_scaling.EDMScaling
+          params:
+            sigma_data: 1.0
+
+    network_config:
+      target: sgm.modules.diffusionmodules.openaimodel.UNetModel
+      params:
+        use_checkpoint: True
+        in_channels: 3
+        out_channels: 3
+        model_channels: 32
+        attention_resolutions: []
+        num_res_blocks: 4
+        channel_mult: [1, 2, 2]
+        num_head_channels: 32
+        num_classes: sequential
+        adm_in_channels: 128
+
+    conditioner_config:
+      target: sgm.modules.GeneralConditioner
+      params:
+        emb_models:
+          - is_trainable: True
+            input_key: cls
+            ucg_rate: 0.2
+            target: sgm.modules.encoders.modules.ClassEmbedder
+            params:
+              embed_dim: 128
+              n_classes: 10
+
+    first_stage_config:
+      target: sgm.models.autoencoder.IdentityFirstStage
+
+    loss_fn_config:
+      target: sgm.modules.diffusionmodules.loss.StandardDiffusionLoss
+      params:
+        sigma_sampler_config:
+          target: sgm.modules.diffusionmodules.sigma_sampling.EDMSampling
+
+    sampler_config:
+      target: sgm.modules.diffusionmodules.sampling.EulerEDMSampler
+      params:
+        num_steps: 50
+
+        discretization_config:
+          target: sgm.modules.diffusionmodules.discretizer.EDMDiscretization
+
+        guider_config:
+          target: sgm.modules.diffusionmodules.guiders.VanillaCFG
+          params:
+            scale: 3.0
+
+data:
+  target: sgm.data.cifar10.CIFAR10Loader
+  params:
+    batch_size: 512
+    num_workers: 1
+
+lightning:
+  modelcheckpoint:
+    params:
+      every_n_train_steps: 5000
+
+  callbacks:
+    metrics_over_trainsteps_checkpoint:
+      params:
+        every_n_train_steps: 25000
+
+    image_logger:
+      target: main.ImageLogger
+      params:
+        disabled: False
+        batch_frequency: 1000
+        max_images: 64
+        increase_log_steps: True
+        log_first_step: False
+        log_images_kwargs:
+          use_ema_scope: False
+          N: 64
+          n_rows: 8
+
+  trainer:
+    devices: 0,
+    benchmark: True
+    num_sanity_val_steps: 0
+    accumulate_grad_batches: 1
+    max_epochs: 20

CCEdit-main/configs/example_training/toy/mnist.yaml

@@ -0,0 +1,80 @@
+model:
+  base_learning_rate: 1.0e-4
+  target: sgm.models.diffusion.DiffusionEngine
+  params:
+    denoiser_config:
+      target: sgm.modules.diffusionmodules.denoiser.Denoiser
+      params:
+        weighting_config:
+          target: sgm.modules.diffusionmodules.denoiser_weighting.EDMWeighting
+          params:
+            sigma_data: 1.0
+        scaling_config:
+          target: sgm.modules.diffusionmodules.denoiser_scaling.EDMScaling
+          params:
+            sigma_data: 1.0
+
+    network_config:
+      target: sgm.modules.diffusionmodules.openaimodel.UNetModel
+      params:
+        use_checkpoint: True
+        in_channels: 1
+        out_channels: 1
+        model_channels: 32
+        attention_resolutions: []
+        num_res_blocks: 4
+        channel_mult: [1, 2, 2]
+        num_head_channels: 32
+
+    first_stage_config:
+      target: sgm.models.autoencoder.IdentityFirstStage
+
+    loss_fn_config:
+      target: sgm.modules.diffusionmodules.loss.StandardDiffusionLoss
+      params:
+        sigma_sampler_config:
+          target: sgm.modules.diffusionmodules.sigma_sampling.EDMSampling
+
+    sampler_config:
+      target: sgm.modules.diffusionmodules.sampling.EulerEDMSampler
+      params:
+        num_steps: 50
+
+        discretization_config:
+          target: sgm.modules.diffusionmodules.discretizer.EDMDiscretization
+
+data:
+  target: sgm.data.mnist.MNISTLoader
+  params:
+    batch_size: 512
+    num_workers: 1
+
+lightning:
+  modelcheckpoint:
+    params:
+      every_n_train_steps: 5000
+
+  callbacks:
+    metrics_over_trainsteps_checkpoint:
+      params:
+        every_n_train_steps: 25000
+
+    image_logger:
+      target: main.ImageLogger
+      params:
+        disabled: False
+        batch_frequency: 1000
+        max_images: 64
+        increase_log_steps: False
+        log_first_step: False
+        log_images_kwargs:
+          use_ema_scope: False
+          N: 64
+          n_rows: 8
+
+  trainer:
+    devices: 0,
+    benchmark: True
+    num_sanity_val_steps: 0
+    accumulate_grad_batches: 1
+    max_epochs: 10

CCEdit-main/configs/example_training/toy/mnist_cond.yaml

@@ -0,0 +1,99 @@
+model:
+  base_learning_rate: 1.0e-4
+  target: sgm.models.diffusion.DiffusionEngine
+  params:
+    denoiser_config:
+      target: sgm.modules.diffusionmodules.denoiser.Denoiser
+      params:
+        weighting_config:
+          target: sgm.modules.diffusionmodules.denoiser_weighting.EDMWeighting
+          params:
+            sigma_data: 1.0
+        scaling_config:
+          target: sgm.modules.diffusionmodules.denoiser_scaling.EDMScaling
+          params:
+            sigma_data: 1.0
+
+    network_config:
+      target: sgm.modules.diffusionmodules.openaimodel.UNetModel
+      params:
+        use_checkpoint: True
+        in_channels: 1
+        out_channels: 1
+        model_channels: 32
+        attention_resolutions: [ ]
+        num_res_blocks: 4
+        channel_mult: [ 1, 2, 2 ]
+        num_head_channels: 32
+        num_classes: sequential
+        adm_in_channels: 128
+
+    conditioner_config:
+      target: sgm.modules.GeneralConditioner
+      params:
+        emb_models:
+          - is_trainable: True
+            input_key: "cls"
+            ucg_rate: 0.2
+            target: sgm.modules.encoders.modules.ClassEmbedder
+            params:
+              embed_dim: 128
+              n_classes: 10
+
+    first_stage_config:
+      target: sgm.models.autoencoder.IdentityFirstStage
+
+    loss_fn_config:
+      target: sgm.modules.diffusionmodules.loss.StandardDiffusionLoss
+      params:
+        sigma_sampler_config:
+          target: sgm.modules.diffusionmodules.sigma_sampling.EDMSampling
+
+    sampler_config:
+      target: sgm.modules.diffusionmodules.sampling.EulerEDMSampler
+      params:
+        num_steps: 50
+
+        discretization_config:
+          target: sgm.modules.diffusionmodules.discretizer.EDMDiscretization
+
+        guider_config:
+          target: sgm.modules.diffusionmodules.guiders.VanillaCFG
+          params:
+            scale: 3.0
+
+data:
+  target: sgm.data.mnist.MNISTLoader
+  params:
+    batch_size: 512
+    num_workers: 1
+
+lightning:
+  modelcheckpoint:
+    params:
+      every_n_train_steps: 5000
+
+  callbacks:
+    metrics_over_trainsteps_checkpoint:
+      params:
+        every_n_train_steps: 25000
+
+    image_logger:
+      target: main.ImageLogger
+      params:
+        disabled: False
+        batch_frequency: 1000
+        max_images: 16
+        increase_log_steps: True
+        log_first_step: False
+        log_images_kwargs:
+          use_ema_scope: False
+          N: 16
+          n_rows: 4
+
+  trainer:
+    devices: 0,
+    benchmark: True
+    num_sanity_val_steps: 0
+    accumulate_grad_batches: 1
+    max_epochs: 20

CCEdit-main/configs/example_training/toy/mnist_cond_discrete_eps.yaml

@@ -0,0 +1,104 @@
+model:
+  base_learning_rate: 1.0e-4
+  target: sgm.models.diffusion.DiffusionEngine
+  params:
+    denoiser_config:
+      target: sgm.modules.diffusionmodules.denoiser.DiscreteDenoiser
+      params:
+        num_idx: 1000
+
+        weighting_config:
+          target: sgm.modules.diffusionmodules.denoiser_weighting.EDMWeighting
+        scaling_config:
+          target: sgm.modules.diffusionmodules.denoiser_scaling.EDMScaling
+        discretization_config:
+          target: sgm.modules.diffusionmodules.discretizer.LegacyDDPMDiscretization
+
+    network_config:
+      target: sgm.modules.diffusionmodules.openaimodel.UNetModel
+      params:
+        use_checkpoint: True
+        in_channels: 1
+        out_channels: 1
+        model_channels: 32
+        attention_resolutions: [ ]
+        num_res_blocks: 4
+        channel_mult: [ 1, 2, 2 ]
+        num_head_channels: 32
+        num_classes: sequential
+        adm_in_channels: 128
+
+    conditioner_config:
+      target: sgm.modules.GeneralConditioner
+      params:
+        emb_models:
+          - is_trainable: True
+            input_key: "cls"
+            ucg_rate: 0.2
+            target: sgm.modules.encoders.modules.ClassEmbedder
+            params:
+              embed_dim: 128
+              n_classes: 10
+
+    first_stage_config:
+      target: sgm.models.autoencoder.IdentityFirstStage
+
+    loss_fn_config:
+      target: sgm.modules.diffusionmodules.loss.StandardDiffusionLoss
+      params:
+        sigma_sampler_config:
+          target: sgm.modules.diffusionmodules.sigma_sampling.DiscreteSampling
+          params:
+            num_idx: 1000
+
+            discretization_config:
+              target: sgm.modules.diffusionmodules.discretizer.LegacyDDPMDiscretization
+
+    sampler_config:
+      target: sgm.modules.diffusionmodules.sampling.EulerEDMSampler
+      params:
+        num_steps: 50
+
+        discretization_config:
+          target: sgm.modules.diffusionmodules.discretizer.LegacyDDPMDiscretization
+
+        guider_config:
+          target: sgm.modules.diffusionmodules.guiders.VanillaCFG
+          params:
+            scale: 5.0
+
+data:
+  target: sgm.data.mnist.MNISTLoader
+  params:
+    batch_size: 512
+    num_workers: 1
+
+lightning:
+  modelcheckpoint:
+    params:
+      every_n_train_steps: 5000
+
+  callbacks:
+    metrics_over_trainsteps_checkpoint:
+      params:
+        every_n_train_steps: 25000
+
+    image_logger:
+      target: main.ImageLogger
+      params:
+        disabled: False
+        batch_frequency: 1000
+        max_images: 16
+        increase_log_steps: True
+        log_first_step: False
+        log_images_kwargs:
+          use_ema_scope: False
+          N: 16
+          n_rows: 4
+
+  trainer:
+    devices: 0,
+    benchmark: True
+    num_sanity_val_steps: 0
+    accumulate_grad_batches: 1
+    max_epochs: 20

CCEdit-main/configs/example_training/toy/mnist_cond_l1_loss.yaml

@@ -0,0 +1,104 @@
+model:
+  base_learning_rate: 1.0e-4
+  target: sgm.models.diffusion.DiffusionEngine
+  params:
+    denoiser_config:
+      target: sgm.modules.diffusionmodules.denoiser.Denoiser
+      params:
+        weighting_config:
+          target: sgm.modules.diffusionmodules.denoiser_weighting.EDMWeighting
+          params:
+            sigma_data: 1.0
+        scaling_config:
+          target: sgm.modules.diffusionmodules.denoiser_scaling.EDMScaling
+          params:
+            sigma_data: 1.0
+
+    network_config:
+      target: sgm.modules.diffusionmodules.openaimodel.UNetModel
+      params:
+        use_checkpoint: True
+        in_channels: 1
+        out_channels: 1
+        model_channels: 32
+        attention_resolutions: []
+        num_res_blocks: 4
+        channel_mult: [1, 2, 2]
+        num_head_channels: 32
+        num_classes: "sequential"
+        adm_in_channels: 128
+
+    conditioner_config:
+      target: sgm.modules.GeneralConditioner
+      params:
+        emb_models:
+          - is_trainable: True
+            input_key: "cls"
+            ucg_rate: 0.2
+            target: sgm.modules.encoders.modules.ClassEmbedder
+            params:
+              embed_dim: 128
+              n_classes: 10
+
+    first_stage_config:
+      target: sgm.models.autoencoder.IdentityFirstStage
+
+    loss_fn_config:
+      target: sgm.modules.diffusionmodules.loss.StandardDiffusionLoss
+      params:
+        sigma_sampler_config:
+          target: sgm.modules.diffusionmodules.sigma_sampling.EDMSampling
+
+    sampler_config:
+      target: sgm.modules.diffusionmodules.sampling.EulerEDMSampler
+      params:
+        num_steps: 50
+
+        discretization_config:
+          target: sgm.modules.diffusionmodules.discretizer.EDMDiscretization
+
+        guider_config:
+          target: sgm.modules.diffusionmodules.guiders.VanillaCFG
+          params:
+            scale: 3.0
+
+    loss_config:
+      target: sgm.modules.diffusionmodules.StandardDiffusionLoss
+      params:
+        type: l1
+
+data:
+  target: sgm.data.mnist.MNISTLoader
+  params:
+    batch_size: 512
+    num_workers: 1
+
+lightning:
+  modelcheckpoint:
+    params:
+      every_n_train_steps: 5000
+
+  callbacks:
+    metrics_over_trainsteps_checkpoint:
+      params:
+        every_n_train_steps: 25000
+
+    image_logger:
+      target: main.ImageLogger
+      params:
+        disabled: False
+        batch_frequency: 1000
+        max_images: 64
+        increase_log_steps: True
+        log_first_step: False
+        log_images_kwargs:
+          use_ema_scope: False
+          N: 64
+          n_rows: 8
+
+  trainer:
+    devices: 0,
+    benchmark: True
+    num_sanity_val_steps: 0
+    accumulate_grad_batches: 1
+    max_epochs: 20

CCEdit-main/configs/example_training/toy/mnist_cond_with_ema.yaml

@@ -0,0 +1,101 @@
+model:
+  base_learning_rate: 1.0e-4
+  target: sgm.models.diffusion.DiffusionEngine
+  params:
+    use_ema: True
+
+    denoiser_config:
+      target: sgm.modules.diffusionmodules.denoiser.Denoiser
+      params:
+        weighting_config:
+          target: sgm.modules.diffusionmodules.denoiser_weighting.EDMWeighting
+          params:
+            sigma_data: 1.0
+        scaling_config:
+          target: sgm.modules.diffusionmodules.denoiser_scaling.EDMScaling
+          params:
+            sigma_data: 1.0
+
+    network_config:
+      target: sgm.modules.diffusionmodules.openaimodel.UNetModel
+      params:
+        use_checkpoint: True
+        in_channels: 1
+        out_channels: 1
+        model_channels: 32
+        attention_resolutions: []
+        num_res_blocks: 4
+        channel_mult: [1, 2, 2]
+        num_head_channels: 32
+        num_classes: sequential
+        adm_in_channels: 128
+
+    conditioner_config:
+      target: sgm.modules.GeneralConditioner
+      params:
+        emb_models:
+          - is_trainable: True
+            input_key: cls
+            ucg_rate: 0.2
+            target: sgm.modules.encoders.modules.ClassEmbedder
+            params:
+              embed_dim: 128
+              n_classes: 10
+
+    first_stage_config:
+      target: sgm.models.autoencoder.IdentityFirstStage
+
+    loss_fn_config:
+      target: sgm.modules.diffusionmodules.loss.StandardDiffusionLoss
+      params:
+        sigma_sampler_config:
+          target: sgm.modules.diffusionmodules.sigma_sampling.EDMSampling
+
+    sampler_config:
+      target: sgm.modules.diffusionmodules.sampling.EulerEDMSampler
+      params:
+        num_steps: 50
+
+        discretization_config:
+          target: sgm.modules.diffusionmodules.discretizer.EDMDiscretization
+
+        guider_config:
+          target: sgm.modules.diffusionmodules.guiders.VanillaCFG
+          params:
+            scale: 3.0
+
+data:
+  target: sgm.data.mnist.MNISTLoader
+  params:
+    batch_size: 512
+    num_workers: 1
+
+lightning:
+  modelcheckpoint:
+    params:
+      every_n_train_steps: 5000
+
+  callbacks:
+    metrics_over_trainsteps_checkpoint:
+      params:
+        every_n_train_steps: 25000
+
+    image_logger:
+      target: main.ImageLogger
+      params:
+        disabled: False
+        batch_frequency: 1000
+        max_images: 64
+        increase_log_steps: True
+        log_first_step: False
+        log_images_kwargs:
+          use_ema_scope: False
+          N: 64
+          n_rows: 8
+
+  trainer:
+    devices: 0,
+    benchmark: True
+    num_sanity_val_steps: 0
+    accumulate_grad_batches: 1
+    max_epochs: 20

CCEdit-main/configs/inference/sd_2_1.yaml

@@ -0,0 +1,66 @@
+model:
+  target: sgm.models.diffusion.DiffusionEngine
+  params:
+    scale_factor: 0.18215
+    disable_first_stage_autocast: True
+
+    denoiser_config:
+      target: sgm.modules.diffusionmodules.denoiser.DiscreteDenoiser
+      params:
+        num_idx: 1000
+
+        weighting_config:
+          target: sgm.modules.diffusionmodules.denoiser_weighting.EpsWeighting
+        scaling_config:
+          target: sgm.modules.diffusionmodules.denoiser_scaling.EpsScaling
+        discretization_config:
+          target: sgm.modules.diffusionmodules.discretizer.LegacyDDPMDiscretization
+
+    network_config:
+      target: sgm.modules.diffusionmodules.openaimodel.UNetModel
+      params:
+        use_checkpoint: True
+        use_fp16: True
+        in_channels: 4
+        out_channels: 4
+        model_channels: 320
+        attention_resolutions: [4, 2, 1]
+        num_res_blocks: 2
+        channel_mult: [1, 2, 4, 4]
+        num_head_channels: 64
+        use_spatial_transformer: True
+        use_linear_in_transformer: True
+        transformer_depth: 1
+        context_dim: 1024
+        legacy: False
+
+    conditioner_config:
+      target: sgm.modules.GeneralConditioner
+      params:
+        emb_models:
+          # crossattn cond
+          - is_trainable: False
+            input_key: txt
+            target: sgm.modules.encoders.modules.FrozenOpenCLIPEmbedder
+            params:
+              freeze: true
+              layer: penultimate
+
+    first_stage_config:
+      target: sgm.models.autoencoder.AutoencoderKLInferenceWrapper
+      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

CCEdit-main/configs/inference/sd_2_1_768.yaml

@@ -0,0 +1,66 @@
+model:
+  target: sgm.models.diffusion.DiffusionEngine
+  params:
+    scale_factor: 0.18215
+    disable_first_stage_autocast: True
+
+    denoiser_config:
+      target: sgm.modules.diffusionmodules.denoiser.DiscreteDenoiser
+      params:
+        num_idx: 1000
+
+        weighting_config:
+          target: sgm.modules.diffusionmodules.denoiser_weighting.VWeighting
+        scaling_config:
+          target: sgm.modules.diffusionmodules.denoiser_scaling.VScaling
+        discretization_config:
+          target: sgm.modules.diffusionmodules.discretizer.LegacyDDPMDiscretization
+
+    network_config:
+      target: sgm.modules.diffusionmodules.openaimodel.UNetModel
+      params:
+        use_checkpoint: True
+        use_fp16: True
+        in_channels: 4
+        out_channels: 4
+        model_channels: 320
+        attention_resolutions: [4, 2, 1]
+        num_res_blocks: 2
+        channel_mult: [1, 2, 4, 4]
+        num_head_channels: 64
+        use_spatial_transformer: True
+        use_linear_in_transformer: True
+        transformer_depth: 1
+        context_dim: 1024
+        legacy: False
+
+    conditioner_config:
+      target: sgm.modules.GeneralConditioner
+      params:
+        emb_models:
+          # crossattn cond
+          - is_trainable: False
+            input_key: txt
+            target: sgm.modules.encoders.modules.FrozenOpenCLIPEmbedder
+            params:
+              freeze: true
+              layer: penultimate
+
+    first_stage_config:
+      target: sgm.models.autoencoder.AutoencoderKLInferenceWrapper
+      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

CCEdit-main/configs/inference/sd_xl_refiner.yaml

@@ -0,0 +1,91 @@
+model:
+  target: sgm.models.diffusion.DiffusionEngine
+  params:
+    scale_factor: 0.13025
+    disable_first_stage_autocast: True
+
+    denoiser_config:
+      target: sgm.modules.diffusionmodules.denoiser.DiscreteDenoiser
+      params:
+        num_idx: 1000
+
+        weighting_config:
+          target: sgm.modules.diffusionmodules.denoiser_weighting.EpsWeighting
+        scaling_config:
+          target: sgm.modules.diffusionmodules.denoiser_scaling.EpsScaling
+        discretization_config:
+          target: sgm.modules.diffusionmodules.discretizer.LegacyDDPMDiscretization
+
+    network_config:
+      target: sgm.modules.diffusionmodules.openaimodel.UNetModel
+      params:
+        adm_in_channels: 2560
+        num_classes: sequential
+        use_checkpoint: True
+        in_channels: 4
+        out_channels: 4
+        model_channels: 384
+        attention_resolutions: [4, 2]
+        num_res_blocks: 2
+        channel_mult: [1, 2, 4, 4]
+        num_head_channels: 64
+        use_spatial_transformer: True
+        use_linear_in_transformer: True
+        transformer_depth: 4
+        context_dim: [1280, 1280, 1280, 1280]  # 1280
+        spatial_transformer_attn_type: softmax-xformers
+        legacy: False
+
+    conditioner_config:
+      target: sgm.modules.GeneralConditioner
+      params:
+        emb_models:
+          # crossattn and vector cond
+          - is_trainable: False
+            input_key: txt
+            target: sgm.modules.encoders.modules.FrozenOpenCLIPEmbedder2
+            params:
+              arch: ViT-bigG-14
+              version: laion2b_s39b_b160k
+              legacy: False
+              freeze: True
+              layer: penultimate
+              always_return_pooled: True
+          # vector cond
+          - is_trainable: False
+            input_key: original_size_as_tuple
+            target: sgm.modules.encoders.modules.ConcatTimestepEmbedderND
+            params:
+              outdim: 256  # multiplied by two
+          # vector cond
+          - is_trainable: False
+            input_key: crop_coords_top_left
+            target: sgm.modules.encoders.modules.ConcatTimestepEmbedderND
+            params:
+              outdim: 256  # multiplied by two
+          # vector cond
+          - is_trainable: False
+            input_key: aesthetic_score
+            target: sgm.modules.encoders.modules.ConcatTimestepEmbedderND
+            params:
+              outdim: 256  # multiplied by one
+
+    first_stage_config:
+      target: sgm.models.autoencoder.AutoencoderKLInferenceWrapper
+      params:
+        embed_dim: 4
+        monitor: val/rec_loss
+        ddconfig:
+          attn_type: vanilla-xformers
+          double_z: true
+          z_channels: 4
+          resolution: 256
+          in_channels: 3
+          out_ch: 3
+          ch: 128
+          ch_mult: [1, 2, 4, 4]
+          num_res_blocks: 2
+          attn_resolutions: []
+          dropout: 0.0
+        lossconfig:
+          target: torch.nn.Identity

CCEdit-main/configs/inference_ccedit/keyframe_no2ndca_depthmidas.yaml

@@ -0,0 +1,93 @@
+NumSteps: &NumSteps 30
+
+model:
+  target: sgm.models.diffusion.VideoDiffusionEngineTV2V
+  params:
+    use_ema: False # Default is False
+    scale_factor: 0.18215
+    disable_first_stage_autocast: True
+    log_keys:
+      - txt
+    freeze_model: spatial
+
+    denoiser_config:
+      target: sgm.modules.diffusionmodules.denoiser.DiscreteDenoiser
+      params:
+        num_idx: 1000
+
+        weighting_config:
+          target: sgm.modules.diffusionmodules.denoiser_weighting.EpsWeighting
+        scaling_config:
+          target: sgm.modules.diffusionmodules.denoiser_scaling.EpsScaling
+        discretization_config:
+          target: sgm.modules.diffusionmodules.discretizer.LegacyDDPMDiscretization
+
+    network_config:
+      target: sgm.modules.diffusionmodules.controlmodel.ControlledUNetModel3DTV2V
+      params:
+        use_checkpoint: False
+        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
+        use_spatial_transformer: True
+        transformer_depth: 1
+        context_dim: 768
+        legacy: False
+        disable_temporal_text_ca: True
+        controlnet_config:
+          target: sgm.modules.diffusionmodules.controlmodel.ControlNet2D
+          params:
+            use_checkpoint: False
+            in_channels: 4
+            hint_channels: 3
+            model_channels: 320
+            attention_resolutions: [4, 2, 1]
+            num_res_blocks: 2
+            channel_mult: [1, 2, 4, 4]
+            num_heads: 8
+            use_spatial_transformer: True
+            transformer_depth: 1
+            context_dim: 768
+            legacy: False
+            control_scales: 1.0
+            
+    conditioner_config:
+      target: sgm.modules.GeneralConditioner
+      params:
+        emb_models:
+          # crossattn cond
+          - is_trainable: False
+            input_key: txt
+            ucg_rate: 0.5
+            legacy_ucg_value: ""
+            target: sgm.modules.encoders.modules.FrozenCLIPEmbedder
+            params:
+              freeze: true
+          - is_trainable: False
+            input_key: control_hint
+            ucg_rate: 0.01 
+            target: sgm.modules.encoders.modules.DepthMidasEncoder
+
+    first_stage_config:
+      target: sgm.models.autoencoder.AutoencoderKLInferenceWrapper
+      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
+

CCEdit-main/configs/inference_ccedit/keyframe_ref_cp_no2ndca_add_cfca_depthzoe.yaml

@@ -0,0 +1,130 @@
+model:
+  target: sgm.models.diffusion.VideoDiffusionEngineTV2V
+  params:
+    use_ema: False # Default is False
+    scale_factor: 0.18215
+    disable_first_stage_autocast: True
+    log_keys:
+      - txt
+    freeze_model: spatial
+
+    scheduler_config:
+      target: sgm.lr_scheduler.LambdaLinearScheduler
+      params:
+        warm_up_steps: [ 1000 ]
+        cycle_lengths: [ 10000000000000 ]
+        f_start: [ 1.e-6 ]
+        f_max: [ 1. ]
+        f_min: [ 1. ]
+
+    denoiser_config:
+      target: sgm.modules.diffusionmodules.denoiser.DiscreteDenoiser
+      params:
+        num_idx: 1000
+
+        weighting_config:
+          target: sgm.modules.diffusionmodules.denoiser_weighting.EpsWeighting
+        scaling_config:
+          target: sgm.modules.diffusionmodules.denoiser_scaling.EpsScaling
+        discretization_config:
+          target: sgm.modules.diffusionmodules.discretizer.LegacyDDPMDiscretization
+
+    network_config:
+      target: sgm.modules.diffusionmodules.controlmodel.ControlledUNetModel3DTV2V
+      params:
+        use_checkpoint: True
+        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
+        use_spatial_transformer: True
+        transformer_depth: 1
+        context_dim: 768
+        legacy: False
+        disable_temporal_text_ca: True
+        # -> use "temporal_ca" modules
+        enable_attention3d_crossframe: True
+        ST3DCA_ca_type: 'center_self'
+        # crossframe_type: 'reference'  # not use the reference image as k,v, so comment it.
+        controlnet_config:
+          target: sgm.modules.diffusionmodules.controlmodel.ControlNet2D
+          params:
+            use_checkpoint: True
+            in_channels: 4
+            hint_channels: 3
+            model_channels: 320
+            attention_resolutions: [4, 2, 1]
+            num_res_blocks: 2
+            channel_mult: [1, 2, 4, 4]
+            num_heads: 8
+            use_spatial_transformer: True
+            transformer_depth: 1
+            context_dim: 768
+            legacy: False
+            control_scales: 1.0
+        controlnet_img_config:  # process the anchor frame
+          target: sgm.modules.diffusionmodules.controlmodel.ControlNet2D
+          params:
+            use_checkpoint: True
+            in_channels: 4
+            hint_channels: 3
+            model_channels: 320
+            attention_resolutions: [4, 2, 1]
+            num_res_blocks: 2
+            channel_mult: [1, 2, 4, 4]
+            num_heads: 8
+            use_spatial_transformer: True
+            transformer_depth: 1
+            context_dim: 768
+            legacy: False
+            # -> add on center frame, strengthen the control
+            control_scales: 1.0
+            # control_scales: 0.0 # use crossattention, instead of add in controlnet
+            # -> not add the noised x to controlnet_img
+            no_add_x: True # no need to add x
+            set_input_hint_block_as_identity: True # ATTENTION: newly added. default: False
+            # -> disbale the text cross attention in controlnet_img
+            disable_text_ca: True
+
+    conditioner_config:
+      target: sgm.modules.GeneralConditioner
+      params:
+        emb_models:
+          # crossattn cond
+          - is_trainable: False
+            input_key: txt
+            ucg_rate: 0.5 
+            legacy_ucg_value: ""
+            target: sgm.modules.encoders.modules.FrozenCLIPEmbedder
+            params:
+              freeze: true
+          - is_trainable: False
+            input_key: control_hint
+            ucg_rate: 0.0  
+            target: sgm.modules.encoders.modules.DepthZoeEncoder
+          - is_trainable: False
+            input_key: cond_img
+            ucg_rate: 0.0
+            target: sgm.modules.encoders.modules.VAEEmbedder
+
+    first_stage_config:
+      target: sgm.models.autoencoder.AutoencoderKLInferenceWrapper
+      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

CCEdit-main/sgm/__init__.py

@@ -0,0 +1,3 @@
+from .data import StableDataModuleFromConfig
+from .models import AutoencodingEngine, DiffusionEngine
+from .util import instantiate_from_config

CCEdit-main/sgm/data/__init__.py

@@ -0,0 +1 @@
+from .dataset import StableDataModuleFromConfig

CCEdit-main/sgm/data/cifar10.py

@@ -0,0 +1,67 @@
+import torchvision
+import pytorch_lightning as pl
+from torchvision import transforms
+from torch.utils.data import DataLoader, Dataset
+
+
+class CIFAR10DataDictWrapper(Dataset):
+    def __init__(self, dset):
+        super().__init__()
+        self.dset = dset
+
+    def __getitem__(self, i):
+        x, y = self.dset[i]
+        return {"jpg": x, "cls": y}
+
+    def __len__(self):
+        return len(self.dset)
+
+
+class CIFAR10Loader(pl.LightningDataModule):
+    def __init__(self, batch_size, num_workers=0, shuffle=True):
+        super().__init__()
+
+        transform = transforms.Compose(
+            [transforms.ToTensor(), transforms.Lambda(lambda x: x * 2.0 - 1.0)]
+        )
+
+        self.batch_size = batch_size
+        self.num_workers = num_workers
+        self.shuffle = shuffle
+        self.train_dataset = CIFAR10DataDictWrapper(
+            torchvision.datasets.CIFAR10(
+                root=".data/", train=True, download=True, transform=transform
+            )
+        )
+        self.test_dataset = CIFAR10DataDictWrapper(
+            torchvision.datasets.CIFAR10(
+                root=".data/", train=False, download=True, transform=transform
+            )
+        )
+
+    def prepare_data(self):
+        pass
+
+    def train_dataloader(self):
+        return DataLoader(
+            self.train_dataset,
+            batch_size=self.batch_size,
+            shuffle=self.shuffle,
+            num_workers=self.num_workers,
+        )
+
+    def test_dataloader(self):
+        return DataLoader(
+            self.test_dataset,
+            batch_size=self.batch_size,
+            shuffle=self.shuffle,
+            num_workers=self.num_workers,
+        )
+
+    def val_dataloader(self):
+        return DataLoader(
+            self.test_dataset,
+            batch_size=self.batch_size,
+            shuffle=self.shuffle,
+            num_workers=self.num_workers,
+        )

CCEdit-main/sgm/data/dataset.py

@@ -0,0 +1,80 @@
+from typing import Optional
+
+import torchdata.datapipes.iter
+import webdataset as wds
+from omegaconf import DictConfig
+from pytorch_lightning import LightningDataModule
+
+try:
+    from sdata import create_dataset, create_dummy_dataset, create_loader
+except ImportError as e:
+    print("#" * 100)
+    print("Datasets not yet available")
+    print("to enable, we need to add stable-datasets as a submodule")
+    print("please use ``git submodule update --init --recursive``")
+    print("and do ``pip install -e stable-datasets/`` from the root of this repo")
+    print("#" * 100)
+    exit(1)
+
+
+class StableDataModuleFromConfig(LightningDataModule):
+    def __init__(
+        self,
+        train: DictConfig,
+        validation: Optional[DictConfig] = None,
+        test: Optional[DictConfig] = None,
+        skip_val_loader: bool = False,
+        dummy: bool = False,
+    ):
+        super().__init__()
+        self.train_config = train
+        assert (
+            "datapipeline" in self.train_config and "loader" in self.train_config
+        ), "train config requires the fields `datapipeline` and `loader`"
+
+        self.val_config = validation
+        if not skip_val_loader:
+            if self.val_config is not None:
+                assert (
+                    "datapipeline" in self.val_config and "loader" in self.val_config
+                ), "validation config requires the fields `datapipeline` and `loader`"
+            else:
+                print(
+                    "Warning: No Validation datapipeline defined, using that one from training"
+                )
+                self.val_config = train
+
+        self.test_config = test
+        if self.test_config is not None:
+            assert (
+                "datapipeline" in self.test_config and "loader" in self.test_config
+            ), "test config requires the fields `datapipeline` and `loader`"
+
+        self.dummy = dummy
+        if self.dummy:
+            print("#" * 100)
+            print("USING DUMMY DATASET: HOPE YOU'RE DEBUGGING ;)")
+            print("#" * 100)
+
+    def setup(self, stage: str) -> None:
+        print("Preparing datasets")
+        if self.dummy:
+            data_fn = create_dummy_dataset
+        else:
+            data_fn = create_dataset
+
+        self.train_datapipeline = data_fn(**self.train_config.datapipeline)
+        if self.val_config:
+            self.val_datapipeline = data_fn(**self.val_config.datapipeline)
+        if self.test_config:
+            self.test_datapipeline = data_fn(**self.test_config.datapipeline)
+
+    def train_dataloader(self) -> torchdata.datapipes.iter.IterDataPipe:
+        loader = create_loader(self.train_datapipeline, **self.train_config.loader)
+        return loader
+
+    def val_dataloader(self) -> wds.DataPipeline:
+        return create_loader(self.val_datapipeline, **self.val_config.loader)
+
+    def test_dataloader(self) -> wds.DataPipeline:
+        return create_loader(self.test_datapipeline, **self.test_config.loader)

CCEdit-main/sgm/data/detaset_webvid.py

@@ -0,0 +1,182 @@
+import pytorch_lightning as pl
+from functools import partial
+from sgm.util import (
+    exists,
+    instantiate_from_config,
+    isheatmap,
+)
+import torch
+import numpy as np
+from torch.utils.data import random_split, DataLoader, Dataset, Subset, IterableDataset
+from abc import abstractmethod
+
+
+class Txt2ImgIterableBaseDataset(IterableDataset):
+    """
+    Define an interface to make the IterableDatasets for text2img data chainable
+    """
+
+    def __init__(self, num_records=0, valid_ids=None, size=256):
+        super().__init__()
+        self.num_records = num_records
+        self.valid_ids = valid_ids
+        self.sample_ids = valid_ids
+        self.size = size
+
+        print(f"{self.__class__.__name__} dataset contains {self.__len__()} examples.")
+
+    def __len__(self):
+        return self.num_records
+
+    @abstractmethod
+    def __iter__(self):
+        pass
+
+
+class WrappedDataset(Dataset):
+    """Wraps an arbitrary object with __len__ and __getitem__ into a pytorch dataset"""
+
+    def __init__(self, dataset):
+        self.data = dataset
+
+    def __len__(self):
+        return len(self.data)
+
+    def __getitem__(self, idx):
+        return self.data[idx]
+
+
+def worker_init_fn(_):
+    worker_info = torch.utils.data.get_worker_info()
+
+    dataset = worker_info.dataset
+    worker_id = worker_info.id
+
+    if isinstance(dataset, Txt2ImgIterableBaseDataset):
+        split_size = dataset.num_records // worker_info.num_workers
+        # reset num_records to the true number to retain reliable length information
+        dataset.sample_ids = dataset.valid_ids[
+            worker_id * split_size : (worker_id + 1) * split_size
+        ]
+        current_id = np.random.choice(len(np.random.get_state()[1]), 1)
+        return np.random.seed(np.random.get_state()[1][current_id] + worker_id)
+    else:
+        return np.random.seed(np.random.get_state()[1][0] + worker_id)
+
+
+class DataModuleFromConfig(pl.LightningDataModule):
+    def __init__(
+        self,
+        batch_size,
+        train=None,
+        validation=None,
+        test=None,
+        predict=None,
+        wrap=False,
+        num_workers=None,
+        shuffle_test_loader=False,
+        use_worker_init_fn=False,
+        shuffle_val_dataloader=False,
+    ):
+        super().__init__()
+        self.batch_size = batch_size
+        self.dataset_configs = dict()
+        self.num_workers = num_workers if num_workers is not None else batch_size * 2
+        self.use_worker_init_fn = use_worker_init_fn
+        if train is not None:
+            self.dataset_configs["train"] = train
+            self.train_dataloader = self._train_dataloader
+        if validation is not None:
+            self.dataset_configs["validation"] = validation
+            self.val_dataloader = partial(
+                self._val_dataloader, shuffle=shuffle_val_dataloader
+            )
+        if test is not None:
+            self.dataset_configs["test"] = test
+            self.test_dataloader = partial(
+                self._test_dataloader, shuffle=shuffle_test_loader
+            )
+        if predict is not None:
+            self.dataset_configs["predict"] = predict
+            self.predict_dataloader = self._predict_dataloader
+        self.wrap = wrap
+
+    def prepare_data(self):
+        for data_cfg in self.dataset_configs.values():
+            instantiate_from_config(data_cfg)
+
+    def setup(self, stage=None):
+        self.datasets = dict(
+            (k, instantiate_from_config(self.dataset_configs[k]))
+            for k in self.dataset_configs
+        )
+        if self.wrap:
+            for k in self.datasets:
+                self.datasets[k] = WrappedDataset(self.datasets[k])
+
+    def _train_dataloader(self):
+        is_iterable_dataset = isinstance(
+            self.datasets["train"], Txt2ImgIterableBaseDataset
+        )
+        if is_iterable_dataset or self.use_worker_init_fn:
+            init_fn = worker_init_fn
+        else:
+            init_fn = None
+        return DataLoader(
+            self.datasets["train"],
+            batch_size=self.batch_size,
+            num_workers=self.num_workers,
+            shuffle=False if is_iterable_dataset else True,
+            worker_init_fn=init_fn,
+        )
+
+    def _val_dataloader(self, shuffle=False):
+        if (
+            isinstance(self.datasets["validation"], Txt2ImgIterableBaseDataset)
+            or self.use_worker_init_fn
+        ):
+            init_fn = worker_init_fn
+        else:
+            init_fn = None
+        return DataLoader(
+            self.datasets["validation"],
+            batch_size=self.batch_size,
+            num_workers=self.num_workers,
+            worker_init_fn=init_fn,
+            shuffle=shuffle,
+        )
+
+    def _test_dataloader(self, shuffle=False):
+        is_iterable_dataset = isinstance(
+            self.datasets["train"], Txt2ImgIterableBaseDataset
+        )
+        if is_iterable_dataset or self.use_worker_init_fn:
+            init_fn = worker_init_fn
+        else:
+            init_fn = None
+
+        # do not shuffle dataloader for iterable dataset
+        shuffle = shuffle and (not is_iterable_dataset)
+
+        return DataLoader(
+            self.datasets["test"],
+            batch_size=self.batch_size,
+            num_workers=self.num_workers,
+            worker_init_fn=init_fn,
+            shuffle=shuffle,
+        )
+
+    def _predict_dataloader(self, shuffle=False):
+        if (
+            isinstance(self.datasets["predict"], Txt2ImgIterableBaseDataset)
+            or self.use_worker_init_fn
+        ):
+            init_fn = worker_init_fn
+        else:
+            init_fn = None
+        return DataLoader(
+            self.datasets["predict"],
+            batch_size=self.batch_size,
+            num_workers=self.num_workers,
+            worker_init_fn=init_fn,
+        )

CCEdit-main/sgm/data/mnist.py

@@ -0,0 +1,85 @@
+import torchvision
+import pytorch_lightning as pl
+from torchvision import transforms
+from torch.utils.data import DataLoader, Dataset
+
+
+class MNISTDataDictWrapper(Dataset):
+    def __init__(self, dset):
+        super().__init__()
+        self.dset = dset
+
+    def __getitem__(self, i):
+        x, y = self.dset[i]
+        return {"jpg": x, "cls": y}
+
+    def __len__(self):
+        return len(self.dset)
+
+
+class MNISTLoader(pl.LightningDataModule):
+    def __init__(self, batch_size, num_workers=0, prefetch_factor=2, shuffle=True):
+        super().__init__()
+
+        transform = transforms.Compose(
+            [transforms.ToTensor(), transforms.Lambda(lambda x: x * 2.0 - 1.0)]
+        )
+
+        self.batch_size = batch_size
+        self.num_workers = num_workers
+        self.prefetch_factor = prefetch_factor if num_workers > 0 else 0
+        self.shuffle = shuffle
+        self.train_dataset = MNISTDataDictWrapper(
+            torchvision.datasets.MNIST(
+                root=".data/", train=True, download=True, transform=transform
+            )
+        )
+        self.test_dataset = MNISTDataDictWrapper(
+            torchvision.datasets.MNIST(
+                root=".data/", train=False, download=True, transform=transform
+            )
+        )
+
+    def prepare_data(self):
+        pass
+
+    def train_dataloader(self):
+        return DataLoader(
+            self.train_dataset,
+            batch_size=self.batch_size,
+            shuffle=self.shuffle,
+            num_workers=self.num_workers,
+            prefetch_factor=self.prefetch_factor,
+        )
+
+    def test_dataloader(self):
+        return DataLoader(
+            self.test_dataset,
+            batch_size=self.batch_size,
+            shuffle=self.shuffle,
+            num_workers=self.num_workers,
+            prefetch_factor=self.prefetch_factor,
+        )
+
+    def val_dataloader(self):
+        return DataLoader(
+            self.test_dataset,
+            batch_size=self.batch_size,
+            shuffle=self.shuffle,
+            num_workers=self.num_workers,
+            prefetch_factor=self.prefetch_factor,
+        )
+
+
+if __name__ == "__main__":
+    dset = MNISTDataDictWrapper(
+        torchvision.datasets.MNIST(
+            root=".data/",
+            train=False,
+            download=True,
+            transform=transforms.Compose(
+                [transforms.ToTensor(), transforms.Lambda(lambda x: x * 2.0 - 1.0)]
+            ),
+        )
+    )
+    ex = dset[0]

CCEdit-main/sgm/data/webvid/base_video_dataset.py

@@ -0,0 +1,521 @@
+import torch
+import os
+import random
+from abc import abstractmethod
+
+import av
+import cv2
+import decord
+import numpy as np
+from PIL import Image
+from torch.utils.data import Dataset, get_worker_info
+from torchvision import transforms
+
+
+# def init_transform_dict(
+#     input_res_h=224,
+#     input_res_w=224,
+#     randcrop_scale=(0.5, 1.0),
+#     color_jitter=(0, 0, 0),
+#     norm_mean=(0.5, 0.5, 0.5),
+#     norm_std=(0.5, 0.5, 0.5),
+# ):
+#     # todo: This part need to be discussed and designed carefully.
+#     normalize = transforms.Normalize(mean=norm_mean, std=norm_std)
+#     tsfm_dict = {
+#         "train": transforms.Compose(
+#             [
+#                 transforms.RandomResizedCrop(
+#                     (input_res_h, input_res_w), scale=randcrop_scale, antialias=True
+#                 ),
+#                 normalize,
+#             ]
+#         ),
+#         "val": transforms.Compose(
+#             [
+#                 # todo: should we use crop for validation and test?
+#                 transforms.Resize((input_res_h, input_res_w), antialias=True),
+#                 normalize,
+#             ]
+#         ),
+#         "test": transforms.Compose(
+#             [
+#                 transforms.Resize((input_res_h, input_res_w), antialias=True),
+#                 normalize,
+#             ]
+#         ),
+#     }
+#     return tsfm_dict
+def init_transform_dict(
+    input_res_h=224,
+    input_res_w=224,
+    randcrop_scale=(0.5, 1.0),
+    color_jitter=(0, 0, 0),
+    norm_mean=(0.5, 0.5, 0.5),
+    norm_std=(0.5, 0.5, 0.5),
+):
+    # todo: this implementation might cause bug sometimes.
+    # todo: make it safer, please.
+    normalize = transforms.Normalize(mean=norm_mean, std=norm_std)
+    tsfm_dict = {
+        "train": transforms.Compose(
+            [
+                transforms.Resize(input_res_h, antialias=True),
+                transforms.CenterCrop((input_res_h, input_res_w)),
+                normalize,
+            ]
+        ),
+        "val": transforms.Compose(
+            [
+                transforms.Resize(input_res_h, antialias=True),
+                transforms.CenterCrop((input_res_h, input_res_w)),
+                normalize,
+            ]
+        ),
+        "test": transforms.Compose(
+            [
+                transforms.Resize(input_res_h, antialias=True),
+                transforms.CenterCrop((input_res_h, input_res_w)),
+                normalize,
+            ]
+        ),
+    }
+    return tsfm_dict
+
+
+class TextVideoDataset(Dataset):
+    def __init__(
+        self,
+        dataset_name,
+        text_params,
+        video_params,
+        data_dir,
+        metadata_dir=None,
+        metadata_folder_name=None,  # "webvid10m_meta",
+        split="train",
+        tsfms=None,
+        cut=None,
+        key=None,
+        subsample=1,
+        sliding_window_stride=-1,
+        reader="decord",
+        first_stage_key="video",
+        cond_stage_key="txt",
+        skip_missing_files=True,
+        use_control_hint=False,
+        random_cond_img=False,
+    ):
+        # print(dataset_name, text_params, video_params)
+        # WebVid {'input': 'text'} {'input_res': 224, 'num_frames': 1, 'loading': 'lax'}
+        self.dataset_name = dataset_name
+        self.text_params = text_params
+        self.video_params = video_params
+        # check for environment variables
+        self.data_dir = os.path.expandvars(data_dir)
+        if metadata_dir is not None:
+            self.metadata_dir = os.path.expandvars(metadata_dir)
+        else:
+            self.metadata_dir = self.data_dir
+        # added parameters
+        self.metadata_folder_name = metadata_folder_name
+        self.first_stage_key = first_stage_key
+        self.cond_stage_key = cond_stage_key
+        self.skip = skip_missing_files
+        self.lack_files = []
+        self.split = split
+        self.key = key
+        tsfm_params = (
+            {}
+            if "tsfm_params" not in video_params.keys()
+            else video_params["tsfm_params"]
+        )
+        # tsfm_params['input_res'] = video_params['input_res']
+        tsfm_params["input_res_h"] = video_params["input_res_h"]
+        tsfm_params["input_res_w"] = video_params["input_res_w"]
+        tsfm_dict = init_transform_dict(**tsfm_params)
+
+        if split not in ["train", "val", "test"]:
+            print(
+                'Warning: split is not in ["train", "val", "test"], '
+                'what you set is "{}", '
+                'set it to "train"'.format(split)
+            )
+            split = "train"
+
+        tsfms = tsfm_dict[split]
+
+        self.transforms = tsfms
+        self.cut = cut
+        self.subsample = subsample
+        self.sliding_window_stride = sliding_window_stride
+        self.video_reader = video_reader[reader]
+        self.label_type = "caption"
+        self.frame_sample = video_params.get("frame_sample", "proportional")
+        self._load_metadata()
+        if self.sliding_window_stride != -1:
+            if self.split != "test":
+                raise ValueError(
+                    "Fixing frame sampling is for test time only. can remove but..."
+                )
+            self._fix_temporal_samples()
+        self.use_control_hint = use_control_hint
+        self.random_cond_img = random_cond_img
+
+    @abstractmethod
+    def _load_metadata(self):
+        raise NotImplementedError("Metadata loading must be implemented by subclass")
+
+    @abstractmethod
+    def _get_video_path(self, sample):
+        raise NotImplementedError(
+            "Get video path function must be implemented by subclass"
+        )
+
+    def _get_caption(self, sample):
+        raise NotImplementedError(
+            "Get caption function must be implemented by subclass"
+        )
+
+    def _get_video_lens(self):
+        vlen_li = []
+        for idx, row in self.metadata.iterrows():
+            video_path = self._get_video_path(row)[0]
+            vlen_li.append(get_video_len(video_path))
+
+        return vlen_li
+
+    def _fix_temporal_samples(self):
+        self.metadata["vlen"] = self._get_video_lens()
+        self.metadata["frame_intervals"] = self.metadata["vlen"].apply(
+            lambda x: np.linspace(
+                start=0, stop=x, num=min(x, self.video_params["num_frames"]) + 1
+            ).astype(int)
+        )
+        self.metadata["fix_start"] = self.metadata["frame_intervals"].apply(
+            lambda x: np.arange(0, int(x[-1] / len(x - 1)), self.sliding_window_stride)
+        )
+        self.metadata = self.metadata.explode("fix_start")
+
+    def __len__(self):
+        return len(self.metadata)
+
+    def __getitem__(self, item):
+        item = item % len(self.metadata)
+        sample = self.metadata.iloc[item]
+        video_fp, rel_fp = self._get_video_path(sample)
+        # if not os.path.exists(video_fp):
+        #     return self.__getitem__(np.random.choice(self.__len__()))
+        caption = self._get_caption(sample)
+
+        video_loading = self.video_params.get("loading", "strict")  #
+        # frame_sample = 'rand'
+        fix_start = None
+        # if self.split == 'test':
+        #     frame_sample = 'uniform'
+        if self.sliding_window_stride != -1:
+            fix_start = sample["fix_start"]
+
+        try:
+            if os.path.isfile(video_fp):
+                # imgs, idxs = self.video_reader(video_fp, self.video_params['num_frames'], frame_sample,
+                #                                fix_start=fix_start)
+                if self.frame_sample == "equally spaced":
+                    sample_factor = self.video_params.get("es_interval", 10)
+                elif self.frame_sample == "proportional":
+                    sample_factor = self.video_params.get("prop_factor", 3)
+                imgs, idxs = self.video_reader(
+                    video_fp,
+                    self.video_params["num_frames"],
+                    self.frame_sample,
+                    fix_start=fix_start,
+                    sample_factor=sample_factor,
+                )
+                if self.random_cond_img:
+                    random_cond_img, _ = self.video_reader(
+                        video_fp,
+                        1,
+                        self.frame_sample,
+                        fix_start=fix_start,
+                        sample_factor=sample_factor,
+                    )
+            else:
+                print_str = f"Warning: missing video file {video_fp}."
+                if video_fp not in self.lack_files:
+                    self.lack_files.append(video_fp)
+                if self.skip:
+                    print_str += " Resampling another video."
+                    print(print_str)
+                    return self.__getitem__(np.random.choice(self.__len__()))
+                else:
+                    print(print_str)
+                    assert False
+
+        except Exception as e:
+            if video_loading == "strict":
+                raise ValueError(
+                    f"Video loading failed for {video_fp}, video loading for this dataset is strict."
+                ) from e
+            else:
+                print("Warning: using the pure black image as the frame sample")
+                # imgs = Image.new('RGB', (self.video_params['input_res'], self.video_params['input_res']), (0, 0, 0))
+                imgs = Image.new(
+                    "RGB",
+                    (
+                        self.video_params["input_res_w"],
+                        self.video_params["input_res_h"],
+                    ),
+                    (0, 0, 0),
+                )
+                imgs = transforms.ToTensor()(imgs).unsqueeze(0)
+                if self.random_cond_img:
+                    random_cond_img = Image.new(
+                        "RGB",
+                        (
+                            self.video_params["input_res_w"],
+                            self.video_params["input_res_h"],
+                        ),
+                        (0, 0, 0),
+                    )
+                    random_cond_img = transforms.ToTensor()(random_cond_img).unsqueeze(0)
+
+        if self.transforms is not None:
+            imgs = self.transforms(imgs)  # normalize or 2 * x - 1 ?
+
+        # final = torch.zeros([self.video_params['num_frames'], 3, self.video_params['input_res'],
+        #                      self.video_params['input_res']])
+        final = torch.zeros(
+            [
+                self.video_params["num_frames"],
+                3,
+                self.video_params["input_res_h"],
+                self.video_params["input_res_w"],
+            ]
+        )
+
+        final[: imgs.shape[0]] = imgs
+        if self.random_cond_img:
+            # import pdb; pdb.set_trace()
+            # import torchvision
+            # torchvision.utils.save_image(random_cond_img, 'debug_random_cond_img.png', normalize=True)
+            # torchvision.utils.save_image(imgs, 'debug_imgs.png', normalize=True)
+            cond_img = self.transforms(random_cond_img).squeeze(0)
+        else:
+            cond_img = final[final.shape[0] // 2, ...]
+        final = final.permute(1, 0, 2, 3)  # (C, T, H, W)
+        interpolate_first_last = final[:, [0, -1], ...]
+
+        meta_arr = {
+            "raw_captions": caption,
+            "paths": rel_fp,
+            "dataset": self.dataset_name,
+        }
+        data = {
+            self.first_stage_key: final,
+            self.cond_stage_key: caption,
+            "cond_img": cond_img,
+            'interpolate_first_last': interpolate_first_last,
+            "original_size_as_tuple": torch.tensor(
+                [self.video_params["input_res_w"], self.video_params["input_res_h"]]
+            ),  # TODO only for debug
+            "target_size_as_tuple": torch.tensor(
+                [self.video_params["input_res_w"], self.video_params["input_res_h"]]
+            ),  # TODO only for debug
+            "crop_coords_top_left": torch.tensor([0, 0]),  # TODO only for debug
+            "meta": meta_arr,
+        }
+        if self.use_control_hint:
+            data["control_hint"] = final
+        return data
+
+
+class TextImageDataset(TextVideoDataset):
+    def __getitem__(self, item):
+        item = item % len(self.metadata)
+        sample = self.metadata.iloc[item]
+        video_fp, rel_fp = self._get_video_path(sample)
+        caption = self._get_caption(sample)
+
+        video_loading = self.video_params.get("loading", "strict")
+
+        try:
+            img = Image.open(video_fp).convert("RGB")
+        except:
+            if video_loading == "strict":
+                raise ValueError(
+                    f"Image loading failed for {video_fp}, image loading for this dataset is strict."
+                )
+            else:
+                # img = Image.new('RGB', (self.video_params['input_res'], self.video_params['input_res']), (0, 0, 0))
+                img = Image.new(
+                    "RGB",
+                    (
+                        self.video_params["input_res_w"],
+                        self.video_params["input_res_h"],
+                    ),
+                    (0, 0, 0),
+                )
+
+        # convert to tensor because video transforms don't, expand such that its a 1-frame video.
+        img = transforms.ToTensor()(img).unsqueeze(0)
+        if self.transforms is not None:
+            img = self.transforms(img)
+        meta_arr = {
+            "raw_captions": caption,
+            "paths": rel_fp,
+            "dataset": self.dataset_name,
+        }
+        data = {"video": img, "text": caption, "meta": meta_arr}
+        return data
+
+
+def sample_frames(
+    num_frames, vlen, sample="rand", fix_start=None, **kwargs
+):  # TBD, what do you need
+    """
+    num_frames: The number of frames to sample.
+    vlen: The length of the video.
+    sample: The sampling method.
+        choices of frame_sample:
+        - 'equally spaced': sample frames equally spaced
+            e.g.,1s video has 30 frames, when 'es_interval'=8, we sample frames with spacing of 8
+        - 'proportional': sample frames proportional to the length of the frames in one second
+            e.g., 1s video has 30 frames, when 'prop_factor'=3, we sample frames with spacing of 30/3=10
+        - 'random': sample frames randomly (not recommended)
+        - 'uniform': sample frames uniformly (not recommended)
+    fix_start: The starting frame index. If it is not None, then it will be used as the starting frame index.
+    """
+    acc_samples = min(num_frames, vlen)
+    if sample in ["rand", "uniform"]:
+        intervals = np.linspace(start=0, stop=vlen, num=acc_samples + 1).astype(int)
+        ranges = []
+        for idx, interv in enumerate(intervals[:-1]):
+            ranges.append((interv, intervals[idx + 1] - 1))
+        if sample == "rand":
+            frame_idxs = [random.choice(range(x[0], x[1])) for x in ranges]
+        elif fix_start is not None:
+            frame_idxs = [x[0] + fix_start for x in ranges]
+        elif sample == "uniform":
+            frame_idxs = [(x[0] + x[1]) // 2 for x in ranges]
+    elif sample in ["equally spaced", "proportional"]:
+        if sample == "equally spaced":
+            raise NotImplementedError  # need to pass in the corresponding parameters
+        else:
+            interval = round(kwargs["fps"] / kwargs["sample_factor"])
+            needed_frames = (acc_samples - 1) * interval
+
+            if fix_start is not None:
+                start = fix_start
+            else:
+                if vlen - needed_frames - 1 < 0:
+                    start = 0
+                else:
+                    start = random.randint(0, vlen - needed_frames - 1)
+            frame_idxs = np.linspace(
+                start=start, stop=min(vlen - 1, start + needed_frames), num=acc_samples
+            ).astype(int)
+    else:
+        raise NotImplementedError
+
+    return frame_idxs
+
+
+def read_frames_cv2(video_path, num_frames, sample="rand", fix_start=None, **kwargs):
+    cap = cv2.VideoCapture(video_path)
+    assert cap.isOpened()
+    vlen = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+    # frame_idxs = sample_frames(num_frames, vlen, sample=sample, fix_start=fix_start)
+    # get indexes of sampled frames
+    fps = cap.get(cv2.CAP_PROP_FPS)  # not verified yet, might cause bug.
+    frame_idxs = sample_frames(
+        num_frames,
+        vlen,
+        sample=sample,
+        fix_start=fix_start,
+        fps=fps,
+        sample_factor=kwargs["sample_factor"],
+    )
+    frames = []
+    success_idxs = []
+    for index in frame_idxs:
+        cap.set(cv2.CAP_PROP_POS_FRAMES, index - 1)
+        ret, frame = cap.read()
+        if ret:
+            frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+            frame = torch.from_numpy(frame)
+            # (H x W x C) to (C x H x W)
+            frame = frame.permute(2, 0, 1)
+            frames.append(frame)
+            success_idxs.append(index)
+        else:
+            pass
+            # print(frame_idxs, ' fail ', index, f'  (vlen {vlen})')
+
+    frames = torch.stack(frames).float() / 255
+    cap.release()
+    return frames, success_idxs
+
+
+def read_frames_av(video_path, num_frames, sample="rand", fix_start=None, **kwargs):
+    reader = av.open(video_path)
+    try:
+        frames = []
+        frames = [
+            torch.from_numpy(f.to_rgb().to_ndarray()) for f in reader.decode(video=0)
+        ]
+    except (RuntimeError, ZeroDivisionError) as exception:
+        print(
+            "{}: WEBM reader cannot open {}. Empty "
+            "list returned.".format(type(exception).__name__, video_path)
+        )
+    vlen = len(frames)
+    # frame_idxs = sample_frames(num_frames, vlen, sample=sample, fix_start=fix_start)
+    fps = reader.streams.video[0].average_rate  # not verified yet, might cause bug.
+    frame_idxs = sample_frames(
+        num_frames,
+        vlen,
+        sample=sample,
+        fix_start=fix_start,
+        fps=fps,
+        sample_factor=kwargs["sample_factor"],
+    )
+    frames = torch.stack([frames[idx] for idx in frame_idxs]).float() / 255
+    frames = frames.permute(0, 3, 1, 2)
+    return frames, frame_idxs
+
+
+decord.bridge.set_bridge("torch")
+
+
+def read_frames_decord(video_path, num_frames, sample="rand", fix_start=None, **kwargs):
+    video_reader = decord.VideoReader(video_path, num_threads=0)
+    vlen = len(video_reader)
+    # frame_idxs = sample_frames(num_frames, vlen, sample=sample, fix_start=fix_start)
+    fps = video_reader.get_avg_fps()  # note that the fps here is float.
+    frame_idxs = sample_frames(
+        num_frames,
+        vlen,
+        sample=sample,
+        fix_start=fix_start,
+        fps=fps,
+        sample_factor=kwargs["sample_factor"],
+    )
+    frames = video_reader.get_batch(frame_idxs)
+    frames = frames.float() / 255
+    frames = frames.permute(0, 3, 1, 2)
+    return frames, frame_idxs
+
+
+def get_video_len(video_path):
+    cap = cv2.VideoCapture(video_path)
+    if not (cap.isOpened()):
+        return False
+    vlen = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+    cap.release()
+    return vlen
+
+
+video_reader = {
+    "av": read_frames_av,
+    "cv2": read_frames_cv2,
+    "decord": read_frames_decord,
+}

CCEdit-main/sgm/data/webvid/webvid_dataset.py

@@ -0,0 +1,152 @@
+import os
+
+import pandas as pd
+
+from .base_video_dataset import TextVideoDataset
+
+
+class WebVid(TextVideoDataset):
+    """
+    WebVid Dataset.
+    Assumes webvid data is structured as follows.
+    Webvid/
+        videos/
+            000001_000050/      ($page_dir)
+                1.mp4           (videoid.mp4)
+                ...
+                5000.mp4
+            ...
+    """
+
+    def _load_metadata(self):
+        assert self.metadata_folder_name is not None
+        assert self.cut is not None
+        metadata_dir = os.path.join(self.metadata_dir, self.metadata_folder_name)
+        if self.key is None:
+            metadata_fp = os.path.join(
+                metadata_dir, f"results_{self.cut}_{self.split}.csv"
+            )
+        else:
+            metadata_fp = os.path.join(
+                metadata_dir, f"results_{self.cut}_{self.split}_{self.key}.csv"
+            )
+        print(metadata_fp)
+        metadata = pd.read_csv(
+            metadata_fp,
+            on_bad_lines="skip",
+            encoding="ISO-8859-1",
+            engine="python",
+            sep=",",
+        )
+
+        if self.subsample < 1:
+            metadata = metadata.sample(frac=self.subsample)
+        elif self.split == "val":
+            try:
+                metadata = metadata.sample(1000, random_state=0)
+            except:
+                print(
+                    "there are less than 1000 samples in the val set, thus no downsampling is done"
+                )
+                pass
+
+        metadata["caption"] = metadata["name"]
+        del metadata["name"]
+        self.metadata = metadata
+        self.metadata.dropna(inplace=True)
+
+    def _get_video_path(self, sample):
+        rel_video_fp = str(sample["videoid"]) + ".mp4"
+        full_video_fp = os.path.join(self.data_dir, rel_video_fp)
+        if not os.path.exists(full_video_fp):
+            full_video_fp = os.path.join(self.data_dir, "videos", rel_video_fp)
+        return full_video_fp, rel_video_fp
+
+    def _get_caption(self, sample):
+        return sample["caption"]
+
+
+if __name__ == "__main__":
+    from tqdm import tqdm
+    import imageio
+    import argparse
+    import numpy as np
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--out_path", type=str, default=None)
+    parser.add_argument("--num_frames", type=int, default=17)
+    parser.add_argument("--motion_scale", type=int, default=4)
+    opt = parser.parse_known_args()[0]
+
+    def write_text_to_file(text, file_path):
+        with open(file_path, "w") as file:
+            file.write(text)
+
+    config = {
+        "dataset_name": "WebVid",
+        "data_dir": "/msra_data/videos_rmwm",
+        "metadata_dir": "/msra_data",
+        "split": "val",
+        "cut": "2M",
+        "key": "wmrm_all",
+        "subsample": 1,
+        "text_params": {"input": "text"},
+        "video_params": {
+            "input_res_h": 320,  # todo: check the input_res_h
+            "input_res_w": 320,  # todo: check the input_res_w
+            "tsfm_params": {
+                "norm_mean": [0.5, 0.5, 0.5],
+                "norm_std": [0.5, 0.5, 0.5],
+            },
+            "num_frames": opt.num_frames,
+            "prop_factor": 30,
+            "loading": "lax",
+        },
+        "metadata_folder_name": "webvid10m_meta",
+        "first_stage_key": "jpg",
+        "cond_stage_key": "txt",
+        "skip_missing_files": False,
+    }
+
+    dataset = WebVid(**config)
+    length = dataset.__len__()
+
+    txt_out_path = os.path.join(
+        opt.out_path, f"num{opt.num_frames}_ms{opt.motion_scale}", "txt"
+    )
+    video_out_high_path = os.path.join(
+        opt.out_path, f"num{opt.num_frames}_ms{opt.motion_scale}", "videoHigh"
+    )
+    video_out_low_path = os.path.join(
+        opt.out_path, f"num{opt.num_frames}_ms{opt.motion_scale}", "videoLow"
+    )
+    os.makedirs(txt_out_path, exist_ok=True)
+    os.makedirs(video_out_high_path, exist_ok=True)
+    os.makedirs(video_out_low_path, exist_ok=True)
+
+    for idx in tqdm(range(length)):
+        print(idx)
+        item = dataset.__getitem__(idx)
+        video = item["jpg"]
+        txt = item["txt"]
+
+        video_new = (
+            ((video.transpose(3, 1) * 0.5 + 0.5).clamp(0, 1) * 255.0)
+            .numpy()
+            .astype(np.uint8)
+        )
+        video_list = [img for img in video_new]
+        imageio.mimsave(
+            os.path.join(video_out_high_path, f"{idx:09d}.gif"),
+            video_list,
+            duration=1,
+            loops=1,
+        )
+        imageio.mimsave(
+            os.path.join(video_out_low_path, f"{idx:09d}.gif"),
+            video_list[:: opt.motion_scale],
+            duration=1 * opt.motion_scale,
+            loops=1,
+        )
+
+        write_text_to_file(txt, os.path.join(txt_out_path, f"{idx:09d}.txt"))

CCEdit-main/sgm/lr_scheduler.py

@@ -0,0 +1,135 @@
+import numpy as np
+
+
+class LambdaWarmUpCosineScheduler:
+    """
+    note: use with a base_lr of 1.0
+    """
+
+    def __init__(
+        self,
+        warm_up_steps,
+        lr_min,
+        lr_max,
+        lr_start,
+        max_decay_steps,
+        verbosity_interval=0,
+    ):
+        self.lr_warm_up_steps = warm_up_steps
+        self.lr_start = lr_start
+        self.lr_min = lr_min
+        self.lr_max = lr_max
+        self.lr_max_decay_steps = max_decay_steps
+        self.last_lr = 0.0
+        self.verbosity_interval = verbosity_interval
+
+    def schedule(self, n, **kwargs):
+        if self.verbosity_interval > 0:
+            if n % self.verbosity_interval == 0:
+                print(f"current step: {n}, recent lr-multiplier: {self.last_lr}")
+        if n < self.lr_warm_up_steps:
+            lr = (
+                self.lr_max - self.lr_start
+            ) / self.lr_warm_up_steps * n + self.lr_start
+            self.last_lr = lr
+            return lr
+        else:
+            t = (n - self.lr_warm_up_steps) / (
+                self.lr_max_decay_steps - self.lr_warm_up_steps
+            )
+            t = min(t, 1.0)
+            lr = self.lr_min + 0.5 * (self.lr_max - self.lr_min) * (
+                1 + np.cos(t * np.pi)
+            )
+            self.last_lr = lr
+            return lr
+
+    def __call__(self, n, **kwargs):
+        return self.schedule(n, **kwargs)
+
+
+class LambdaWarmUpCosineScheduler2:
+    """
+    supports repeated iterations, configurable via lists
+    note: use with a base_lr of 1.0.
+    """
+
+    def __init__(
+        self, warm_up_steps, f_min, f_max, f_start, cycle_lengths, verbosity_interval=0
+    ):
+        assert (
+            len(warm_up_steps)
+            == len(f_min)
+            == len(f_max)
+            == len(f_start)
+            == len(cycle_lengths)
+        )
+        self.lr_warm_up_steps = warm_up_steps
+        self.f_start = f_start
+        self.f_min = f_min
+        self.f_max = f_max
+        self.cycle_lengths = cycle_lengths
+        self.cum_cycles = np.cumsum([0] + list(self.cycle_lengths))
+        self.last_f = 0.0
+        self.verbosity_interval = verbosity_interval
+
+    def find_in_interval(self, n):
+        interval = 0
+        for cl in self.cum_cycles[1:]:
+            if n <= cl:
+                return interval
+            interval += 1
+
+    def schedule(self, n, **kwargs):
+        cycle = self.find_in_interval(n)
+        n = n - self.cum_cycles[cycle]
+        if self.verbosity_interval > 0:
+            if n % self.verbosity_interval == 0:
+                print(
+                    f"current step: {n}, recent lr-multiplier: {self.last_f}, "
+                    f"current cycle {cycle}"
+                )
+        if n < self.lr_warm_up_steps[cycle]:
+            f = (self.f_max[cycle] - self.f_start[cycle]) / self.lr_warm_up_steps[
+                cycle
+            ] * n + self.f_start[cycle]
+            self.last_f = f
+            return f
+        else:
+            t = (n - self.lr_warm_up_steps[cycle]) / (
+                self.cycle_lengths[cycle] - self.lr_warm_up_steps[cycle]
+            )
+            t = min(t, 1.0)
+            f = self.f_min[cycle] + 0.5 * (self.f_max[cycle] - self.f_min[cycle]) * (
+                1 + np.cos(t * np.pi)
+            )
+            self.last_f = f
+            return f
+
+    def __call__(self, n, **kwargs):
+        return self.schedule(n, **kwargs)
+
+
+class LambdaLinearScheduler(LambdaWarmUpCosineScheduler2):
+    def schedule(self, n, **kwargs):
+        cycle = self.find_in_interval(n)
+        n = n - self.cum_cycles[cycle]
+        if self.verbosity_interval > 0:
+            if n % self.verbosity_interval == 0:
+                print(
+                    f"current step: {n}, recent lr-multiplier: {self.last_f}, "
+                    f"current cycle {cycle}"
+                )
+
+        if n < self.lr_warm_up_steps[cycle]:
+            f = (self.f_max[cycle] - self.f_start[cycle]) / self.lr_warm_up_steps[
+                cycle
+            ] * n + self.f_start[cycle]
+            self.last_f = f
+            return f
+        else:
+            f = self.f_min[cycle] + (self.f_max[cycle] - self.f_min[cycle]) * (
+                self.cycle_lengths[cycle] - n
+            ) / (self.cycle_lengths[cycle])
+            self.last_f = f
+            return f

CCEdit-main/sgm/models/__init__.py

@@ -0,0 +1,2 @@
+from .autoencoder import AutoencodingEngine
+from .diffusion import DiffusionEngine

CCEdit-main/sgm/models/autoencoder.py

@@ -0,0 +1,357 @@
+import re
+from abc import abstractmethod
+from contextlib import contextmanager
+from typing import Any, Dict, Tuple, Union
+import einops
+
+import pytorch_lightning as pl
+import torch
+from omegaconf import ListConfig
+from packaging import version
+from safetensors.torch import load_file as load_safetensors
+
+from ..modules.diffusionmodules.model import Decoder, Encoder
+from ..modules.distributions.distributions import DiagonalGaussianDistribution
+from ..modules.ema import LitEma
+from ..util import default, get_obj_from_str, instantiate_from_config
+
+
+class AbstractAutoencoder(pl.LightningModule):
+    """
+    This is the base class for all autoencoders, including image autoencoders, image autoencoders with discriminators,
+    unCLIP models, etc. Hence, it is fairly general, and specific features
+    (e.g. discriminator training, encoding, decoding) must be implemented in subclasses.
+    """
+
+    def __init__(
+        self,
+        ema_decay: Union[None, float] = None,
+        monitor: Union[None, str] = None,
+        input_key: str = "jpg",
+        ckpt_path: Union[None, str] = None,
+        ignore_keys: Union[Tuple, list, ListConfig] = (),
+    ):
+        super().__init__()
+        self.input_key = input_key
+        self.use_ema = ema_decay is not None
+        if monitor is not None:
+            self.monitor = monitor
+
+        if self.use_ema:
+            self.model_ema = LitEma(self, decay=ema_decay)
+            print(f"Keeping EMAs of {len(list(self.model_ema.buffers()))}.")
+
+        if ckpt_path is not None:
+            self.init_from_ckpt(ckpt_path, ignore_keys=ignore_keys)
+
+        if version.parse(torch.__version__) >= version.parse("2.0.0"):
+            self.automatic_optimization = False
+
+    def init_from_ckpt(
+        self, path: str, ignore_keys: Union[Tuple, list, ListConfig] = tuple()
+    ) -> None:
+        if path.endswith("ckpt"):
+            sd = torch.load(path, map_location="cpu")["state_dict"]
+        elif path.endswith("safetensors"):
+            sd = load_safetensors(path)
+        else:
+            raise NotImplementedError
+
+        keys = list(sd.keys())
+        for k in keys:
+            for ik in ignore_keys:
+                if re.match(ik, k):
+                    print("Deleting key {} from state_dict.".format(k))
+                    del sd[k]
+        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}")
+
+    @abstractmethod
+    def get_input(self, batch) -> Any:
+        raise NotImplementedError()
+
+    def on_train_batch_end(self, *args, **kwargs):
+        # for EMA computation
+        if self.use_ema:
+            self.model_ema(self)
+
+    @contextmanager
+    def ema_scope(self, context=None):
+        if self.use_ema:
+            self.model_ema.store(self.parameters())
+            self.model_ema.copy_to(self)
+            if context is not None:
+                print(f"{context}: Switched to EMA weights")
+        try:
+            yield None
+        finally:
+            if self.use_ema:
+                self.model_ema.restore(self.parameters())
+                if context is not None:
+                    print(f"{context}: Restored training weights")
+
+    @abstractmethod
+    def encode(self, *args, **kwargs) -> torch.Tensor:
+        raise NotImplementedError("encode()-method of abstract base class called")
+
+    @abstractmethod
+    def decode(self, *args, **kwargs) -> torch.Tensor:
+        raise NotImplementedError("decode()-method of abstract base class called")
+
+    def instantiate_optimizer_from_config(self, params, lr, cfg):
+        print(f"loading >>> {cfg['target']} <<< optimizer from config")
+        return get_obj_from_str(cfg["target"])(
+            params, lr=lr, **cfg.get("params", dict())
+        )
+
+    def configure_optimizers(self) -> Any:
+        raise NotImplementedError()
+
+
+class AutoencodingEngine(AbstractAutoencoder):
+    """
+    Base class for all image autoencoders that we train, like VQGAN or AutoencoderKL
+    (we also restore them explicitly as special cases for legacy reasons).
+    Regularizations such as KL or VQ are moved to the regularizer class.
+    """
+
+    def __init__(
+        self,
+        *args,
+        encoder_config: Dict,
+        decoder_config: Dict,
+        loss_config: Dict,
+        regularizer_config: Dict,
+        optimizer_config: Union[Dict, None] = None,
+        lr_g_factor: float = 1.0,
+        **kwargs,
+    ):
+        super().__init__(*args, **kwargs)
+        # todo: add options to freeze encoder/decoder
+        self.encoder = instantiate_from_config(encoder_config)
+        self.decoder = instantiate_from_config(decoder_config)
+        self.loss = instantiate_from_config(loss_config)
+        self.regularization = instantiate_from_config(regularizer_config)
+        self.optimizer_config = default(
+            optimizer_config, {"target": "torch.optim.Adam"}
+        )
+        self.lr_g_factor = lr_g_factor
+
+    def get_input(self, batch: Dict) -> torch.Tensor:
+        # assuming unified data format, dataloader returns a dict.
+        # image tensors should be scaled to -1 ... 1 and in channels-first format (e.g., bchw instead if bhwc)
+        return batch[self.input_key]
+
+    def get_autoencoder_params(self) -> list:
+        params = (
+            list(self.encoder.parameters())
+            + list(self.decoder.parameters())
+            + list(self.regularization.get_trainable_parameters())
+            + list(self.loss.get_trainable_autoencoder_parameters())
+        )
+        return params
+
+    def get_discriminator_params(self) -> list:
+        params = list(self.loss.get_trainable_parameters())  # e.g., discriminator
+        return params
+
+    def get_last_layer(self):
+        return self.decoder.get_last_layer()
+
+    def encode(self, x: Any, return_reg_log: bool = False) -> Any:
+        z = self.encoder(x)
+        z, reg_log = self.regularization(z)
+        if return_reg_log:
+            return z, reg_log
+        return z
+
+    def decode(self, z: Any) -> torch.Tensor:
+        x = self.decoder(z)
+        return x
+
+    def forward(self, x: Any) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+        z, reg_log = self.encode(x, return_reg_log=True)
+        dec = self.decode(z)
+        return z, dec, reg_log
+
+    def training_step(self, batch, batch_idx, optimizer_idx) -> Any:
+        x = self.get_input(batch)
+        z, xrec, regularization_log = self(x)
+
+        if optimizer_idx == 0:
+            # autoencode
+            aeloss, log_dict_ae = self.loss(
+                regularization_log,
+                x,
+                xrec,
+                optimizer_idx,
+                self.global_step,
+                last_layer=self.get_last_layer(),
+                split="train",
+            )
+
+            self.log_dict(
+                log_dict_ae, prog_bar=False, logger=True, on_step=True, on_epoch=True
+            )
+            return aeloss
+
+        if optimizer_idx == 1:
+            # discriminator
+            discloss, log_dict_disc = self.loss(
+                regularization_log,
+                x,
+                xrec,
+                optimizer_idx,
+                self.global_step,
+                last_layer=self.get_last_layer(),
+                split="train",
+            )
+            self.log_dict(
+                log_dict_disc, prog_bar=False, logger=True, on_step=True, on_epoch=True
+            )
+            return discloss
+
+    def validation_step(self, batch, batch_idx) -> Dict:
+        log_dict = self._validation_step(batch, batch_idx)
+        with self.ema_scope():
+            log_dict_ema = self._validation_step(batch, batch_idx, postfix="_ema")
+            log_dict.update(log_dict_ema)
+        return log_dict
+
+    def _validation_step(self, batch, batch_idx, postfix="") -> Dict:
+        x = self.get_input(batch)
+
+        z, xrec, regularization_log = self(x)
+        aeloss, log_dict_ae = self.loss(
+            regularization_log,
+            x,
+            xrec,
+            0,
+            self.global_step,
+            last_layer=self.get_last_layer(),
+            split="val" + postfix,
+        )
+
+        discloss, log_dict_disc = self.loss(
+            regularization_log,
+            x,
+            xrec,
+            1,
+            self.global_step,
+            last_layer=self.get_last_layer(),
+            split="val" + postfix,
+        )
+        self.log(f"val{postfix}/rec_loss", log_dict_ae[f"val{postfix}/rec_loss"])
+        log_dict_ae.update(log_dict_disc)
+        self.log_dict(log_dict_ae)
+        return log_dict_ae
+
+    def configure_optimizers(self) -> Any:
+        ae_params = self.get_autoencoder_params()
+        disc_params = self.get_discriminator_params()
+
+        opt_ae = self.instantiate_optimizer_from_config(
+            ae_params,
+            default(self.lr_g_factor, 1.0) * self.learning_rate,
+            self.optimizer_config,
+        )
+        opt_disc = self.instantiate_optimizer_from_config(
+            disc_params, self.learning_rate, self.optimizer_config
+        )
+
+        return [opt_ae, opt_disc], []
+
+    @torch.no_grad()
+    def log_images(self, batch: Dict, **kwargs) -> Dict:
+        log = dict()
+        x = self.get_input(batch)
+        _, xrec, _ = self(x)
+        log["inputs"] = x
+        log["reconstructions"] = xrec
+        with self.ema_scope():
+            _, xrec_ema, _ = self(x)
+            log["reconstructions_ema"] = xrec_ema
+        return log
+
+
+class AutoencoderKL(AutoencodingEngine):
+    def __init__(self, embed_dim: int, **kwargs):
+        ddconfig = kwargs.pop("ddconfig")
+        ckpt_path = kwargs.pop("ckpt_path", None)
+        ignore_keys = kwargs.pop("ignore_keys", ())
+        super().__init__(
+            encoder_config={"target": "torch.nn.Identity"},
+            decoder_config={"target": "torch.nn.Identity"},
+            regularizer_config={"target": "torch.nn.Identity"},
+            loss_config=kwargs.pop("lossconfig"),
+            **kwargs,
+        )
+        assert ddconfig["double_z"]
+        self.encoder = Encoder(**ddconfig)
+        self.decoder = Decoder(**ddconfig)
+        self.quant_conv = torch.nn.Conv2d(2 * ddconfig["z_channels"], 2 * embed_dim, 1)
+        self.post_quant_conv = torch.nn.Conv2d(embed_dim, ddconfig["z_channels"], 1)
+        self.embed_dim = embed_dim
+
+        if ckpt_path is not None:
+            self.init_from_ckpt(ckpt_path, ignore_keys=ignore_keys)
+
+    def encode(self, x):
+        assert (
+            not self.training
+        ), f"{self.__class__.__name__} only supports inference currently"
+        assert x.dim() == 4
+        h = self.encoder(x)
+        moments = self.quant_conv(h)
+        posterior = DiagonalGaussianDistribution(moments)
+
+        return posterior
+
+    def decode(self, z, **decoder_kwargs):
+        z = self.post_quant_conv(z)
+        dec = self.decoder(z, **decoder_kwargs)
+        return dec
+
+
+class AutoencoderKLInferenceWrapper(AutoencoderKL):
+    def encode(self, x):
+        # return super().encode(x).sample()
+        is_video = x.dim() == 5
+        if is_video:
+            b, c, t, h, w = x.shape
+            x = einops.rearrange(x, "b c t h w -> (b t) c h w")
+        x = super().encode(x).sample()
+        if is_video:
+            x = einops.rearrange(x, "(b t) c h w -> b c t h w", b=b, t=t)
+        return x
+
+    def decode(self, z, **decoder_kwargs):
+        is_video = z.dim() == 5
+        if is_video:
+            b, c, t, h, w = z.shape
+            z = einops.rearrange(z, "b c t h w -> (b t) c h w")
+        z = self.post_quant_conv(z.to(self.post_quant_conv.weight.dtype))
+        dec = self.decoder(z, **decoder_kwargs)
+        if is_video:
+            dec = einops.rearrange(dec, "(b t) c h w -> b c t h w", b=b, t=t)
+        return dec
+
+
+class IdentityFirstStage(AbstractAutoencoder):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+    def get_input(self, x: Any) -> Any:
+        return x
+
+    def encode(self, x: Any, *args, **kwargs) -> Any:
+        return x
+
+    def decode(self, x: Any, *args, **kwargs) -> Any:
+        return x

CCEdit-main/sgm/models/diffusion-ori.py

@@ -0,0 +1,320 @@
+from contextlib import contextmanager
+from typing import Any, Dict, List, Tuple, Union
+
+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 ..modules import UNCONDITIONAL_CONFIG
+from ..modules.diffusionmodules.wrappers import OPENAIUNETWRAPPER
+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)
+        self.model = get_obj_from_str(default(network_wrapper, OPENAIUNETWRAPPER))(
+            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:
+        if path.endswith("ckpt"):
+            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)
+                    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

CCEdit-main/sgm/models/diffusion.py

@@ -0,0 +1,910 @@
+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()

CCEdit-main/sgm/modules/__init__.py

@@ -0,0 +1,6 @@
+from .encoders.modules import GeneralConditioner
+
+UNCONDITIONAL_CONFIG = {
+    "target": "sgm.modules.GeneralConditioner",
+    "params": {"emb_models": []},
+}

CCEdit-main/sgm/modules/attention.py

@@ -0,0 +1,1663 @@
+import math
+from inspect import isfunction
+from typing import Any, Optional
+
+import torch
+import torch.nn.functional as F
+from einops import rearrange, repeat
+from packaging import version
+from torch import nn
+
+import loralib as lora
+
+if version.parse(torch.__version__) >= version.parse("2.0.0"):
+    SDP_IS_AVAILABLE = True
+    from torch.backends.cuda import SDPBackend, sdp_kernel
+
+    BACKEND_MAP = {
+        SDPBackend.MATH: {
+            "enable_math": True,
+            "enable_flash": False,
+            "enable_mem_efficient": False,
+        },
+        SDPBackend.FLASH_ATTENTION: {
+            "enable_math": False,
+            "enable_flash": True,
+            "enable_mem_efficient": False,
+        },
+        SDPBackend.EFFICIENT_ATTENTION: {
+            "enable_math": False,
+            "enable_flash": False,
+            "enable_mem_efficient": True,
+        },
+        None: {"enable_math": True, "enable_flash": True, "enable_mem_efficient": True},
+    }
+else:
+    from contextlib import nullcontext
+
+    SDP_IS_AVAILABLE = False
+    sdp_kernel = nullcontext
+    BACKEND_MAP = {}
+    print(
+        f"No SDP backend available, likely because you are running in pytorch versions < 2.0. In fact, "
+        f"you are using PyTorch {torch.__version__}. You might want to consider upgrading."
+    )
+
+try:
+    import xformers
+    import xformers.ops
+
+    XFORMERS_IS_AVAILABLE = True
+except:
+    XFORMERS_IS_AVAILABLE = False
+    print("no module 'xformers'. Processing without...")
+
+from .diffusionmodules.util import checkpoint
+
+try:
+    from flash_attn.flash_attn_interface import flash_attn_unpadded_func
+    from flash_attn.bert_padding import unpad_input
+
+    use_flash_attention = True
+except ImportError:
+    try:
+        from flash_attn.flash_attn_interface import (
+            flash_attn_varlen_func as flash_attn_unpadded_func,
+        )
+        from flash_attn.bert_padding import unpad_input
+
+        use_flash_attention = True
+    except ImportError:
+        flash_attn_unpadded_func = None
+        unpad_input = None
+        use_flash_attention = False
+        print("Not use flash Attention")
+
+
+def exists(val):
+    return val is not None
+
+
+def uniq(arr):
+    return {el: True for el in arr}.keys()
+
+
+def default(val, d):
+    if exists(val):
+        return val
+    return d() if isfunction(d) else d
+
+
+def max_neg_value(t):
+    return -torch.finfo(t.dtype).max
+
+
+def init_(tensor):
+    dim = tensor.shape[-1]
+    std = 1 / math.sqrt(dim)
+    tensor.uniform_(-std, std)
+    return tensor
+
+def get_lora_params(kwargs):
+    lora_names = ["q", "k", "v", "o"]
+    lora_params = dict()
+    for lora_name in lora_names:
+        lora_use = lora_name + "_use_lora"
+        lora_r = lora_name + "_lora_r"
+        lora_alpha = lora_name + "_lora_alpha"
+        lora_params[lora_use] = kwargs.get(lora_use, False)
+        lora_params[lora_r] = kwargs.get(lora_r, 4)
+        lora_params[lora_alpha] = kwargs.get(lora_alpha, 1)
+    return lora_params    
+
+
+# feedforward
+class GEGLU(nn.Module):
+    def __init__(self, dim_in, dim_out):
+        super().__init__()
+        self.proj = nn.Linear(dim_in, dim_out * 2)
+
+    def forward(self, x):
+        x, gate = self.proj(x).chunk(2, dim=-1)
+        return x * F.gelu(gate)
+
+
+class FeedForward(nn.Module):
+    def __init__(self, dim, dim_out=None, mult=4, glu=False, dropout=0.0):
+        super().__init__()
+        inner_dim = int(dim * mult)
+        dim_out = default(dim_out, dim)
+        project_in = (
+            nn.Sequential(nn.Linear(dim, inner_dim), nn.GELU())
+            if not glu
+            else GEGLU(dim, inner_dim)
+        )
+
+        self.net = nn.Sequential(
+            project_in, nn.Dropout(dropout), nn.Linear(inner_dim, dim_out)
+        )
+
+    def forward(self, x):
+        return self.net(x)
+
+
+def zero_module(module):
+    """
+    Zero out the parameters of a module and return it.
+    """
+    for p in module.parameters():
+        p.detach().zero_()
+    return module
+
+
+def Normalize(in_channels):
+    return torch.nn.GroupNorm(
+        num_groups=32, num_channels=in_channels, eps=1e-6, affine=True
+    )
+
+
+class 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 SpatialSelfAttention(nn.Module):
+    def __init__(self, in_channels):
+        super().__init__()
+        self.in_channels = in_channels
+
+        self.norm = Normalize(in_channels)
+        self.q = torch.nn.Conv2d(
+            in_channels, in_channels, kernel_size=1, stride=1, padding=0
+        )
+        self.k = torch.nn.Conv2d(
+            in_channels, in_channels, kernel_size=1, stride=1, padding=0
+        )
+        self.v = torch.nn.Conv2d(
+            in_channels, in_channels, kernel_size=1, stride=1, padding=0
+        )
+        self.proj_out = torch.nn.Conv2d(
+            in_channels, in_channels, kernel_size=1, stride=1, padding=0
+        )
+
+    def forward(self, x):
+        h_ = x
+        h_ = self.norm(h_)
+        q = self.q(h_)
+        k = self.k(h_)
+        v = self.v(h_)
+
+        # compute attention
+        b, c, h, w = q.shape
+        q = rearrange(q, "b c h w -> b (h w) c")
+        k = rearrange(k, "b c h w -> b c (h w)")
+        w_ = torch.einsum("bij,bjk->bik", q, k)
+
+        w_ = w_ * (int(c) ** (-0.5))
+        w_ = torch.nn.functional.softmax(w_, dim=2)
+
+        # attend to values
+        v = rearrange(v, "b c h w -> b c (h w)")
+        w_ = rearrange(w_, "b i j -> b j i")
+        h_ = torch.einsum("bij,bjk->bik", v, w_)
+        h_ = rearrange(h_, "b c (h w) -> b c h w", h=h)
+        h_ = self.proj_out(h_)
+
+        return x + h_
+
+
+class FlashCrossAttention(nn.Module):
+    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 with a dimension of {dim_head}."
+        )
+        self.dropout = dropout
+        self.query_dim = query_dim
+        self.context_dim = context_dim
+        self.heads = heads
+        self.dim_head = dim_head
+
+        inner_dim = dim_head * heads
+        context_dim = default(context_dim, query_dim)
+
+        self.scale = dim_head**-0.5
+
+        lora_params = get_lora_params(kwargs)
+
+        if lora_params["q_use_lora"]:
+            self.to_q = lora.Linear(
+                query_dim, inner_dim, r=lora_params["q_lora_r"], bias=False
+            )
+        else:
+            self.to_q = nn.Linear(query_dim, inner_dim, bias=False)
+
+        if lora_params["k_use_lora"]:
+            self.to_k = lora.Linear(
+                context_dim, inner_dim, r=lora_params["k_lora_r"], bias=False
+            )
+        else:
+            self.to_k = nn.Linear(context_dim, inner_dim, bias=False)
+
+        if lora_params["v_use_lora"]:
+            self.to_v = lora.Linear(
+                context_dim, inner_dim, r=lora_params["v_lora_r"], bias=False
+            )
+        else:
+            self.to_v = nn.Linear(context_dim, inner_dim, bias=False)
+
+        if lora_params["o_use_lora"]:
+            self.to_out = nn.Sequential(
+                lora.Linear(inner_dim, query_dim, r=lora_params["o_lora_r"]),
+                nn.Dropout(dropout),
+            )
+        else:
+            self.to_out = nn.Sequential(
+                nn.Linear(inner_dim, query_dim), nn.Dropout(dropout)
+            )
+
+    def get_input(self, x, seqlen, batch_size, nheads, mask=None):
+        assert mask is None, "not implemented for mask with flash attention"
+        lengths = torch.ones([batch_size, 1], dtype=torch.int, device="cuda") * seqlen
+        attention_mask_bool = (
+            repeat(torch.arange(seqlen, device="cuda"), "s -> b s", b=batch_size)
+            < lengths
+        )
+        attention_mask = torch.zeros(
+            batch_size, seqlen, device="cuda", dtype=torch.float16
+        )
+        attention_mask[~attention_mask_bool] = -10000.0
+        attention_mask = rearrange(attention_mask, "b s -> b 1 1 s")
+        x_unpad, indices, cu_seqlens_x, max_seqlen_in_batch_x = unpad_input(
+            x, attention_mask_bool
+        )
+        x_unpad = rearrange(x_unpad, "nnz (h d) -> nnz h d", h=nheads)
+        return x_unpad.to(torch.float16), cu_seqlens_x, max_seqlen_in_batch_x
+
+    def forward(
+        self,
+        x,
+        context=None,
+        mask=None,
+        additional_tokens=None,
+        n_times_crossframe_attn_in_self=0,
+    ):
+        if additional_tokens is not None:
+            # get the number of masked tokens at the beginning of the output sequence
+            n_tokens_to_mask = additional_tokens.shape[1]
+            # add additional token
+            x = torch.cat([additional_tokens, x], dim=1)
+
+        h = self.heads
+        q = self.to_q(x)
+        context = default(context, x)
+        k = self.to_k(context)
+        v = self.to_v(context)
+
+        if n_times_crossframe_attn_in_self:
+            # reprogramming cross-frame attention as in https://arxiv.org/abs/2303.13439
+            assert x.shape[0] % n_times_crossframe_attn_in_self == 0
+            # n_cp = x.shape[0]//n_times_crossframe_attn_in_self
+            k = repeat(
+                k[::n_times_crossframe_attn_in_self],
+                "b ... -> (b n) ...",
+                n=n_times_crossframe_attn_in_self,
+            )
+            v = repeat(
+                v[::n_times_crossframe_attn_in_self],
+                "b ... -> (b n) ...",
+                n=n_times_crossframe_attn_in_self,
+            )
+
+        b, seqlen_q = q.shape[0], q.shape[1]
+        seqlen_k = k.shape[1]
+        seqlen_v = v.shape[1]
+        q, cu_seqlens_q, max_seqlen_in_batch_q = self.get_input(q, seqlen_q, b, h)
+        k, cu_seqlens_k, max_seqlen_in_batch_k = self.get_input(k, seqlen_k, b, h)
+        v, cu_seqlens_v, max_seqlen_in_batch_v = self.get_input(v, seqlen_v, b, h)
+
+        if self.training:
+            dropout_p = self.dropout
+        else:
+            dropout_p = 0
+
+        out = flash_attn_unpadded_func(
+            q,
+            k,
+            v,
+            cu_seqlens_q,
+            cu_seqlens_k,
+            max_seqlen_in_batch_q,
+            max_seqlen_in_batch_k,
+            dropout_p,
+        )
+
+        out = rearrange(out, "(b n) h d -> b n (h d)", b=b, h=h)
+        out = out.to(context.dtype)
+        if additional_tokens is not None:
+            # remove additional token
+            out = out[:, n_tokens_to_mask:]
+        out = self.to_out(out)
+        return out
+
+
+class CrossAttention(nn.Module):
+    def __init__(
+        self,
+        query_dim,
+        context_dim=None,
+        heads=8,
+        dim_head=64,
+        dropout=0.0,
+        backend=None,
+        **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)
+        )
+
+        self.backend = backend
+
+    def forward(
+        self,
+        x,
+        context=None,
+        mask=None,
+        additional_tokens=None,
+        n_times_crossframe_attn_in_self=0,
+    ):
+        h = self.heads
+
+        if additional_tokens is not None:
+            # get the number of masked tokens at the beginning of the output sequence
+            n_tokens_to_mask = additional_tokens.shape[1]
+            # add additional token
+            x = torch.cat([additional_tokens, x], dim=1)
+
+        q = self.to_q(x)
+        context = default(context, x)
+        context = context.to(self.to_k.weight.dtype)
+        k = self.to_k(context)
+        v = self.to_v(context)
+
+        if n_times_crossframe_attn_in_self:
+            # reprogramming cross-frame attention as in https://arxiv.org/abs/2303.13439
+            assert x.shape[0] % n_times_crossframe_attn_in_self == 0
+            n_cp = x.shape[0] // n_times_crossframe_attn_in_self
+            k = repeat(
+                k[::n_times_crossframe_attn_in_self], "b ... -> (b n) ...", n=n_cp
+            )
+            v = repeat(
+                v[::n_times_crossframe_attn_in_self], "b ... -> (b n) ...", n=n_cp
+            )
+
+        q, k, v = map(lambda t: rearrange(t, "b n (h d) -> b h n d", h=h), (q, k, v))
+
+        # old
+        """
+        sim = einsum('b i d, b j d -> b i j', q, k) * self.scale
+        del q, k
+
+        if exists(mask):
+            mask = rearrange(mask, 'b ... -> b (...)')
+            max_neg_value = -torch.finfo(sim.dtype).max
+            mask = repeat(mask, 'b j -> (b h) () j', h=h)
+            sim.masked_fill_(~mask, max_neg_value)
+
+        # attention, what we cannot get enough of
+        sim = sim.softmax(dim=-1)
+
+        out = einsum('b i j, b j d -> b i d', sim, v)
+        """
+        # new
+        with sdp_kernel(**BACKEND_MAP[self.backend]):
+            # print("dispatching into backend", self.backend, "q/k/v shape: ", q.shape, k.shape, v.shape)
+            out = F.scaled_dot_product_attention(
+                q, k, v, attn_mask=mask
+            )  # scale is dim_head ** -0.5 per default
+            # if self.to_q.weight.dtype == torch.float16:
+            #     q, k, v = q.to(torch.float32), k.to(torch.float32), v.to(torch.float32)
+            # elif self.to_q.weight.dtype == torch.bfloat16:
+            #     q, k, v = (
+            #         q.to(torch.bfloat16),
+            #         k.to(torch.bfloat16),
+            #         v.to(torch.bfloat16),
+            #     )
+            # out = F.scaled_dot_product_attention(q, k, v, attn_mask=mask).to(
+            #     self.to_q.weight.dtype
+            # )
+
+        del q, k, v
+        out = rearrange(out, "b h n d -> b n (h d)", h=h)
+
+        if additional_tokens is not None:
+            # remove additional token
+            out = out[:, n_tokens_to_mask:]
+        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 with a dimension of {dim_head}."
+        )
+        inner_dim = dim_head * heads
+        context_dim = default(context_dim, query_dim)
+
+        self.heads = heads
+        self.dim_head = dim_head
+
+        lora_params = get_lora_params(kwargs)
+
+        if lora_params["q_use_lora"]:
+            self.to_q = lora.Linear(
+                query_dim, inner_dim, r=lora_params["q_lora_r"], bias=False
+            )
+        else:
+            self.to_q = nn.Linear(query_dim, inner_dim, bias=False)
+
+        if lora_params["k_use_lora"]:
+            self.to_k = lora.Linear(
+                context_dim, inner_dim, r=lora_params["k_lora_r"], bias=False
+            )
+        else:
+            self.to_k = nn.Linear(context_dim, inner_dim, bias=False)
+
+        if lora_params["v_use_lora"]:
+            self.to_v = lora.Linear(
+                context_dim, inner_dim, r=lora_params["v_lora_r"], bias=False
+            )
+        else:
+            self.to_v = nn.Linear(context_dim, inner_dim, bias=False)
+
+        if lora_params["o_use_lora"]:
+            self.to_out = nn.Sequential(
+                lora.Linear(inner_dim, query_dim, r=lora_params["o_lora_r"]),
+                nn.Dropout(dropout),
+            )
+        else:
+            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,
+        additional_tokens=None,
+        n_times_crossframe_attn_in_self=0,
+    ):
+        if additional_tokens is not None:
+            # get the number of masked tokens at the beginning of the output sequence
+            n_tokens_to_mask = additional_tokens.shape[1]
+            # add additional token
+            x = torch.cat([additional_tokens, x], dim=1)
+        q = self.to_q(x)
+        context = default(context, x)
+        context = context.to(self.to_k.weight.dtype)
+        k = self.to_k(context)
+        v = self.to_v(context)
+
+        if n_times_crossframe_attn_in_self:
+            # reprogramming cross-frame attention as in https://arxiv.org/abs/2303.13439
+            assert x.shape[0] % n_times_crossframe_attn_in_self == 0
+            # n_cp = x.shape[0]//n_times_crossframe_attn_in_self
+            k = repeat(
+                k[::n_times_crossframe_attn_in_self],
+                "b ... -> (b n) ...",
+                n=n_times_crossframe_attn_in_self,
+            )
+            v = repeat(
+                v[::n_times_crossframe_attn_in_self],
+                "b ... -> (b n) ...",
+                n=n_times_crossframe_attn_in_self,
+            )
+
+        b, _, _ = q.shape
+        q, k, v = map(
+            lambda t: t.unsqueeze(3)
+            .reshape(b, t.shape[1], self.heads, self.dim_head)
+            .permute(0, 2, 1, 3)
+            .reshape(b * self.heads, t.shape[1], self.dim_head)
+            .contiguous(),
+            (q, k, v),
+        )
+
+        # actually compute the attention, what we cannot get enough of
+        # out = xformers.ops.memory_efficient_attention(
+        #     q, k, v, attn_bias=None, op=self.attention_op
+        # )
+
+        with torch.autocast(enabled=False, device_type="cuda"):
+            if self.to_q.weight.dtype == torch.float16:
+                q, k, v = q.to(torch.float32), k.to(torch.float32), v.to(torch.float32)
+            elif self.to_q.weight.dtype == torch.bfloat16:
+                q, k, v = (
+                    q.to(torch.bfloat16),
+                    k.to(torch.bfloat16),
+                    v.to(torch.bfloat16),
+                )
+            out = F.scaled_dot_product_attention(q, k, v, is_causal=False).to(
+                self.to_q.weight.dtype
+            )
+
+        # TODO: Use this directly in the attention operation, as a bias
+        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)
+        )
+        if additional_tokens is not None:
+            # remove additional token
+            out = out[:, n_tokens_to_mask:]
+        return self.to_out(out)
+
+
+class BasicTransformerBlock(nn.Module):
+    ATTENTION_MODES = {
+        "softmax": CrossAttention,  # vanilla attention
+        "flash": FlashCrossAttention,  # flash attention
+        "softmax-xformers": MemoryEfficientCrossAttention,  # ampere
+    }
+
+    def __init__(
+        self,
+        dim,
+        n_heads,
+        d_head,
+        dropout=0.0,
+        context_dim=None,
+        gated_ff=True,
+        checkpoint=True,
+        disable_self_attn=False,
+        flash_attention=False,
+        attn_mode="softmax",
+        sdp_backend=None,
+        **kwargs,
+    ):
+        super().__init__()
+        assert attn_mode in self.ATTENTION_MODES
+        if use_flash_attention and flash_attention:
+            attn_mode = "flash"
+        else:
+            if attn_mode != "softmax" and not XFORMERS_IS_AVAILABLE:
+                print(
+                    f"Attention mode '{attn_mode}' is not available. Falling back to native attention. "
+                    f"This is not a problem in Pytorch >= 2.0. FYI, you are running with PyTorch version {torch.__version__}"
+                )
+                attn_mode = "softmax"
+            elif attn_mode == "softmax" and not SDP_IS_AVAILABLE:
+                print(
+                    "We do not support vanilla attention anymore, as it is too expensive. Sorry."
+                )
+                if not XFORMERS_IS_AVAILABLE:
+                    assert (
+                        False
+                    ), "Please install xformers via e.g. 'pip install xformers==0.0.16'"
+                else:
+                    print("Falling back to xformers efficient attention.")
+                    attn_mode = "softmax-xformers"
+        attn_cls = self.ATTENTION_MODES[attn_mode]
+        if version.parse(torch.__version__) >= version.parse("2.0.0"):
+            assert sdp_backend is None or isinstance(sdp_backend, SDPBackend)
+        else:
+            assert sdp_backend is None
+        self.disable_self_attn = disable_self_attn
+        self.attn1 = attn_cls(
+            query_dim=dim,
+            heads=n_heads,
+            dim_head=d_head,
+            dropout=dropout,
+            context_dim=context_dim if self.disable_self_attn else None,
+            backend=sdp_backend,
+            **kwargs,
+        )  # is a self-attention if not self.disable_self_attn
+        self.ff = FeedForward(dim, dropout=dropout, glu=gated_ff)
+        self.attn2 = attn_cls(
+            query_dim=dim,
+            context_dim=context_dim,
+            heads=n_heads,
+            dim_head=d_head,
+            dropout=dropout,
+            backend=sdp_backend,
+            **kwargs,
+        )  # is self-attn if context is none
+        self.norm1 = nn.LayerNorm(dim)
+        self.norm2 = nn.LayerNorm(dim)
+        self.norm3 = nn.LayerNorm(dim)
+        self.checkpoint = checkpoint
+        if self.checkpoint:
+            print(f"{self.__class__.__name__} is using checkpointing")
+
+    def forward(
+        self, x, context=None, additional_tokens=None, n_times_crossframe_attn_in_self=0
+    ):
+        kwargs = {"x": x}
+
+        if context is not None:
+            kwargs.update({"context": context})
+
+        if additional_tokens is not None:
+            kwargs.update({"additional_tokens": additional_tokens})
+
+        if n_times_crossframe_attn_in_self:
+            kwargs.update(
+                {"n_times_crossframe_attn_in_self": n_times_crossframe_attn_in_self}
+            )
+
+        # return mixed_checkpoint(self._forward, kwargs, self.parameters(), self.checkpoint)
+        return checkpoint(
+            self._forward, (x, context), self.parameters(), self.checkpoint
+        )
+
+    def _forward(
+        self, x, context=None, additional_tokens=None, n_times_crossframe_attn_in_self=0
+    ):
+        x = (
+            self.attn1(
+                self.norm1(x),
+                context=context if self.disable_self_attn else None,
+                additional_tokens=additional_tokens,
+                n_times_crossframe_attn_in_self=n_times_crossframe_attn_in_self
+                if not self.disable_self_attn
+                else 0,
+            )
+            + x
+        )
+        x = (
+            self.attn2(
+                self.norm2(x), context=context, additional_tokens=additional_tokens
+            )
+            + x
+        )
+        x = self.ff(self.norm3(x)) + x
+        return x
+
+
+class BasicTransformerSingleLayerBlock(nn.Module):
+    ATTENTION_MODES = {
+        "softmax": CrossAttention,  # vanilla attention
+        # on the A100s not quite as fast as the above version
+        "softmax-xformers": MemoryEfficientCrossAttention
+        # (todo might depend on head_dim, check, falls back to semi-optimized kernels for dim!=[16,32,64,128])
+    }
+
+    def __init__(
+        self,
+        dim,
+        n_heads,
+        d_head,
+        dropout=0.0,
+        context_dim=None,
+        gated_ff=True,
+        checkpoint=True,
+        attn_mode="softmax-xformers",
+    ):
+        super().__init__()
+        assert attn_mode in self.ATTENTION_MODES
+        attn_cls = self.ATTENTION_MODES[attn_mode]
+        self.attn1 = attn_cls(
+            query_dim=dim,
+            heads=n_heads,
+            dim_head=d_head,
+            dropout=dropout,
+            context_dim=context_dim,
+        )
+        self.ff = FeedForward(dim, dropout=dropout, glu=gated_ff)
+        self.norm1 = nn.LayerNorm(dim)
+        self.norm2 = nn.LayerNorm(dim)
+        self.checkpoint = checkpoint
+
+    def forward(self, x, context=None):
+        return checkpoint(
+            self._forward, (x, context), self.parameters(), self.checkpoint
+        )
+
+    def _forward(self, x, context=None):
+        x = self.attn1(self.norm1(x), context=context) + x
+        x = self.ff(self.norm2(x)) + x
+        return x
+
+
+class SpatialTransformer(nn.Module):
+    """
+    Transformer block for image-like data.
+    First, project the input (aka embedding)
+    and reshape to b, t, d.
+    Then apply standard transformer action.
+    Finally, reshape to image
+    NEW: use_linear for more efficiency instead of the 1x1 convs
+    """
+
+    def __init__(
+        self,
+        in_channels,
+        n_heads,
+        d_head,
+        depth=1,
+        dropout=0.0,
+        context_dim=None,
+        disable_self_attn=False,
+        use_linear=False,
+        attn_type="softmax-xformers",
+        use_checkpoint=True,
+        sdp_backend=None,
+        **kwargs,
+    ):
+        super().__init__()
+        print(
+            f"constructing {self.__class__.__name__} of depth {depth} w/ {in_channels} channels and {n_heads} heads"
+        )
+        from omegaconf import ListConfig
+
+        if exists(context_dim) and not isinstance(context_dim, (list, ListConfig)):
+            context_dim = [context_dim]
+        if exists(context_dim) and isinstance(context_dim, list):
+            if depth != len(context_dim):
+                print(
+                    f"WARNING: {self.__class__.__name__}: Found context dims {context_dim} of depth {len(context_dim)}, "
+                    f"which does not match the specified 'depth' of {depth}. Setting context_dim to {depth * [context_dim[0]]} now."
+                )
+                # depth does not match context dims.
+                assert all(
+                    map(lambda x: x == context_dim[0], context_dim)
+                ), "need homogenous context_dim to match depth automatically"
+                context_dim = depth * [context_dim[0]]
+        elif context_dim is None:
+            context_dim = [None] * depth
+        self.in_channels = in_channels
+        inner_dim = n_heads * d_head
+        self.norm = Normalize(in_channels)
+        if not use_linear:
+            self.proj_in = nn.Conv2d(
+                in_channels, inner_dim, kernel_size=1, stride=1, padding=0
+            )
+        else:
+            self.proj_in = nn.Linear(in_channels, inner_dim)
+
+        disable_text_ca = kwargs.get("disable_text_ca", False)
+        self.disable_text_ca = disable_text_ca
+        if disable_text_ca:
+            self.transformer_blocks = nn.ModuleList(
+                [
+                    # BasicTransformerBlock(  # temporal transformer does not use flash attention
+                    BasicTransformerSingleLayerBlock(  # temporal transformer does not use flash attention
+                        inner_dim,
+                        n_heads,
+                        d_head,
+                        dropout=dropout,
+                        # context_dim=context_dim[d],
+                        context_dim=None,
+                        attn_mode="softmax",
+                        checkpoint=use_checkpoint,
+                    )
+                    for d in range(depth)
+                ]
+            )
+        else:
+            self.transformer_blocks = nn.ModuleList(
+                [
+                    BasicTransformerBlock(
+                        inner_dim,
+                        n_heads,
+                        d_head,
+                        dropout=dropout,
+                        context_dim=context_dim[d],
+                        disable_self_attn=disable_self_attn,
+                        attn_mode=attn_type,
+                        checkpoint=use_checkpoint,
+                        sdp_backend=sdp_backend,
+                    )
+                    for d in range(depth)
+                ]
+            )
+        if not use_linear:
+            self.proj_out = zero_module(
+                nn.Conv2d(inner_dim, in_channels, kernel_size=1, stride=1, padding=0)
+            )
+        else:
+            # self.proj_out = zero_module(nn.Linear(in_channels, inner_dim))
+            self.proj_out = zero_module(nn.Linear(inner_dim, in_channels))
+        self.use_linear = use_linear
+
+    def forward(self, x, context=None):
+        # note: if no context is given, cross-attention defaults to self-attention
+        if not isinstance(context, list):
+            context = [context]
+        b, c, h, w = x.shape
+        x_in = x
+        x = self.norm(x)
+        if not self.use_linear:
+            x = self.proj_in(x)
+        x = rearrange(x, "b c h w -> b (h w) c").contiguous()
+        if self.use_linear:
+            x = self.proj_in(x)
+        for i, block in enumerate(self.transformer_blocks):
+            if i > 0 and len(context) == 1:
+                i = 0  # use same context for each block
+            if self.disable_text_ca:
+                x = block(x, context=x)
+            else:
+                x = block(x, context=context[i])
+        if self.use_linear:
+            x = self.proj_out(x)
+        x = rearrange(x, "b (h w) c -> b c h w", h=h, w=w).contiguous()
+        if not self.use_linear:
+            x = self.proj_out(x)
+        return x + x_in
+
+
+class SpatialTransformerCA(SpatialTransformer):
+    """
+    This is hacked from SpatialTransformer.
+    Conduct additional cross-attention with k,v from the reference feature.
+    Thus, the attention order is text cross-attention -> sptial self-attention -> reference cross-attention.
+    Note that if the reference feature is not given, this module is equivalent to SpatialTransformer.
+
+
+    Transformer block for image-like data.
+    First, project the input (aka embedding)
+    and reshape to b, t, d.
+    Then apply standard transformer action.
+    Finally, reshape to image
+    NEW: use_linear for more efficiency instead of the 1x1 convs
+    """
+
+    def __init__(
+        self,
+        in_channels,
+        n_heads,
+        d_head,
+        depth=1,
+        dropout=0.0,
+        context_dim=None,
+        disable_self_attn=False,
+        use_linear=False,
+        attn_type="softmax-xformers",
+        use_checkpoint=True,
+        sdp_backend=None,
+        **kwargs,
+    ):
+        super().__init__(
+            in_channels,
+            n_heads,
+            d_head,
+            depth,
+            dropout,
+            context_dim,
+            disable_self_attn,
+            use_linear,
+            attn_type,
+            use_checkpoint,
+            sdp_backend,
+            **kwargs,
+        )
+        inner_dim = n_heads * d_head
+
+        # temporal crossattention part
+        self.norm_ca = Normalize(in_channels)
+        if not use_linear:
+            self.proj_in_ca = nn.Conv2d(
+                in_channels, inner_dim, kernel_size=1, stride=1, padding=0
+            )
+        else:
+            self.proj_in_ca = nn.Linear(in_channels, inner_dim)
+        self.transformer_blocks_ca = nn.ModuleList(
+            [
+                BasicTransformerSingleLayerBlock( 
+                    inner_dim,
+                    n_heads,
+                    d_head,
+                    dropout=dropout,
+                    context_dim=None,
+                    attn_mode=attn_type,
+                    checkpoint=use_checkpoint,
+                )
+                for d in range(depth)
+            ]
+        )
+        if not use_linear:
+            self.proj_out_ca = zero_module(
+                nn.Conv2d(inner_dim, in_channels, kernel_size=1, stride=1, padding=0)
+            )
+        else:
+            self.proj_out_ca = zero_module(nn.Linear(inner_dim, in_channels))
+
+    def forward(self, x, context=None):
+        x = super().forward(x, context)
+
+        assert hasattr(self, 'ref_control'), "must have ref_control"
+        ref_control = self.ref_control
+
+        b, c, h, w = x.shape
+        # cross-frame attention
+        # x = rearrange(x, "b c t h w -> (b t) c h w").contiguous()
+        x_in = x
+        x = self.norm_ca(x)
+        if not self.use_linear:
+            x = self.proj_in_ca(x)
+        x = rearrange(x, "b c h w -> b (h w) c").contiguous()
+        if self.use_linear:
+            x = self.proj_in_ca(x)
+
+        for i, block in enumerate(self.transformer_blocks_ca):
+            ref_control = rearrange(ref_control, "b c h w -> b (h w) c").contiguous()
+            context_texture = ref_control
+            x = block(x, context_texture)
+
+        if self.use_linear:
+            x = self.proj_out_ca(x)
+        x = rearrange(x, "b (h w) c -> b c h w", h=h, w=w).contiguous()
+        if not self.use_linear:
+            x = self.proj_out_ca(x)
+        x = x + x_in
+
+        return x
+
+
+class SpatialTransformer3D(nn.Module):
+    """
+    This is hacked from the 2D version above.
+
+    Transformer block for video-like data.
+    First, project the input (aka embedding)
+    and reshape to b, t, d.
+    Then apply standard transformer action.
+    Finally, reshape to image
+    NEW: use_linear for more efficiency instead of the 1x1 convs
+    """
+
+    def __init__(
+        self,
+        in_channels,
+        n_heads,
+        d_head,
+        depth=1,
+        dropout=0.0,
+        context_dim=None,
+        disable_self_attn=False,
+        use_linear=False,
+        attn_type="softmax-xformers",
+        use_checkpoint=True,
+        sdp_backend=None,
+        **kwargs,
+    ):
+        super().__init__()
+        print(
+            f"constructing {self.__class__.__name__} of depth {depth} w/ {in_channels} channels and {n_heads} heads"
+        )
+        from omegaconf import ListConfig
+
+        if exists(context_dim) and not isinstance(context_dim, (list, ListConfig)):
+            context_dim = [context_dim]
+        if exists(context_dim) and isinstance(context_dim, list):
+            if depth != len(context_dim):
+                print(
+                    f"WARNING: {self.__class__.__name__}: Found context dims {context_dim} of depth {len(context_dim)}, "
+                    f"which does not match the specified 'depth' of {depth}. Setting context_dim to {depth * [context_dim[0]]} now."
+                )
+                # depth does not match context dims.
+                assert all(
+                    map(lambda x: x == context_dim[0], context_dim)
+                ), "need homogenous context_dim to match depth automatically"
+                context_dim = depth * [context_dim[0]]
+        elif context_dim is None:
+            context_dim = [None] * depth
+        self.in_channels = in_channels
+        inner_dim = n_heads * d_head
+        self.norm = Normalize(in_channels)
+        if not use_linear:
+            self.proj_in = nn.Conv2d(
+                in_channels, inner_dim, kernel_size=1, stride=1, padding=0
+            )
+        else:
+            self.proj_in = nn.Linear(in_channels, inner_dim)
+
+        self.transformer_blocks = nn.ModuleList(
+            [
+                BasicTransformerBlock(
+                    inner_dim,
+                    n_heads,
+                    d_head,
+                    dropout=dropout,
+                    context_dim=context_dim[d],
+                    disable_self_attn=disable_self_attn,
+                    attn_mode=attn_type,
+                    checkpoint=use_checkpoint,
+                    sdp_backend=sdp_backend,
+                    flash_attention=True,
+                    **kwargs,
+                )
+                for d in range(depth)
+            ]
+        )
+        if not use_linear:
+            self.proj_out = zero_module(
+                nn.Conv2d(inner_dim, in_channels, kernel_size=1, stride=1, padding=0)
+            )
+        else:
+            self.proj_out = zero_module(nn.Linear(inner_dim, in_channels))
+        self.use_linear = use_linear
+
+        # temporal part
+        self.norm_temporal = Normalize(in_channels)
+        if not use_linear:
+            self.proj_in_temporal = zero_module(
+                nn.Conv1d(in_channels, inner_dim, kernel_size=1, stride=1, padding=0)
+            )
+        else:
+            self.proj_in_temporal = zero_module(nn.Linear(in_channels, inner_dim))
+        disable_temporal_text_ca = kwargs.get("disable_temporal_text_ca", False)
+        self.disable_temporal_text_ca = disable_temporal_text_ca
+        if disable_temporal_text_ca:
+            self.transformer_blocks_temporal = nn.ModuleList(
+                [
+                    # BasicTransformerBlock(  # temporal transformer does not use flash attention
+                    BasicTransformerSingleLayerBlock(  # temporal transformer does not use flash attention
+                        inner_dim,
+                        n_heads,
+                        d_head,
+                        dropout=dropout,
+                        # context_dim=context_dim[d],
+                        context_dim=None,
+                        attn_mode="softmax",
+                        checkpoint=use_checkpoint,
+                    )
+                    for d in range(depth)
+                ]
+            )
+        else:
+            self.transformer_blocks_temporal = nn.ModuleList(
+                [
+                    BasicTransformerBlock(  # temporal transformer does not use flash attention
+                        inner_dim,
+                        n_heads,
+                        d_head,
+                        dropout=dropout,
+                        context_dim=context_dim[d],
+                        disable_self_attn=disable_self_attn,
+                        attn_mode="softmax",
+                        checkpoint=use_checkpoint,
+                        sdp_backend=sdp_backend,
+                    )
+                    for d in range(depth)
+                ]
+            )
+        if not use_linear:
+            self.proj_out_temporal = zero_module(
+                nn.Conv1d(inner_dim, in_channels, kernel_size=1, stride=1, padding=0)
+            )
+        else:
+            self.proj_out_temporal = zero_module(nn.Linear(inner_dim, in_channels))
+
+        use_learnable_alpha = kwargs.get("use_learnable_alpha", False)
+        if use_learnable_alpha:
+            self.alpha_temporal = nn.Parameter(
+                torch.ones(1)
+            )  # x = alpha * spatial + (1-alpha) * temporal
+
+    def forward(self, x, context=None):
+        # note: if no context is given, cross-attention defaults to self-attention
+        if not isinstance(context, list):
+            context = [context]
+        b, c, t, h, w = x.shape
+        # spatial attention
+        x = rearrange(x, "b c t h w -> (b t) c h w").contiguous()
+        x_in = x
+        x = self.norm(x)
+        if not self.use_linear:
+            x = self.proj_in(x)
+        x = rearrange(x, "bt c h w -> bt (h w) c").contiguous()
+        if self.use_linear:
+            x = self.proj_in(x)
+
+        for i, block in enumerate(self.transformer_blocks):
+            if i > 0 and len(context) == 1:
+                i = 0
+            context_i = (
+                repeat(context[i], "b l c -> (b t) l c", t=t).contiguous()
+                if context[i] is not None
+                else None
+            )
+            x = block(x, context=context_i)
+        if self.use_linear:
+            x = self.proj_out(x)
+        x = rearrange(x, "bt (h w) c -> bt c h w", h=h, w=w).contiguous()
+        if not self.use_linear:
+            x = self.proj_out(x)
+        x = x + x_in
+
+        x = rearrange(x, "(b t) c h w -> (b h w) c t", t=t).contiguous()
+        # temporal attention
+        if hasattr(self, "norm_temporal"):  # temporal operation exist
+            x_in = x
+            x = self.norm_temporal(x)
+            if not self.use_linear:
+                x = self.proj_in_temporal(x)
+            x = rearrange(x, "bhw c t->bhw t c").contiguous()
+            if self.use_linear:
+                x = self.proj_in_temporal(x)
+            for i, block in enumerate(self.transformer_blocks_temporal):
+                if i > 0 and len(context) == 1:
+                    i = 0  # use same context for each block
+                # if context[i] != None:
+                context_i = (
+                    repeat(context[i], "b l c -> (b h w) l c", h=h, w=w).contiguous()
+                    if context[i] is not None
+                    else None
+                )
+                if self.disable_temporal_text_ca:
+                    x = block(x, context=x)
+                else:
+                    x = block(x, context=context_i)
+
+            if self.use_linear: 
+                x = self.proj_out_temporal(x)
+            x = rearrange(x, "bhw t c -> bhw c t").contiguous()
+            if not self.use_linear:
+                x = self.proj_out_temporal(x)
+            if hasattr(self, "alpha_temporal"):
+                x = self.alpha_temporal * x_in + (1 - self.alpha_temporal) * x
+            else:
+                x = x_in + x
+            # x = x_in    # ! DEBUG ONLY
+
+        x = rearrange(x, "(b h w) c t -> b c t h w", h=h, w=w).contiguous()
+        return x
+
+
+class SpatialTransformer3DCA(SpatialTransformer3D):
+    """
+    # -> SpatialTransformer3DCrossAttention
+    # Replace the second temporal attention in SpatialTransformer3D with cross-attention
+    # Original attention order:
+    # 1. spatial self-attention
+    # 2. cross-attention with text condition
+    # 3. temporal self-attention (1d)
+    # 4. cross-attention with text condition
+    # Attention order: 
+    # 1. spatial self-attention
+    # 2. cross-attention with text condition
+    # 3. temporal self-attention (1d)
+    # 4. cross-attention with text condition (maybe not necessary, but... nevermind)
+    # 5. cross-attention with anchor frame (usually center frame, or reference image from outside)
+
+    This is hacked from the 2D version above.
+
+    Transformer block for video-like data.
+    First, project the input (aka embedding)
+    and reshape to b, t, d.
+    Then apply standard transformer action.
+    Finally, reshape to image
+    NEW: use_linear for more efficiency instead of the 1x1 convs
+    """
+
+    def __init__(
+        self,
+        in_channels,
+        n_heads,
+        d_head,
+        depth=1,
+        dropout=0.0,
+        context_dim=None,
+        disable_self_attn=False,
+        use_linear=False,
+        attn_type="softmax-xformers",
+        use_checkpoint=True,
+        sdp_backend=None,
+        **kwargs,
+    ):
+        # super().__init__(**kwargs)
+        super().__init__(
+            in_channels,
+            n_heads,
+            d_head,
+            depth=depth,
+            dropout=dropout,
+            context_dim=context_dim,
+            disable_self_attn=disable_self_attn,
+            use_linear=use_linear,
+            attn_type=attn_type,
+            use_checkpoint=use_checkpoint,
+            sdp_backend=sdp_backend,
+            **kwargs,
+        )
+
+        inner_dim = n_heads * d_head
+
+        # temporal crossattention part
+        self.norm_temporal_ca = Normalize(in_channels)
+        if not use_linear:
+            self.proj_in_temporal_ca = nn.Conv2d(
+                in_channels, inner_dim, kernel_size=1, stride=1, padding=0
+            )
+        else:
+            self.proj_in_temporal_ca = nn.Linear(in_channels, inner_dim)
+        self.transformer_blocks_temporal_ca = nn.ModuleList(
+            [
+                BasicTransformerSingleLayerBlock( 
+                    inner_dim,
+                    n_heads,
+                    d_head,
+                    dropout=dropout,
+                    context_dim=None,
+                    attn_mode=attn_type,
+                    checkpoint=use_checkpoint,
+                )
+                for d in range(depth)
+            ]
+        )
+        if not use_linear:
+            self.proj_out_temporal_ca = zero_module(
+                nn.Conv2d(inner_dim, in_channels, kernel_size=1, stride=1, padding=0)
+            )
+        else:
+            self.proj_out_temporal_ca = zero_module(nn.Linear(inner_dim, in_channels))
+
+        self.ST3DCA_ca_type = kwargs.get("ST3DCA_ca_type", "center")
+        assert self.ST3DCA_ca_type in ["center", 'self', 'center_self']
+
+    def forward(self, x, context=None):
+        x = super().forward(x, context)
+
+        # note: if no context is given, cross-attention defaults to self-attention
+        if not isinstance(context, list):
+            context = [context]
+        b, c, t, h, w = x.shape
+        # cross-frame attention
+        x = rearrange(x, "b c t h w -> (b t) c h w").contiguous()
+        x_in = x
+        x = self.norm_temporal_ca(x)
+        if not self.use_linear:
+            x = self.proj_in_temporal_ca(x)
+        x = rearrange(x, "bt c h w -> bt (h w) c").contiguous()
+        if self.use_linear:
+            x = self.proj_in_temporal_ca(x)
+
+        for i, block in enumerate(self.transformer_blocks_temporal_ca):
+            if i > 0 and len(context) == 1:
+                i = 0
+            # # center frame as anchor
+            x = rearrange(x, "(b t) hw c -> b t hw c", b=b).contiguous()
+            attn_anchor_frame_idx = t // 2  # center frame
+            anchor_frame = x[:, attn_anchor_frame_idx, :, :].contiguous()
+            anchor_frame = repeat(anchor_frame, "b hw c -> b t hw c", t=t).contiguous()
+            anchor_frame = rearrange(anchor_frame, "b t hw c -> (b t) hw c").contiguous()
+            context_texture = anchor_frame
+            x = rearrange(x, "b t hw c -> (b t) hw c", b=b).contiguous()
+            if self.ST3DCA_ca_type == 'center':
+                x = block(x, context=context_texture)
+            elif self.ST3DCA_ca_type == 'self':
+                x = block(x, context=x)
+            elif self.ST3DCA_ca_type == 'center_self':
+                context_texture = torch.cat([context_texture, x], dim=1)
+                x = block(x, context=context_texture)
+            else:
+                raise NotImplementedError
+            # x = block(x, context_texture)
+
+        if self.use_linear:
+            x = self.proj_out_temporal_ca(x)
+        x = rearrange(x, "bt (h w) c -> bt c h w", h=h, w=w).contiguous()
+        if not self.use_linear:
+            x = self.proj_out_temporal_ca(x)
+        x = x + x_in
+
+        x = rearrange(x, "(b t) c h w -> b c t h w", b=b, t=t).contiguous()
+
+        return x
+
+
+def benchmark_attn():
+    # Lets define a helpful benchmarking function:
+    # https://pytorch.org/tutorials/intermediate/scaled_dot_product_attention_tutorial.html
+    device = "cuda" if torch.cuda.is_available() else "cpu"
+    import torch.nn.functional as F
+    import torch.utils.benchmark as benchmark
+
+    def benchmark_torch_function_in_microseconds(f, *args, **kwargs):
+        t0 = benchmark.Timer(
+            stmt="f(*args, **kwargs)", globals={"args": args, "kwargs": kwargs, "f": f}
+        )
+        return t0.blocked_autorange().mean * 1e6
+
+    # Lets define the hyper-parameters of our input
+    batch_size = 32
+    max_sequence_len = 1024
+    num_heads = 32
+    embed_dimension = 32
+
+    dtype = torch.float16
+
+    query = torch.rand(
+        batch_size,
+        num_heads,
+        max_sequence_len,
+        embed_dimension,
+        device=device,
+        dtype=dtype,
+    )
+    key = torch.rand(
+        batch_size,
+        num_heads,
+        max_sequence_len,
+        embed_dimension,
+        device=device,
+        dtype=dtype,
+    )
+    value = torch.rand(
+        batch_size,
+        num_heads,
+        max_sequence_len,
+        embed_dimension,
+        device=device,
+        dtype=dtype,
+    )
+
+    print(f"q/k/v shape:", query.shape, key.shape, value.shape)
+
+    # Lets explore the speed of each of the 3 implementations
+    from torch.backends.cuda import SDPBackend, sdp_kernel
+
+    # Helpful arguments mapper
+    backend_map = {
+        SDPBackend.MATH: {
+            "enable_math": True,
+            "enable_flash": False,
+            "enable_mem_efficient": False,
+        },
+        SDPBackend.FLASH_ATTENTION: {
+            "enable_math": False,
+            "enable_flash": True,
+            "enable_mem_efficient": False,
+        },
+        SDPBackend.EFFICIENT_ATTENTION: {
+            "enable_math": False,
+            "enable_flash": False,
+            "enable_mem_efficient": True,
+        },
+    }
+
+    from torch.profiler import ProfilerActivity, profile, record_function
+
+    activities = [ProfilerActivity.CPU, ProfilerActivity.CUDA]
+
+    print(
+        f"The default implementation runs in {benchmark_torch_function_in_microseconds(F.scaled_dot_product_attention, query, key, value):.3f} microseconds"
+    )
+    with profile(
+        activities=activities, record_shapes=False, profile_memory=True
+    ) as prof:
+        with record_function("Default detailed stats"):
+            for _ in range(25):
+                o = F.scaled_dot_product_attention(query, key, value)
+    print(prof.key_averages().table(sort_by="cuda_time_total", row_limit=10))
+
+    print(
+        f"The math implementation runs in {benchmark_torch_function_in_microseconds(F.scaled_dot_product_attention, query, key, value):.3f} microseconds"
+    )
+    with sdp_kernel(**backend_map[SDPBackend.MATH]):
+        with profile(
+            activities=activities, record_shapes=False, profile_memory=True
+        ) as prof:
+            with record_function("Math implmentation stats"):
+                for _ in range(25):
+                    o = F.scaled_dot_product_attention(query, key, value)
+        print(prof.key_averages().table(sort_by="cuda_time_total", row_limit=10))
+
+    with sdp_kernel(**backend_map[SDPBackend.FLASH_ATTENTION]):
+        try:
+            print(
+                f"The flash attention implementation runs in {benchmark_torch_function_in_microseconds(F.scaled_dot_product_attention, query, key, value):.3f} microseconds"
+            )
+        except RuntimeError:
+            print("FlashAttention is not supported. See warnings for reasons.")
+        with profile(
+            activities=activities, record_shapes=False, profile_memory=True
+        ) as prof:
+            with record_function("FlashAttention stats"):
+                for _ in range(25):
+                    o = F.scaled_dot_product_attention(query, key, value)
+        print(prof.key_averages().table(sort_by="cuda_time_total", row_limit=10))
+
+    with sdp_kernel(**backend_map[SDPBackend.EFFICIENT_ATTENTION]):
+        try:
+            print(
+                f"The memory efficient implementation runs in {benchmark_torch_function_in_microseconds(F.scaled_dot_product_attention, query, key, value):.3f} microseconds"
+            )
+        except RuntimeError:
+            print("EfficientAttention is not supported. See warnings for reasons.")
+        with profile(
+            activities=activities, record_shapes=False, profile_memory=True
+        ) as prof:
+            with record_function("EfficientAttention stats"):
+                for _ in range(25):
+                    o = F.scaled_dot_product_attention(query, key, value)
+        print(prof.key_averages().table(sort_by="cuda_time_total", row_limit=10))
+
+
+def run_model(model, x, context):
+    return model(x, context)
+
+
+def benchmark_transformer_blocks():
+    device = "cuda" if torch.cuda.is_available() else "cpu"
+    import torch.utils.benchmark as benchmark
+
+    def benchmark_torch_function_in_microseconds(f, *args, **kwargs):
+        t0 = benchmark.Timer(
+            stmt="f(*args, **kwargs)", globals={"args": args, "kwargs": kwargs, "f": f}
+        )
+        return t0.blocked_autorange().mean * 1e6
+
+    checkpoint = True
+    compile = False
+
+    batch_size = 32
+    h, w = 64, 64
+    context_len = 1024
+    embed_dimension = 1024
+    context_dim = 1024
+    d_head = 64
+
+    transformer_depth = 4
+
+    n_heads = embed_dimension // d_head
+
+    dtype = torch.float16
+
+    model_native = SpatialTransformer(
+        embed_dimension,
+        n_heads,
+        d_head,
+        context_dim=context_dim,
+        use_linear=True,
+        use_checkpoint=checkpoint,
+        attn_type="softmax",
+        depth=transformer_depth,
+        sdp_backend=SDPBackend.FLASH_ATTENTION,
+    ).to(device)
+    model_efficient_attn = SpatialTransformer(
+        embed_dimension,
+        n_heads,
+        d_head,
+        context_dim=context_dim,
+        use_linear=True,
+        depth=transformer_depth,
+        use_checkpoint=checkpoint,
+        attn_type="softmax-xformers",
+    ).to(device)
+    if not checkpoint and compile:
+        print("compiling models")
+        model_native = torch.compile(model_native)
+        model_efficient_attn = torch.compile(model_efficient_attn)
+
+    x = torch.rand(batch_size, embed_dimension, h, w, device=device, dtype=dtype)
+    c = torch.rand(batch_size, context_len, context_dim, device=device, dtype=dtype)
+
+    from torch.profiler import ProfilerActivity, profile, record_function
+
+    activities = [ProfilerActivity.CPU, ProfilerActivity.CUDA]
+
+    with torch.autocast("cuda"):
+        print(
+            f"The native model runs in {benchmark_torch_function_in_microseconds(model_native.forward, x, c):.3f} microseconds"
+        )
+        print(
+            f"The efficientattn model runs in {benchmark_torch_function_in_microseconds(model_efficient_attn.forward, x, c):.3f} microseconds"
+        )
+
+        print(75 * "+")
+        print("NATIVE")
+        print(75 * "+")
+        torch.cuda.reset_peak_memory_stats()
+        with profile(
+            activities=activities, record_shapes=False, profile_memory=True
+        ) as prof:
+            with record_function("NativeAttention stats"):
+                for _ in range(25):
+                    model_native(x, c)
+        print(prof.key_averages().table(sort_by="cuda_time_total", row_limit=10))
+        print(torch.cuda.max_memory_allocated() * 1e-9, "GB used by native block")
+
+        print(75 * "+")
+        print("Xformers")
+        print(75 * "+")
+        torch.cuda.reset_peak_memory_stats()
+        with profile(
+            activities=activities, record_shapes=False, profile_memory=True
+        ) as prof:
+            with record_function("xformers stats"):
+                for _ in range(25):
+                    model_efficient_attn(x, c)
+        print(prof.key_averages().table(sort_by="cuda_time_total", row_limit=10))
+        print(torch.cuda.max_memory_allocated() * 1e-9, "GB used by xformers block")
+
+
+def test01():
+    # conv1x1 vs linear
+    from ..util import count_params
+
+    conv = nn.Conv2d(3, 32, kernel_size=1).cuda()
+    print(count_params(conv))
+    linear = torch.nn.Linear(3, 32).cuda()
+    print(count_params(linear))
+
+    print(conv.weight.shape)
+
+    # use same initialization
+    linear.weight = torch.nn.Parameter(conv.weight.squeeze(-1).squeeze(-1))
+    linear.bias = torch.nn.Parameter(conv.bias)
+
+    print(linear.weight.shape)
+
+    x = torch.randn(11, 3, 64, 64).cuda()
+
+    xr = rearrange(x, "b c h w -> b (h w) c").contiguous()
+    print(xr.shape)
+    out_linear = linear(xr)
+    print(out_linear.mean(), out_linear.shape)
+
+    out_conv = conv(x)
+    print(out_conv.mean(), out_conv.shape)
+    print("done with test01.\n")
+
+
+def test02():
+    # try cosine flash attention
+    import time
+
+    torch.backends.cuda.matmul.allow_tf32 = True
+    torch.backends.cudnn.allow_tf32 = True
+    torch.backends.cudnn.benchmark = True
+    print("testing cosine flash attention...")
+    DIM = 1024
+    SEQLEN = 4096
+    BS = 16
+
+    print(" softmax (vanilla) first...")
+    model = BasicTransformerBlock(
+        dim=DIM,
+        n_heads=16,
+        d_head=64,
+        dropout=0.0,
+        context_dim=None,
+        attn_mode="softmax",
+    ).cuda()
+    try:
+        x = torch.randn(BS, SEQLEN, DIM).cuda()
+        tic = time.time()
+        y = model(x)
+        toc = time.time()
+        print(y.shape, toc - tic)
+    except RuntimeError as e:
+        # likely oom
+        print(str(e))
+
+    print("\n now softmax-xformer ...")
+    model = BasicTransformerBlock(
+        dim=DIM,
+        n_heads=16,
+        d_head=64,
+        dropout=0.0,
+        context_dim=None,
+        attn_mode="softmax-xformers",
+    ).cuda()
+    x = torch.randn(BS, SEQLEN, DIM).cuda()
+    tic = time.time()
+    y = model(x)
+    toc = time.time()
+    print(y.shape, toc - tic)
+    print("done with test02.\n")
+
+
+if __name__ == "__main__":
+    test01()
+    test02()
+
+    benchmark_attn()
+    # benchmark_transformer_blocks()
+
+    print("done.")

CCEdit-main/sgm/modules/autoencoding/losses/__init__.py

@@ -0,0 +1,246 @@
+from typing import Any, Union
+
+import torch
+import torch.nn as nn
+from einops import rearrange
+from taming.modules.discriminator.model import NLayerDiscriminator, weights_init
+from taming.modules.losses.lpips import LPIPS
+from taming.modules.losses.vqperceptual import hinge_d_loss, vanilla_d_loss
+
+from ....util import default, instantiate_from_config
+
+
+def adopt_weight(weight, global_step, threshold=0, value=0.0):
+    if global_step < threshold:
+        weight = value
+    return weight
+
+
+class LatentLPIPS(nn.Module):
+    def __init__(
+        self,
+        decoder_config,
+        perceptual_weight=1.0,
+        latent_weight=1.0,
+        scale_input_to_tgt_size=False,
+        scale_tgt_to_input_size=False,
+        perceptual_weight_on_inputs=0.0,
+    ):
+        super().__init__()
+        self.scale_input_to_tgt_size = scale_input_to_tgt_size
+        self.scale_tgt_to_input_size = scale_tgt_to_input_size
+        self.init_decoder(decoder_config)
+        self.perceptual_loss = LPIPS().eval()
+        self.perceptual_weight = perceptual_weight
+        self.latent_weight = latent_weight
+        self.perceptual_weight_on_inputs = perceptual_weight_on_inputs
+
+    def init_decoder(self, config):
+        self.decoder = instantiate_from_config(config)
+        if hasattr(self.decoder, "encoder"):
+            del self.decoder.encoder
+
+    def forward(self, latent_inputs, latent_predictions, image_inputs, split="train"):
+        log = dict()
+        loss = (latent_inputs - latent_predictions) ** 2
+        log[f"{split}/latent_l2_loss"] = loss.mean().detach()
+        image_reconstructions = None
+        if self.perceptual_weight > 0.0:
+            image_reconstructions = self.decoder.decode(latent_predictions)
+            image_targets = self.decoder.decode(latent_inputs)
+            perceptual_loss = self.perceptual_loss(
+                image_targets.contiguous(), image_reconstructions.contiguous()
+            )
+            loss = (
+                self.latent_weight * loss.mean()
+                + self.perceptual_weight * perceptual_loss.mean()
+            )
+            log[f"{split}/perceptual_loss"] = perceptual_loss.mean().detach()
+
+        if self.perceptual_weight_on_inputs > 0.0:
+            image_reconstructions = default(
+                image_reconstructions, self.decoder.decode(latent_predictions)
+            )
+            if self.scale_input_to_tgt_size:
+                image_inputs = torch.nn.functional.interpolate(
+                    image_inputs,
+                    image_reconstructions.shape[2:],
+                    mode="bicubic",
+                    antialias=True,
+                )
+            elif self.scale_tgt_to_input_size:
+                image_reconstructions = torch.nn.functional.interpolate(
+                    image_reconstructions,
+                    image_inputs.shape[2:],
+                    mode="bicubic",
+                    antialias=True,
+                )
+
+            perceptual_loss2 = self.perceptual_loss(
+                image_inputs.contiguous(), image_reconstructions.contiguous()
+            )
+            loss = loss + self.perceptual_weight_on_inputs * perceptual_loss2.mean()
+            log[f"{split}/perceptual_loss_on_inputs"] = perceptual_loss2.mean().detach()
+        return loss, log
+
+
+class GeneralLPIPSWithDiscriminator(nn.Module):
+    def __init__(
+        self,
+        disc_start: int,
+        logvar_init: float = 0.0,
+        pixelloss_weight=1.0,
+        disc_num_layers: int = 3,
+        disc_in_channels: int = 3,
+        disc_factor: float = 1.0,
+        disc_weight: float = 1.0,
+        perceptual_weight: float = 1.0,
+        disc_loss: str = "hinge",
+        scale_input_to_tgt_size: bool = False,
+        dims: int = 2,
+        learn_logvar: bool = False,
+        regularization_weights: Union[None, dict] = None,
+    ):
+        super().__init__()
+        self.dims = dims
+        if self.dims > 2:
+            print(
+                f"running with dims={dims}. This means that for perceptual loss calculation, "
+                f"the LPIPS loss will be applied to each frame independently. "
+            )
+        self.scale_input_to_tgt_size = scale_input_to_tgt_size
+        assert disc_loss in ["hinge", "vanilla"]
+        self.pixel_weight = pixelloss_weight
+        self.perceptual_loss = LPIPS().eval()
+        self.perceptual_weight = perceptual_weight
+        # output log variance
+        self.logvar = nn.Parameter(torch.ones(size=()) * logvar_init)
+        self.learn_logvar = learn_logvar
+
+        self.discriminator = NLayerDiscriminator(
+            input_nc=disc_in_channels, n_layers=disc_num_layers, use_actnorm=False
+        ).apply(weights_init)
+        self.discriminator_iter_start = disc_start
+        self.disc_loss = hinge_d_loss if disc_loss == "hinge" else vanilla_d_loss
+        self.disc_factor = disc_factor
+        self.discriminator_weight = disc_weight
+        self.regularization_weights = default(regularization_weights, {})
+
+    def get_trainable_parameters(self) -> Any:
+        return self.discriminator.parameters()
+
+    def get_trainable_autoencoder_parameters(self) -> Any:
+        if self.learn_logvar:
+            yield self.logvar
+        yield from ()
+
+    def calculate_adaptive_weight(self, nll_loss, g_loss, last_layer=None):
+        if last_layer is not None:
+            nll_grads = torch.autograd.grad(nll_loss, last_layer, retain_graph=True)[0]
+            g_grads = torch.autograd.grad(g_loss, last_layer, retain_graph=True)[0]
+        else:
+            nll_grads = torch.autograd.grad(
+                nll_loss, self.last_layer[0], retain_graph=True
+            )[0]
+            g_grads = torch.autograd.grad(
+                g_loss, self.last_layer[0], retain_graph=True
+            )[0]
+
+        d_weight = torch.norm(nll_grads) / (torch.norm(g_grads) + 1e-4)
+        d_weight = torch.clamp(d_weight, 0.0, 1e4).detach()
+        d_weight = d_weight * self.discriminator_weight
+        return d_weight
+
+    def forward(
+        self,
+        regularization_log,
+        inputs,
+        reconstructions,
+        optimizer_idx,
+        global_step,
+        last_layer=None,
+        split="train",
+        weights=None,
+    ):
+        if self.scale_input_to_tgt_size:
+            inputs = torch.nn.functional.interpolate(
+                inputs, reconstructions.shape[2:], mode="bicubic", antialias=True
+            )
+
+        if self.dims > 2:
+            inputs, reconstructions = map(
+                lambda x: rearrange(x, "b c t h w -> (b t) c h w"),
+                (inputs, reconstructions),
+            )
+
+        rec_loss = torch.abs(inputs.contiguous() - reconstructions.contiguous())
+        if self.perceptual_weight > 0:
+            p_loss = self.perceptual_loss(
+                inputs.contiguous(), reconstructions.contiguous()
+            )
+            rec_loss = rec_loss + self.perceptual_weight * p_loss
+
+        nll_loss = rec_loss / torch.exp(self.logvar) + self.logvar
+        weighted_nll_loss = nll_loss
+        if weights is not None:
+            weighted_nll_loss = weights * nll_loss
+        weighted_nll_loss = torch.sum(weighted_nll_loss) / weighted_nll_loss.shape[0]
+        nll_loss = torch.sum(nll_loss) / nll_loss.shape[0]
+
+        # now the GAN part
+        if optimizer_idx == 0:
+            # generator update
+            logits_fake = self.discriminator(reconstructions.contiguous())
+            g_loss = -torch.mean(logits_fake)
+
+            if self.disc_factor > 0.0:
+                try:
+                    d_weight = self.calculate_adaptive_weight(
+                        nll_loss, g_loss, last_layer=last_layer
+                    )
+                except RuntimeError:
+                    assert not self.training
+                    d_weight = torch.tensor(0.0)
+            else:
+                d_weight = torch.tensor(0.0)
+
+            disc_factor = adopt_weight(
+                self.disc_factor, global_step, threshold=self.discriminator_iter_start
+            )
+            loss = weighted_nll_loss + d_weight * disc_factor * g_loss
+            log = dict()
+            for k in regularization_log:
+                if k in self.regularization_weights:
+                    loss = loss + self.regularization_weights[k] * regularization_log[k]
+                log[f"{split}/{k}"] = regularization_log[k].detach().mean()
+
+            log.update(
+                {
+                    "{}/total_loss".format(split): loss.clone().detach().mean(),
+                    "{}/logvar".format(split): self.logvar.detach(),
+                    "{}/nll_loss".format(split): nll_loss.detach().mean(),
+                    "{}/rec_loss".format(split): rec_loss.detach().mean(),
+                    "{}/d_weight".format(split): d_weight.detach(),
+                    "{}/disc_factor".format(split): torch.tensor(disc_factor),
+                    "{}/g_loss".format(split): g_loss.detach().mean(),
+                }
+            )
+
+            return loss, log
+
+        if optimizer_idx == 1:
+            # second pass for discriminator update
+            logits_real = self.discriminator(inputs.contiguous().detach())
+            logits_fake = self.discriminator(reconstructions.contiguous().detach())
+
+            disc_factor = adopt_weight(
+                self.disc_factor, global_step, threshold=self.discriminator_iter_start
+            )
+            d_loss = disc_factor * self.disc_loss(logits_real, logits_fake)
+
+            log = {
+                "{}/disc_loss".format(split): d_loss.clone().detach().mean(),
+                "{}/logits_real".format(split): logits_real.detach().mean(),
+                "{}/logits_fake".format(split): logits_fake.detach().mean(),
+            }
+            return d_loss, log

CCEdit-main/sgm/modules/autoencoding/regularizers/__init__.py

@@ -0,0 +1,53 @@
+from abc import abstractmethod
+from typing import Any, Tuple
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+from ....modules.distributions.distributions import DiagonalGaussianDistribution
+
+
+class AbstractRegularizer(nn.Module):
+    def __init__(self):
+        super().__init__()
+
+    def forward(self, z: torch.Tensor) -> Tuple[torch.Tensor, dict]:
+        raise NotImplementedError()
+
+    @abstractmethod
+    def get_trainable_parameters(self) -> Any:
+        raise NotImplementedError()
+
+
+class DiagonalGaussianRegularizer(AbstractRegularizer):
+    def __init__(self, sample: bool = True):
+        super().__init__()
+        self.sample = sample
+
+    def get_trainable_parameters(self) -> Any:
+        yield from ()
+
+    def forward(self, z: torch.Tensor) -> Tuple[torch.Tensor, dict]:
+        log = dict()
+        posterior = DiagonalGaussianDistribution(z)
+        if self.sample:
+            z = posterior.sample()
+        else:
+            z = posterior.mode()
+        kl_loss = posterior.kl()
+        kl_loss = torch.sum(kl_loss) / kl_loss.shape[0]
+        log["kl_loss"] = kl_loss
+        return z, log
+
+
+def measure_perplexity(predicted_indices, num_centroids):
+    # src: https://github.com/karpathy/deep-vector-quantization/blob/main/model.py
+    # eval cluster perplexity. when perplexity == num_embeddings then all clusters are used exactly equally
+    encodings = (
+        F.one_hot(predicted_indices, num_centroids).float().reshape(-1, num_centroids)
+    )
+    avg_probs = encodings.mean(0)
+    perplexity = (-(avg_probs * torch.log(avg_probs + 1e-10)).sum()).exp()
+    cluster_use = torch.sum(avg_probs > 0)
+    return perplexity, cluster_use