diff --git "a/Helios/_DEV2/train_helios.py" "b/Helios/_DEV2/train_helios.py" new file mode 100644--- /dev/null +++ "b/Helios/_DEV2/train_helios.py" @@ -0,0 +1,2603 @@ +import os + + +os.environ["HF_ENABLE_PARALLEL_LOADING"] = "yes" +os.environ["HF_PARALLEL_LOADING_WORKERS"] = "8" + +import argparse +import copy +import json +import logging +import math +import random +import shutil +from datetime import timedelta +from pathlib import Path + +import numpy as np +import torch +import torch.distributed.checkpoint as dcp +import transformers +from accelerate import Accelerator, DistributedType +from accelerate.logging import get_logger +from accelerate.utils import ( + DeepSpeedPlugin, + DistributedDataParallelKwargs, + InitProcessGroupKwargs, + ProjectConfiguration, + broadcast, + set_seed, +) +from helios.modules.helios_kernels import ( + replace_all_norms_with_flash_norms, + replace_rmsnorm_with_fp32, + replace_rope_with_flash_rope, +) +from helios.modules.transformer_helios import HeliosTransformer3DModel +from helios.pipelines.pipeline_helios import HeliosPipeline +from helios.scheduler.scheduling_helios import HeliosScheduler +from helios.utils.create_ema_zero3_lora import create_ema_final, gather_zero3ema +from helios.utils.train_config import Args +from helios.utils.utils_base import ( + NORM_LAYER_PREFIXES, + compare_configs, + encode_prompt, + get_optimizer, + load_extra_components, + load_model_checkpoint, + save_extra_components, + save_model_checkpoint, +) +from helios.utils.utils_helios_base import ( + _flow_loss, + prepare_stage1_clean_input_from_latents, + prepare_stage1_noise_input, + prepare_stage2_noise_input, +) +from helios.utils.utils_helios_post import ( + OptimizedLowVRAMManager, + _critic_loss, + _generator_loss, + _ode_regression_loss, + merge_dict_list, + sample_dynamic_dmd_num_latent_sections, +) +from helios.utils.utils_recycle_batch import get_timesteps +from helios.videoalign.inference import VideoVLMRewardInference +from packaging import version +from peft import LoraConfig, set_peft_model_state_dict +from peft.utils import get_peft_model_state_dict +from torchdata.stateful_dataloader import StatefulDataLoader +from tqdm.auto import tqdm +from transformers import ( + AutoTokenizer, + UMT5EncoderModel, +) + +import diffusers +from diffusers import ( + AutoencoderKLWan, + FlowMatchEulerDiscreteScheduler, + UniPCMultistepScheduler, +) +from diffusers.optimization import get_scheduler +from diffusers.training_utils import ( + _collate_lora_metadata, + cast_training_params, + free_memory, +) +from diffusers.utils import ( + check_min_version, + convert_unet_state_dict_to_peft, + export_to_video, + is_wandb_available, +) +from diffusers.utils.import_utils import is_torch_npu_available, is_xformers_available +from diffusers.utils.torch_utils import is_compiled_module + + +if is_wandb_available(): + import wandb + +# Will error if the minimal version of diffusers is not installed. Remove at your own risks. +check_min_version("0.36.0.dev0") + +logger = get_logger(__name__) + +if is_torch_npu_available(): + torch.npu.config.allow_internal_format = False + + +def main(args): + if args.data_config.use_stage3_dataset: + from helios.dataset.dataloader_dmd import ( + BucketedFeatureDataset, + BucketedSampler, + collate_fn, + ) + elif args.data_config.use_stage1_dataset: + from helios.dataset.dataloader_history_latents_dist import ( + BucketedFeatureDataset, + BucketedSampler, + collate_fn, + ) + else: + from helios.dataset.dataloader_mp4_dist import ( + BucketedFeatureDataset, + BucketedSampler, + collate_fn, + ) + + if torch.backends.mps.is_available() and args.training_config.mixed_precision == "bf16": + # due to pytorch#99272, MPS does not yet support bfloat16. + raise ValueError( + "Mixed precision training with bfloat16 is not supported on MPS. Please use fp16 (recommended) or fp32 instead." + ) + + # load dmd reward model + reward_model = None + if args.training_config.is_use_reward_model: + reward_model = VideoVLMRewardInference(args.model_config.reward_model_name_or_path) + reward_model.model.requires_grad_(False) + reward_model.model.eval() + + logging_dir = Path(args.output_dir, args.logging_dir) + + accelerator_project_config = ProjectConfiguration(project_dir=args.output_dir, logging_dir=logging_dir) + kwargs = DistributedDataParallelKwargs(find_unused_parameters=True) + init_kwargs = InitProcessGroupKwargs(backend="nccl", timeout=timedelta(seconds=1800)) + + # Support 2 models training using deepspeed. + # https://huggingface.co/docs/accelerate/usage_guides/deepspeed_multiple_model + deepspeed_plugins = None + dmd_deepspeed_training = ( + args.training_config.is_train_dmd + and args.training_config.dmd_generator_deepspeed_config is not None + and args.training_config.dmd_critic_deepspeed_config is not None + ) + if dmd_deepspeed_training: + generator_zero_plugin = DeepSpeedPlugin(hf_ds_config=args.training_config.dmd_generator_deepspeed_config) + critic_zero_plugin = DeepSpeedPlugin(hf_ds_config=args.training_config.dmd_critic_deepspeed_config) + deepspeed_plugins = {"generator": generator_zero_plugin, "critic_model": critic_zero_plugin} + + accelerator = Accelerator( + gradient_accumulation_steps=args.training_config.gradient_accumulation_steps, + mixed_precision=args.training_config.mixed_precision, + log_with=args.report_to.report_to, + project_config=accelerator_project_config, + deepspeed_plugins=deepspeed_plugins, + kwargs_handlers=[kwargs, init_kwargs], + ) + if ( + accelerator.distributed_type == DistributedType.DEEPSPEED + and args.training_config.is_train_dmd + and not args.training_config.dmd_generator_deepspeed_config + and not args.training_config.dmd_critic_deepspeed_config + ): + raise ValueError("`--deepspeed_config` is required for DMD distillation.") + + if dmd_deepspeed_training: + critic_accelerator = Accelerator() + + if accelerator.is_main_process: + os.makedirs(args.output_dir, exist_ok=True) + config_path = os.path.join(args.output_dir, "config.json") + current_conf = OmegaConf.to_container(args, resolve=True) + if os.path.exists(config_path): + with open(config_path, "r") as f: + existing_conf = json.load(f) + + ignore_keys = {"training_config.local_rank"} + mismatches = compare_configs(existing_conf, current_conf, ignore_keys=ignore_keys) + if mismatches: + print("Config mismatches found:") + for mismatch in mismatches: + print(f" - {mismatch}") + raise ValueError("Configuration mismatch detected!") + else: + with open(config_path, "w") as f: + json.dump(current_conf, f, indent=4) + + if args.training_config.use_ema: + args.training_config.ema_zero3_port = os.environ.get("MASTER_PORT", "12345") + + # Disable AMP for MPS. + if torch.backends.mps.is_available(): + accelerator.native_amp = False + + if args.report_to.report_to == "wandb": + if not is_wandb_available(): + raise ImportError("Make sure to install wandb if you want to use it for logging during training.") + + # Make one log on every process with the configuration for debugging. + logging.basicConfig( + format="%(asctime)s - %(levelname)s - %(name)s - %(message)s", + datefmt="%m/%d/%Y %H:%M:%S", + level=logging.INFO, + ) + logger.info(accelerator.state, main_process_only=False) + if accelerator.is_local_main_process: + transformers.utils.logging.set_verbosity_warning() + diffusers.utils.logging.set_verbosity_info() + else: + transformers.utils.logging.set_verbosity_error() + diffusers.utils.logging.set_verbosity_error() + + # If passed along, set the training seed now. + if args.seed is not None: + set_seed(args.seed) + + # Handle the repository creation + if accelerator.is_main_process: + if args.output_dir is not None: + os.makedirs(args.output_dir, exist_ok=True) + + # Load the tokenizers + tokenizer = AutoTokenizer.from_pretrained( + args.model_config.pretrained_model_name_or_path, + subfolder="tokenizer", + revision=args.model_config.revision, + ) + + # For mixed precision training we cast all non-trainable weights (vae, text_encoder and transformer) to half-precision + # as these weights are only used for inference, keeping weights in full precision is not required. + weight_dtype = torch.float32 + if accelerator.mixed_precision == "fp16": + weight_dtype = torch.float16 + elif accelerator.mixed_precision == "bf16": + weight_dtype = torch.bfloat16 + + # Load scheduler and models + if args.training_config.is_enable_stage2: + noise_scheduler = HeliosScheduler( + shift=args.training_config.stage2_timestep_shift, + stages=args.training_config.stage2_num_stages, + stage_range=args.training_config.stage2_stage_range, + gamma=args.training_config.stage2_scheduler_gamma, + ) + noise_scheduler_copy = copy.deepcopy(noise_scheduler) + else: + noise_scheduler = UniPCMultistepScheduler.from_pretrained("scripts/accelerate_configs/scheduler_config.json") + noise_scheduler_copy = FlowMatchEulerDiscreteScheduler(num_train_timesteps=1000) + if args.training_config.is_train_dmd: + noise_scheduler.config.flow_shift = args.training_config.dmd_timestep_shift + + if args.training_config.is_train_dmd: + if args.training_config.is_enable_stage2: + critic_noise_scheduler = HeliosScheduler( + shift=args.training_config.stage2_timestep_shift, + stages=args.training_config.stage2_num_stages, + stage_range=args.training_config.stage2_stage_range, + gamma=args.training_config.stage2_scheduler_gamma, + ) + else: + critic_noise_scheduler = FlowMatchEulerDiscreteScheduler(num_train_timesteps=1000) + + vae = AutoencoderKLWan.from_pretrained( + args.model_config.pretrained_model_name_or_path, + subfolder="vae", + revision=args.model_config.revision, + variant=args.model_config.variant, + torch_dtype=torch.float32, + device_map=accelerator.device, + ) + if args.model_config.enable_slicing: + vae.enable_slicing() + if args.model_config.enable_tiling: + vae.enable_tiling() + + text_encoder = UMT5EncoderModel.from_pretrained( + args.model_config.pretrained_model_name_or_path, + subfolder="text_encoder", + revision=args.model_config.revision, + variant=args.model_config.variant, + dtype=weight_dtype, + device_map=accelerator.device, + ) + # For negative prompt + with torch.no_grad(): + negative_prompt_embeds, _ = encode_prompt( + tokenizer=tokenizer, + text_encoder=text_encoder, + prompt=args.data_config.negative_prompt, + device=accelerator.device, + ) + + transformer_additional_kwargs = { + "has_multi_term_memory_patch": args.training_config.has_multi_term_memory_patch, + "zero_history_timestep": args.training_config.zero_history_timestep, + "restrict_self_attn": args.training_config.restrict_self_attn, + "guidance_cross_attn": args.training_config.guidance_cross_attn, + "is_train_restrict_lora": args.training_config.is_train_restrict_lora, + "restrict_lora": args.training_config.restrict_lora, + "restrict_lora_rank": args.training_config.restrict_lora_rank, + "is_amplify_history": args.training_config.is_amplify_history, + "history_scale_mode": args.training_config.history_scale_mode, + } + transformer = HeliosTransformer3DModel.from_pretrained( + args.model_config.transformer_model_name_or_path, + subfolder=args.model_config.subfolder or "transformer", + transformer_additional_kwargs=transformer_additional_kwargs, + ) + transformer = replace_rmsnorm_with_fp32(transformer) + transformer = replace_all_norms_with_flash_norms(transformer) + replace_rope_with_flash_rope() + + # load dmd real score model + if args.training_config.is_train_dmd: + if args.model_config.real_score_model_name_or_path is None: + args.model_config.real_score_model_name_or_path = args.model_config.transformer_model_name_or_path + critic_transformer_additional_kwargs = { + "has_multi_term_memory_patch": args.training_config.has_multi_term_memory_patch, + "zero_history_timestep": args.training_config.zero_history_timestep, + "restrict_self_attn": args.training_config.restrict_self_attn, + "guidance_cross_attn": args.training_config.guidance_cross_attn, + "is_train_restrict_lora": args.training_config.is_train_restrict_lora, + "restrict_lora": args.training_config.restrict_lora, + "restrict_lora_rank": args.training_config.restrict_lora_rank, + "is_use_gan": args.training_config.is_use_gan, + "is_use_gan_hooks": args.training_config.is_use_gan_hooks, + "is_use_gan_final": args.training_config.is_use_gan_final, + "gan_cond_map_dim": args.training_config.gan_cond_map_dim, + "gan_hooks": args.training_config.gan_hooks, + } + + real_score_model = HeliosTransformer3DModel.from_pretrained( + args.model_config.real_score_model_name_or_path, + subfolder=args.model_config.critic_subfolder or "transformer", + transformer_additional_kwargs=critic_transformer_additional_kwargs, + ) + real_score_model = replace_rmsnorm_with_fp32(real_score_model) + real_score_model = replace_all_norms_with_flash_norms(real_score_model) + + # We only train the additional adapter LoRA layers + transformer.requires_grad_(False) + vae.requires_grad_(False) + text_encoder.requires_grad_(False) + vae.eval() + text_encoder.eval() + if args.training_config.is_train_dmd: + real_score_model.requires_grad_(False) + + if args.model_config.lora_layers is not None: + if args.model_config.lora_layers != "all-linear": + target_modules = [layer.strip() for layer in args.model_config.lora_layers.split(",")] + # add the input layer to the mix. + if args.training_config.is_train_lora_patch_embedding and "patch_embedding" not in target_modules: + target_modules.append("patch_embedding") + + # add multi-term memory patches to the mix + if args.training_config.is_train_lora_multi_term_memory_patchg: + for patch_name in ["patch_short", "patch_mid", "patch_long"]: + if patch_name not in target_modules: + target_modules.append(patch_name) + elif args.model_config.lora_layers == "all-linear": + target_modules = set() + for name, module in transformer.named_modules(): + if isinstance(module, torch.nn.Linear): + target_modules.add(name) + target_modules = list(target_modules) + # add the input layer to the mix. + if args.training_config.is_train_lora_patch_embedding and "patch_embedding" not in target_modules: + target_modules.append("patch_embedding") + + # add multi-term memory patches to the mix + if args.training_config.is_train_lora_multi_term_memory_patchg: + for patch_name in ["patch_short", "patch_mid", "patch_long"]: + if patch_name not in target_modules: + target_modules.append(patch_name) + target_modules = [t for t in target_modules if "norm" not in t] + else: + target_modules = args.model_config.lora_target_modules + + # now we will add new LoRA weights the transformer layers + transformer_lora_config = LoraConfig( + r=args.model_config.lora_rank, + lora_alpha=args.model_config.lora_alpha, + lora_dropout=args.model_config.lora_dropout, + init_lora_weights="gaussian", + target_modules=list(target_modules), + exclude_modules=list(args.model_config.lora_exclude_modules), + ) + transformer.add_adapter(transformer_lora_config) + + if args.model_config.train_norm_layers: + for name, param in transformer.named_parameters(): + if any(k in name for k in NORM_LAYER_PREFIXES): + param.requires_grad = True + + # set trainable parameter + trainable_modules = [] + if args.training_config.is_train_full_multi_term_memory_patchg: + trainable_modules.extend(["patch_short", "patch_mid", "patch_long"]) + if args.training_config.is_train_full_patch_embedding: + trainable_modules.append("patch_embedding") + if args.training_config.is_train_restrict_lora: + trainable_modules.extend(["q_loras", "k_loras", "v_loras"]) + if args.training_config.is_amplify_history: + trainable_modules.append("history_key_scale") + for name, param in transformer.named_parameters(): + for trainable_module_name in trainable_modules: + if trainable_module_name in name: + param.requires_grad = True + break + + if args.training_config.use_ema: + model_cls = HeliosTransformer3DModel + transformer_cpu = copy.deepcopy(transformer) + with open(args.training_config.ema_deepspeed_config_file, "r") as f: + ds_config = json.load(f) + + # get fake score model + if args.training_config.is_train_dmd: + critic_target_modules = [ + m for m in target_modules if m not in ["patch_short", "patch_mid", "patch_long", "patch_embedding"] + ] + critic_exclude_modules = list(args.model_config.lora_exclude_modules) + [ + "patch_short", + "patch_mid", + "patch_long", + "patch_embedding", + "gan_heads", + "gan_final_head", + ] + critic_transformer_lora_config = LoraConfig( + r=args.model_config.critic_lora_rank, + lora_alpha=args.model_config.critic_lora_alpha, + lora_dropout=args.model_config.critic_lora_dropout, + init_lora_weights="gaussian", + target_modules=critic_target_modules, + exclude_modules=critic_exclude_modules, + ) + + real_score_model.add_adapter(critic_transformer_lora_config) + + if args.model_config.train_norm_layers: + for name, param in real_score_model.named_parameters(): + if any(k in name for k in NORM_LAYER_PREFIXES): + param.requires_grad = True + + if args.training_config.is_use_gan: + critic_trainable_modules = ["gan_heads", "gan_final_head"] + for name, param in real_score_model.named_parameters(): + for trainable_module_name in critic_trainable_modules: + if trainable_module_name in name: + param.requires_grad = True + break + + if args.model_config.load_checkpoints_custom: + load_model_checkpoint( + args=args, + checkpoint_path=args.model_config.load_model_path, + transformer=transformer, + pipeline_class=HeliosPipeline, + norm_layer_prefixes=NORM_LAYER_PREFIXES, + convert_unet_state_dict_to_peft_fn=convert_unet_state_dict_to_peft, + set_peft_model_state_dict_fn=set_peft_model_state_dict, + cast_training_params_fn=cast_training_params, + ) + if args.training_config.is_train_dmd: + assert args.model_config.critic_lora_name_or_path is not None + assert args.model_config.load_dcp + + if args.model_config.critic_lora_name_or_path is not None: + load_model_checkpoint( + args=args, + checkpoint_path=args.model_config.critic_lora_name_or_path, + transformer=real_score_model, + pipeline_class=HeliosPipeline, + norm_layer_prefixes=NORM_LAYER_PREFIXES, + convert_unet_state_dict_to_peft_fn=convert_unet_state_dict_to_peft, + set_peft_model_state_dict_fn=set_peft_model_state_dict, + cast_training_params_fn=cast_training_params, + ) + + if torch.backends.mps.is_available() and weight_dtype == torch.bfloat16: + # due to pytorch#99272, MPS does not yet support bfloat16. + raise ValueError( + "Mixed precision training with bfloat16 is not supported on MPS. Please use fp16 (recommended) or fp32 instead." + ) + + # Move vae, transformer and text_encoder to device and cast to weight_dtype + target_device = ( + "cpu" if (args.data_config.use_stage1_dataset or args.data_config.use_stage3_dataset) else accelerator.device + ) + vae.to(target_device) + text_encoder.to(target_device) + if args.training_config.is_use_reward_model: + reward_model.model.to(target_device) + free_memory() + + # we never offload the transformer to CPU, so we can just use the accelerator device + for name, param in transformer.named_parameters(): + should_keep_fp32 = any(pattern in name for pattern in transformer.__class__._keep_in_fp32_modules) + if should_keep_fp32: + param.data = param.data.to(torch.float32) + else: + param.data = param.data.to(weight_dtype) + transformer.to(accelerator.device) + + if args.training_config.is_train_dmd: + for name, param in real_score_model.named_parameters(): + should_keep_fp32 = any(pattern in name for pattern in real_score_model.__class__._keep_in_fp32_modules) + if should_keep_fp32: + param.data = param.data.to(torch.float32) + else: + param.data = param.data.to(weight_dtype) + real_score_model.to(accelerator.device) + free_memory() + + if args.training_config.enable_npu_flash_attention: + if is_torch_npu_available(): + accelerator.print("npu flash attention enabled.") + transformer.enable_npu_flash_attention() + if args.training_config.is_train_dmd: + real_score_model.enable_npu_flash_attention() + else: + raise ValueError("npu flash attention requires torch_npu extensions and is supported only on npu devices.") + + if args.training_config.enable_xformers_memory_efficient_attention: + if is_xformers_available(): + import xformers + + xformers_version = version.parse(xformers.__version__) + if xformers_version == version.parse("0.0.16"): + logger.warning( + "xFormers 0.0.16 cannot be used for training in some GPUs. If you observe problems during training, please update xFormers to at least 0.0.17. See https://huggingface.co/docs/diffusers/main/en/optimization/xformers for more details." + ) + transformer.enable_xformers_memory_efficient_attention() + if args.training_config.is_train_dmd: + real_score_model.enable_xformers_memory_efficient_attention() + else: + raise ValueError("xformers is not available. Make sure it is installed correctly") + + if args.training_config.gradient_checkpointing: + transformer.enable_gradient_checkpointing() + if args.training_config.is_train_dmd: + real_score_model.enable_gradient_checkpointing() + + def unwrap_model(model): + model = accelerator.unwrap_model(model) + model = model._orig_mod if is_compiled_module(model) else model + return model + + # create custom saving & loading hooks so that `accelerator.save_state(...)` serializes in a nice format + def save_model_hook(models, weights, output_dir): + if accelerator.is_main_process: + transformer_lora_layers_to_save = None + modules_to_save = {} + + for model in models: + if isinstance(unwrap_model(model), type(unwrap_model(transformer))): + model = unwrap_model(model) + transformer_lora_layers_to_save = get_peft_model_state_dict(model) + if args.model_config.train_norm_layers: + transformer_norm_layers_to_save = { + f"transformer.{name}": param + for name, param in model.named_parameters() + if any(k in name for k in NORM_LAYER_PREFIXES) + } + transformer_lora_layers_to_save = { + **transformer_lora_layers_to_save, + **transformer_norm_layers_to_save, + } + modules_to_save["transformer"] = model + else: + raise ValueError(f"unexpected save model: {model.__class__}") + + # make sure to pop weight so that corresponding model is not saved again + if weights: + weights.pop() + + HeliosPipeline.save_lora_weights( + output_dir, + transformer_lora_layers=transformer_lora_layers_to_save, + **_collate_lora_metadata(modules_to_save), + ) + + save_extra_components(args, model=unwrap_model(model), output_dir=output_dir) + + def load_model_hook(models, input_dir): + transformer_ = None + + if not accelerator.distributed_type == DistributedType.DEEPSPEED: + while len(models) > 0: + model = models.pop() + + if isinstance(unwrap_model(model), type(unwrap_model(transformer))): + model = unwrap_model(model) + transformer_ = model + else: + raise ValueError(f"unexpected save model: {model.__class__}") + else: + transformer_ = HeliosTransformer3DModel.from_pretrained( + args.model_config.transformer_model_name_or_path, + subfolder=( + args.model_config.critic_subfolder if "critic" in input_dir else args.model_config.subfolder + ) + or "transformer", + transformer_additional_kwargs=critic_transformer_additional_kwargs + if "critic" in input_dir + else transformer_additional_kwargs, + ) + transformer_.add_adapter( + critic_transformer_lora_config if "critic" in input_dir else transformer_lora_config + ) + + lora_state_dict = HeliosPipeline.lora_state_dict(input_dir) + + transformer_state_dict = { + f"{k.replace('transformer.', '')}": v for k, v in lora_state_dict.items() if k.startswith("transformer.") + } + transformer_state_dict = convert_unet_state_dict_to_peft(transformer_state_dict) + incompatible_keys = set_peft_model_state_dict(transformer_, transformer_state_dict, adapter_name="default") + if incompatible_keys is not None: + # check only for unexpected keys + unexpected_keys = getattr(incompatible_keys, "unexpected_keys", None) + if unexpected_keys: + logger.warning( + f"Loading adapter weights from state_dict led to unexpected keys not found in the model: " + f" {unexpected_keys}. " + ) + + if args.model_config.train_norm_layers: + transformer_norm_state_dict = { + k: v + for k, v in lora_state_dict.items() + if k.startswith("transformer.") and any(norm_k in k for norm_k in NORM_LAYER_PREFIXES) + } + transformer_._transformer_norm_layers = HeliosPipeline._load_norm_into_transformer( + transformer_norm_state_dict, + transformer=transformer_, + discard_original_layers=False, + ) + + load_extra_components(args, transformer_, os.path.join(input_dir, "transformer_partial.pth")) + + # Make sure the trainable params are in float32. This is again needed since the base models + # are in `weight_dtype`. More details: + # https://github.com/huggingface/diffusers/pull/6514#discussion_r1449796804 + if args.training_config.mixed_precision != "fp32": + models = [transformer_] + # only upcast trainable parameters (LoRA) into fp32 + cast_training_params(models) + + dcp_dir = os.path.join(input_dir, "distributed_checkpoint") + if "critic" not in dcp_dir: + states = { + "dataloader": train_dataloader, + } + dcp.load(states, checkpoint_id=dcp_dir) + + accelerator.register_save_state_pre_hook(save_model_hook) + accelerator.register_load_state_pre_hook(load_model_hook) + + if args.training_config.is_train_dmd: + critic_accelerator.register_save_state_pre_hook(save_model_hook) + critic_accelerator.register_load_state_pre_hook(load_model_hook) + + # Enable TF32 for faster training on Ampere GPUs, + # cf https://pytorch.org/docs/stable/notes/cuda.html#tensorfloat-32-tf32-on-ampere-devices + if args.training_config.allow_tf32 and torch.cuda.is_available(): + torch.backends.cuda.matmul.allow_tf32 = True + + if args.training_config.scale_lr: + args.training_config.learning_rate = ( + args.training_config.learning_rate + * args.training_config.gradient_accumulation_steps + * args.training_config.train_batch_size + * accelerator.num_processes + ) + + if args.training_config.is_train_dmd: + args.training_config.critic_learning_rate = ( + args.training_config.critic_learning_rate + * args.training_config.gradient_accumulation_steps + * args.training_config.train_batch_size + * accelerator.num_processes + ) + + # Make sure the trainable params are in float32. + if args.training_config.mixed_precision != "fp32": + models = [transformer] + if args.training_config.is_train_dmd: + models.append(real_score_model) + # only upcast trainable parameters (LoRA) into fp32 + cast_training_params(models, dtype=torch.float32) + + # Optimization parameters + transformer_lora_parameters = list(filter(lambda p: p.requires_grad, transformer.parameters())) + transformer_parameters_with_lr = {"params": transformer_lora_parameters, "lr": args.training_config.learning_rate} + params_to_optimize = [transformer_parameters_with_lr] + + use_deepspeed_optimizer = ( + accelerator.state.deepspeed_plugin is not None + and "optimizer" in accelerator.state.deepspeed_plugin.deepspeed_config + ) + use_deepspeed_scheduler = ( + accelerator.state.deepspeed_plugin is not None + and "scheduler" in accelerator.state.deepspeed_plugin.deepspeed_config + ) + + optimizer = get_optimizer(args, accelerator, params_to_optimize, use_deepspeed=use_deepspeed_optimizer) + + if args.training_config.is_train_dmd: + critic_model_lora_parameters = list(filter(lambda p: p.requires_grad, real_score_model.parameters())) + critic_model_lr_parameters_with_lr = { + "params": critic_model_lora_parameters, + "lr": args.training_config.critic_learning_rate, + } + critic_model_params_to_optimize = [critic_model_lr_parameters_with_lr] + critic_optimizer = get_optimizer( + args, critic_accelerator, critic_model_params_to_optimize, use_deepspeed=use_deepspeed_optimizer + ) + + # Dataset and DataLoaders creation: + dataset_sampling_ratios = {} + if args.data_config.dataset_sampling_ratios: + for temp_key, temp_value in zip(args.data_config.instance_data_root, args.data_config.dataset_sampling_ratios): + clean_path = temp_key.rstrip("/") + dataset_sampling_ratios[clean_path] = temp_value + + if args.data_config.use_stage3_dataset: + dataset_kwargs = { + "gan_folders": args.data_config.gan_data_root + if args.training_config.is_use_gan or args.training_config.is_use_gt_history + else None, + "ode_folders": args.data_config.ode_data_root if args.training_config.is_use_ode_regression else None, + "text_folders": args.data_config.text_data_root + if not args.training_config.is_only_ode_regression + else None, + "is_use_gt_history": args.training_config.is_use_gt_history, + "return_secondary": args.training_config.is_use_gt_history, + "single_res": args.data_config.single_res, + "single_length": args.data_config.single_length, + "single_num_frame": args.data_config.single_num_frame, + "single_height": args.data_config.single_height, + "single_width": args.data_config.single_width, + "force_rebuild": args.data_config.force_rebuild, + "seed": args.seed, + } + assert any( + [ + dataset_kwargs["gan_folders"], + dataset_kwargs["ode_folders"], + dataset_kwargs["text_folders"], + ] + ), "Invalid dataset config: at least one of `gan_folders`, `ode_folders`, or `text_folders` must be non-empty." + elif args.data_config.use_stage1_dataset: + dataset_kwargs = { + "feature_folders": args.data_config.instance_data_root, + "single_res": args.data_config.single_res, + "single_height": args.data_config.single_height, + "single_width": args.data_config.single_width, + "return_prompt_raw": args.training_config.is_use_reward_model, + "return_all_vae_latent": ( + args.training_config.dmd_teacher_forcing and args.training_config.dmd_teacher_forcing_ratio > 0 + ) + or args.training_config.is_use_gan, + "history_sizes": args.training_config.history_sizes, + "is_keep_x0": True, + "force_rebuild": args.data_config.force_rebuild, + "seed": args.seed, + } + else: + raise NotImplementedError + dataset_kwargs = { + "json_files": args.data_config.instance_data_root, + "video_folders": args.data_config.instance_video_root, + "force_rebuild": args.data_config.force_rebuild, + "stride": args.data_config.stride, + "resolution": args.data_config.resolution, + "single_res": args.data_config.single_res, + "single_length": args.data_config.single_length, + "single_num_frame": args.data_config.single_num_frame, + "single_height": args.data_config.single_height, + "single_width": args.data_config.single_width, + "multi_res": args.data_config.multi_res, + "id_token": args.data_config.id_token, + } + + train_dataset = BucketedFeatureDataset(**dataset_kwargs) + + sampler = BucketedSampler( + train_dataset, + batch_size=args.training_config.train_batch_size, + drop_last=True, # TODO need to be true now + shuffle=args.data_config.use_shuffle, + seed=args.seed, + dataset_sampling_ratios=dataset_sampling_ratios, + num_sp_groups=accelerator.num_processes // 1, + sp_world_size=1, + global_rank=accelerator.process_index, + ) + + train_dataloader = StatefulDataLoader( + train_dataset, + batch_sampler=sampler, + pin_memory=args.data_config.pin_memory, + prefetch_factor=args.data_config.prefetch_factor if args.data_config.prefetch_factor > 0 else None, + persistent_workers=args.data_config.persistent_workers, + collate_fn=collate_fn, + num_workers=args.data_config.dataloader_num_workers, + ) + + if args.model_config.load_dcp: + if args.model_config.load_dcp_path is not None: + dcp_dir = os.path.join(args.model_config.load_dcp_path, "distributed_checkpoint") + else: + dcp_dir = os.path.join(args.model_config.load_model_path, "distributed_checkpoint") + states = { + "dataloader": train_dataloader, + } + dcp.load(states, checkpoint_id=dcp_dir) + print(f"load dcp from {dcp_dir} successfully!") + + # Scheduler and math around the number of training steps. + overrode_max_train_steps = False + num_update_steps_per_epoch = math.ceil(len(train_dataloader) / args.training_config.gradient_accumulation_steps) + if args.training_config.max_train_steps is None: + args.training_config.max_train_steps = args.training_config.num_train_epochs * num_update_steps_per_epoch + overrode_max_train_steps = True + + if use_deepspeed_scheduler: + from accelerate.utils import DummyScheduler + + lr_scheduler = DummyScheduler( + name=args.training_config.lr_scheduler, + optimizer=optimizer, + total_num_steps=args.training_config.max_train_steps * accelerator.num_processes, + num_warmup_steps=args.training_config.lr_warmup_steps * accelerator.num_processes, + ) + + if args.training_config.is_train_dmd: + critic_lr_scheduler = DummyScheduler( + name=args.training_config.lr_scheduler, + optimizer=critic_optimizer, + total_num_steps=args.training_config.max_train_steps * accelerator.num_processes, + num_warmup_steps=args.training_config.lr_warmup_steps * accelerator.num_processes, + ) + else: + lr_scheduler = get_scheduler( + args.training_config.lr_scheduler, + optimizer=optimizer, + num_warmup_steps=args.training_config.lr_warmup_steps * accelerator.num_processes, + num_training_steps=args.training_config.max_train_steps * accelerator.num_processes, + num_cycles=args.training_config.lr_num_cycles, + power=args.training_config.lr_power, + ) + + if args.training_config.is_train_dmd: + critic_lr_scheduler = get_scheduler( + args.training_config.lr_scheduler, + optimizer=critic_optimizer, + num_warmup_steps=args.training_config.lr_warmup_steps * accelerator.num_processes, + num_training_steps=args.training_config.max_train_steps * accelerator.num_processes, + num_cycles=args.training_config.lr_num_cycles, + power=args.training_config.lr_power, + ) + + # Prepare everything with our `accelerator`. + accelerator.wait_for_everyone() + if accelerator.state.deepspeed_plugin is not None: + accelerator.state.deepspeed_plugin.deepspeed_config["train_micro_batch_size_per_gpu"] = ( + args.training_config.train_batch_size + ) + if args.training_config.is_train_dmd: + if dmd_deepspeed_training: + accelerator.state.select_deepspeed_plugin("generator") + transformer, optimizer, lr_scheduler = accelerator.prepare(transformer, optimizer, lr_scheduler) + if dmd_deepspeed_training: + critic_accelerator.state.select_deepspeed_plugin("critic_model") + critic_accelerator.state.deepspeed_plugin.deepspeed_config["train_micro_batch_size_per_gpu"] = ( + args.training_config.train_batch_size + ) + real_score_model, critic_optimizer, critic_lr_scheduler = critic_accelerator.prepare( + real_score_model, critic_optimizer, critic_lr_scheduler + ) + else: + transformer, optimizer, lr_scheduler = accelerator.prepare(transformer, optimizer, lr_scheduler) + + # We need to recalculate our total training steps as the size of the training dataloader may have changed. + num_update_steps_per_epoch = math.ceil(len(train_dataloader) / args.training_config.gradient_accumulation_steps) + if overrode_max_train_steps: + args.training_config.max_train_steps = args.training_config.num_train_epochs * num_update_steps_per_epoch + # Afterwards we recalculate our number of training epochs + args.training_config.num_train_epochs = math.ceil( + args.training_config.max_train_steps / num_update_steps_per_epoch + ) + + # We need to initialize the trackers we use, and also store our configuration. + # The trackers initializes automatically on the main process. + if accelerator.is_main_process: + tracker_name = args.report_to.tracker_name or "wanvideo-train" + wandb_name = args.report_to.wandb_name or "custom-wandb-run-name" + accelerator.init_trackers( + tracker_name, + config=OmegaConf.to_container(args, resolve=True), + init_kwargs={"wandb": {"name": wandb_name}}, + ) + + # Train! + total_batch_size = ( + args.training_config.train_batch_size + * accelerator.num_processes + * args.training_config.gradient_accumulation_steps + ) + num_trainable_parameters = sum(param.numel() for model in params_to_optimize for param in model["params"]) + if args.training_config.is_train_dmd: + critic_num_trainable_parameters = sum( + param.numel() for model in critic_model_params_to_optimize for param in model["params"] + ) + + accelerator.print("***** Running training *****") + accelerator.print(f" Num generator trainable parameters = {num_trainable_parameters}") + if args.training_config.is_train_dmd: + accelerator.print(f" Num fake_score_model trainable parameters = {critic_num_trainable_parameters}") + accelerator.print(f" Num examples = {len(train_dataset)}") + accelerator.print(f" Num batches each epoch = {len(train_dataloader)}") + accelerator.print(f" Num Epochs = {args.training_config.num_train_epochs}") + accelerator.print(f" Instantaneous batch size per device = {args.training_config.train_batch_size}") + accelerator.print(f" Total train batch size (w. parallel, distributed & accumulation) = {total_batch_size}") + accelerator.print(f" Gradient Accumulation steps = {args.training_config.gradient_accumulation_steps}") + accelerator.print(f" Total optimization steps = {args.training_config.max_train_steps}") + global_step = 0 + first_epoch = 0 + + ema_transformer = None + vram_manager = None + if args.training_config.is_train_dmd and args.training_config.dmd_is_low_vram_mode: + vram_manager = OptimizedLowVRAMManager() + + # Potentially load in the weights and states from a previous save + if args.training_config.resume_from_checkpoint: + if args.training_config.resume_from_checkpoint != "latest": + resume_path = args.training_config.resume_from_checkpoint + if os.path.isabs(resume_path): + path = resume_path + else: + path = os.path.join(args.output_dir, resume_path) + else: + # Get the mos recent checkpoint + dirs = os.listdir(args.output_dir) + dirs = [d for d in dirs if d.startswith("checkpoint")] + dirs = sorted(dirs, key=lambda x: int(x.split("-")[1])) + path = os.path.join(args.output_dir, dirs[-1]) if len(dirs) > 0 else None + + if path is None or not os.path.exists(path): + accelerator.print( + f"Checkpoint '{args.training_config.resume_from_checkpoint}' does not exist. Starting a new training run." + ) + args.training_config.resume_from_checkpoint = None + initial_global_step = 0 + else: + accelerator.print(f"Resuming from checkpoint {path}") + accelerator.load_state(path, load_kwargs={"weights_only": False}) + if args.training_config.is_train_dmd: + critic_accelerator.load_state(os.path.join(path, "critic"), load_kwargs={"weights_only": False}) + global_step = int(os.path.basename(path).split("-")[1]) + + initial_global_step = global_step + first_epoch = global_step // num_update_steps_per_epoch + + if args.training_config.use_ema: + if args.training_config.is_train_dmd and args.training_config.dmd_is_low_vram_mode: + vram_manager.move_to_cpu(transformer, non_blocking=False) + vram_manager.move_to_cpu(real_score_model, non_blocking=False) + + transformer_cpu.load_state_dict(unwrap_model(transformer).state_dict()) + ema_transformer = create_ema_final( + accelerator=accelerator, + args=args, + transformer_cpu=transformer_cpu, + model_cls=model_cls, + ds_config=ds_config, + transformer_lora_config=transformer_lora_config, + resume_checkpoint_path=os.path.join(path, "model_ema"), + transformer_additional_kwargs=transformer_additional_kwargs, + ) + accelerator.wait_for_everyone() + + transformer_cpu = None + del transformer_cpu + + if args.training_config.is_train_dmd and args.training_config.dmd_is_low_vram_mode: + vram_manager.move_to_gpu(transformer, accelerator.device) + vram_manager.move_to_gpu(real_score_model, accelerator.device) + else: + initial_global_step = 0 + + if args.model_config.load_checkpoints_custom: + assert initial_global_step == 0 + + progress_bar = tqdm( + range(0, args.training_config.max_train_steps), + initial=initial_global_step, + desc="Steps", + # Only show the progress bar once on each machine. + disable=not accelerator.is_local_main_process, + ) + + if ( + args.training_config.is_train_dmd and args.training_config.dmd_is_low_vram_mode + ) or args.data_config.use_stage3_dataset: + if ( + not args.training_config.is_dmd_vae_decode + and not args.training_config.is_use_reward_model + and not args.training_config.is_smoothness_loss + ) or args.training_config.is_use_gt_history: + vae = None + text_encoder = None + free_memory() + + # initial ema + if ema_transformer is None and args.training_config.use_ema: + if args.training_config.is_train_dmd and args.training_config.dmd_is_low_vram_mode: + vram_manager.move_to_cpu(transformer, non_blocking=False) + vram_manager.move_to_cpu(real_score_model, non_blocking=False) + else: + transformer.to("cpu", non_blocking=False) + + transformer_cpu.load_state_dict(unwrap_model(transformer).state_dict()) + ema_transformer = create_ema_final( + accelerator=accelerator, + args=args, + transformer_cpu=transformer_cpu, + model_cls=model_cls, + ds_config=ds_config, + transformer_lora_config=transformer_lora_config, + update_after_step=args.training_config.ema_start_step, + ) + accelerator.wait_for_everyone() + + transformer_cpu = None + del transformer_cpu + + if args.training_config.is_train_dmd and args.training_config.dmd_is_low_vram_mode: + vram_manager.move_to_gpu(transformer, accelerator.device) + vram_manager.move_to_gpu(real_score_model, accelerator.device) + else: + transformer.to(accelerator.device, non_blocking=False) + + # initial gan + gan_critic_trainable_params = None + gan_base_critic_trainable_params = None + gan_extra_critic_trainable_params = None + if args.training_config.is_use_gan: + gan_critic_trainable_params = { + name for name, param in real_score_model.named_parameters() if param.requires_grad + } + gan_extra_critic_trainable_params = { + name + for name, param in real_score_model.named_parameters() + if param.requires_grad and any(module in name for module in critic_trainable_modules) + } + gan_base_critic_trainable_params = gan_critic_trainable_params - gan_extra_critic_trainable_params + + # initial recycle noise + recycle_vars = None + if args.training_config.use_error_recycling: + from types import SimpleNamespace + + num_grids = args.training_config.num_grids + + recycle_vars = SimpleNamespace() + recycle_vars.recycle_inferece_timesteps, recycle_vars.recycle_sigmas = get_timesteps( + num_inference_steps=num_grids, denoising_strength=1, shift=1.0 + ) + + resolutions = set() + for t, h, w in sampler.buckets.keys(): + base_h = h // 8 + base_w = w // 8 + resolutions.add((base_h, base_w)) + if args.training_config.is_enable_stage2: + resolutions.add((base_h // 2, base_w // 2)) + resolutions.add((base_h // 4, base_w // 4)) + + recycle_vars.latent_error_buffer = { + resolution: {i: [] for i in range(num_grids)} for resolution in resolutions + } + recycle_vars.y_error_buffer = {resolution: {i: [] for i in range(num_grids)} for resolution in resolutions} + + def safe_item(value): + return value.item() if hasattr(value, "item") else value + + accelerator.wait_for_everyone() + + prof = None + if args.training_config.profile_out_dir is not None: + prof = torch.profiler.profile( + activities=[torch.profiler.ProfilerActivity.CPU, torch.profiler.ProfilerActivity.CUDA], + schedule=torch.profiler.schedule(skip_first=2, wait=1, warmup=1, active=2, repeat=1), + on_trace_ready=torch.profiler.tensorboard_trace_handler(args.training_config.profile_out_dir), + profile_memory=True, + with_stack=True, + record_shapes=True, + ) + + for epoch in range(first_epoch, args.training_config.num_train_epochs): + transformer.train() + if args.training_config.is_train_dmd: + real_score_model.train() + sampler.set_epoch(epoch) + train_dataset.set_epoch(epoch) + + for step, batch in enumerate(train_dataloader): + models_to_accumulate = [transformer] + if args.training_config.is_train_dmd: + models_to_accumulate.append(real_score_model) + + with torch.no_grad(): + latent_window_size = args.training_config.latent_window_size[0] + + # Get data samples + gt_history_latents = None + gt_target_latents = None + gt_x0_latents = None + gt_history_latents_2 = None + gt_target_latents_2 = None + gt_x0_latents_2 = None + history_latents = None + target_latents = None + x0_latents = None + model_input = None + prompt_raws = None + prompt_embeds = None + indices_hidden_states = None + indices_latents_history_short = None + indices_latents_history_mid = None + indices_latents_history_long = None + latents_history_short = None + latents_history_mid = None + latents_history_long = None + gan_vae_latents = None + gan_prompt_embeds = None + ode_latents = None + ode_prompt_embeds = None + text_prompt_raws = None + text_prompt_embeds = None + + if args.data_config.use_stage3_dataset: + noisy_model_input_shape = ( + args.training_config.train_batch_size, + 16, + latent_window_size, + args.data_config.single_height // 8, + args.data_config.single_width // 8, + ) + + # For ODE + if args.training_config.is_use_ode_regression: + ode_latent_window_size = batch["ode_latent_window_size"][0] + ode_latents = batch["ode_latents"][0] + ode_prompt_embeds = batch["ode_prompt_embeds"][:1].to( + accelerator.device, dtype=weight_dtype, non_blocking=True + ) + assert args.training_config.train_batch_size == 1 + assert ode_latent_window_size == latent_window_size + + # For Text + if dataset_kwargs["text_folders"] and not args.training_config.is_only_ode_regression: + text_prompt_raws = batch["text_prompt_raws"] + text_prompt_embeds = batch["text_prompt_embeds"].to( + accelerator.device, dtype=weight_dtype, non_blocking=True + ) + + # For GAN + if args.training_config.is_use_gan or args.training_config.is_use_gt_history: + gan_vae_latents = batch["gan_vae_latents"].to( + accelerator.device, dtype=weight_dtype, non_blocking=True + ) + gan_prompt_embeds = batch["gan_prompt_embeds"].to( + accelerator.device, dtype=weight_dtype, non_blocking=True + ) + if args.training_config.is_use_gt_history: + text_prompt_raws = batch["gan_prompt_raws"] + text_prompt_embeds = gan_prompt_embeds + gt_target_latents = gan_vae_latents.to( + accelerator.device, dtype=weight_dtype, non_blocking=True + ) + gt_x0_latents = batch["gan_x0_latents"].to( + accelerator.device, dtype=weight_dtype, non_blocking=True + ) + gt_history_latents = batch["gan_history_latents"].to( + accelerator.device, dtype=weight_dtype, non_blocking=True + ) + + gt_target_latents_2 = batch["gan_vae_latents_2"].to( + accelerator.device, dtype=weight_dtype, non_blocking=True + ) + gt_x0_latents_2 = batch["gan_x0_latents_2"].to( + accelerator.device, dtype=weight_dtype, non_blocking=True + ) + gt_history_latents_2 = batch["gan_history_latents_2"].to( + accelerator.device, dtype=weight_dtype, non_blocking=True + ) + assert gt_target_latents_2.shape[2] == args.training_config.num_critic_input_frames + assert gan_vae_latents.shape[2] == args.training_config.num_critic_input_frames + + elif args.data_config.use_stage1_dataset: + # Prepare prompt embeds + prompt_embeds = batch["prompt_embeds"].to(accelerator.device) + + # Prepare stage1 clean data + history_latents = batch["history_latents"].to(accelerator.device) + target_latents = batch["target_latents"].to(accelerator.device) + x0_latents = batch["x0_latents"].to(accelerator.device) + ( + model_input, # torch.Size([2, 16, 9, 60, 104]) + indices_hidden_states, # torch.Size([2, 9]) + indices_latents_history_short, # torch.Size([2, 2]) + indices_latents_history_mid, # torch.Size([2, 2]) + indices_latents_history_long, # torch.Size([2, 16]) + latents_history_short, # torch.Size([2, 16, 2, 60, 104]) + latents_history_mid, # torch.Size([2, 16, 2, 60, 104]) + latents_history_long, # torch.Size([2, 16, 16, 60, 104]) + ) = prepare_stage1_clean_input_from_latents( + history_latents=history_latents, + target_latents=target_latents, + x0_latents=x0_latents, + latent_window_size=latent_window_size, + history_sizes=args.training_config.history_sizes, + is_random_drop=args.training_config.is_random_drop, + random_drop_i2v_ratio=args.training_config.random_drop_i2v_ratio, + random_drop_v2v_ratio=args.training_config.random_drop_v2v_ratio, + random_drop_t2v_ratio=args.training_config.random_drop_t2v_ratio, + is_keep_x0=True, + dtype=weight_dtype, + device=accelerator.device, + ) + history_latents = None + target_latents = None + x0_latents = None + del history_latents + del target_latents + del x0_latents + else: + raise NotImplementedError + + batch = None + del batch + + if not args.data_config.use_stage3_dataset and ( + args.training_config.offload or args.data_config.use_stage1_dataset + ): + if vae is not None: + vae.to("cpu", non_blocking=True) + if text_encoder is not None: + text_encoder.to("cpu", non_blocking=True) + free_memory() + + # Set NULL Text + if prompt_embeds is not None: + dropout_mask = ( + torch.rand(prompt_embeds.shape[0], device=prompt_embeds.device) + < args.data_config.caption_dropout_p + ) + prompt_embeds[dropout_mask] = 0 + + # To device + if not args.training_config.is_train_dmd and not args.training_config.is_use_ode_regression: + model_input = model_input.to(device=accelerator.device, dtype=weight_dtype, non_blocking=True) + indices_hidden_states = indices_hidden_states.to(accelerator.device, non_blocking=True) + indices_latents_history_short = indices_latents_history_short.to( + accelerator.device, non_blocking=True + ) + indices_latents_history_mid = indices_latents_history_mid.to(accelerator.device, non_blocking=True) + indices_latents_history_long = indices_latents_history_long.to( + accelerator.device, non_blocking=True + ) + latents_history_short = latents_history_short.to( + device=accelerator.device, dtype=weight_dtype, non_blocking=True + ) + latents_history_mid = latents_history_mid.to( + device=accelerator.device, dtype=weight_dtype, non_blocking=True + ) + latents_history_long = latents_history_long.to( + device=accelerator.device, dtype=weight_dtype, non_blocking=True + ) + if prompt_embeds is not None: + prompt_embeds = prompt_embeds.to(accelerator.device, non_blocking=True) + + # Prepare final data for training + use_clean_input = False + if args.training_config.is_train_dmd or args.training_config.is_use_ode_regression: + noisy_model_input_list = None + sigmas_list = None + timesteps_list = None + targets_list = None + latents_history_short = None + latents_history_mid = None + latents_history_long = None + else: + if args.training_config.is_enable_stage2: + ( + noisy_model_input_list, + sigmas_list, + timesteps_list, + targets_list, + latents_history_short, + latents_history_mid, + latents_history_long, + ) = prepare_stage2_noise_input( + args=args, + scheduler=noise_scheduler_copy, + latents=model_input, + pyramid_stage_num=args.training_config.stage2_num_stages, + stage2_sample_ratios=args.training_config.stage2_sample_ratios, + latents_history_short=latents_history_short, + latents_history_mid=latents_history_mid, + latents_history_long=latents_history_long, + latent_window_size=latent_window_size, + is_navit_pyramid=args.training_config.is_navit_pyramid, + is_efficient_sample=args.training_config.efficient_sample, + ) + else: + ( + noisy_model_input_list, + sigmas_list, + timesteps_list, + targets_list, + latents_history_short, + latents_history_mid, + latents_history_long, + use_clean_input, + ) = prepare_stage1_noise_input( + args=args, + model_input=model_input, + noise_scheduler=noise_scheduler_copy, + recycle_vars=recycle_vars, + latents_history_short=latents_history_short, + latents_history_mid=latents_history_mid, + latents_history_long=latents_history_long, + latent_window_size=latent_window_size, + is_keep_x0=True, + ) + + with accelerator.accumulate(models_to_accumulate): + # Predict the noise residual + if not args.training_config.is_train_dmd and not args.training_config.is_use_ode_regression: + assert len(noisy_model_input_list) == len(sigmas_list) == len(timesteps_list) == len(targets_list) + logs = _flow_loss( + args=args, + accelerator=accelerator, + lr_scheduler=lr_scheduler, + transformer=transformer, + prompt_embeds=prompt_embeds, + prompt_attention_masks=None, + noisy_model_input_list=noisy_model_input_list, + sigmas_list=sigmas_list, + timesteps_list=timesteps_list, + targets_list=targets_list, + indices_hidden_states=indices_hidden_states, + indices_latents_history_short=indices_latents_history_short, + indices_latents_history_mid=indices_latents_history_mid, + indices_latents_history_long=indices_latents_history_long, + latents_history_short=latents_history_short, + latents_history_mid=latents_history_mid, + latents_history_long=latents_history_long, + recycle_vars=recycle_vars, + global_step=global_step, + noise_scheduler_copy=noise_scheduler_copy, + use_clean_input=use_clean_input, + ) + optimizer.step() + lr_scheduler.step() + optimizer.zero_grad(set_to_none=True) + + elif args.training_config.is_use_ode_regression and args.training_config.is_only_ode_regression: + if vae is not None: + vae.to("cpu", non_blocking=True) + if text_encoder is not None: + text_encoder.to("cpu", non_blocking=True) + + _, logs = _ode_regression_loss( + args=args, + accelerator=accelerator, + transformer=transformer, + scheduler=noise_scheduler_copy, + noise=torch.randn(noisy_model_input_shape, device=accelerator.device, dtype=weight_dtype), + weight_dtype=weight_dtype, + # For Stage 1 + is_keep_x0=True, + history_sizes=args.training_config.history_sizes, + # For Stage 2 + stage2_num_stages=args.training_config.stage2_num_stages, + # For ODE Main + last_step_only=args.training_config.dmd_last_step_only, + use_dynamic_shifting=args.training_config.use_dynamic_shifting, + time_shift_type=args.training_config.time_shift_type, + is_backward_grad=True, + ode_regression_weight=args.training_config.ode_regression_weight, + ode_latents=ode_latents, + ode_prompt_embeds=ode_prompt_embeds, + ode_num_latent_sections_min=args.training_config.ode_num_latent_sections_min, + ode_num_latent_sections_max=args.training_config.ode_num_latent_sections_max, + # For Dynamic Num Sections + ode_dynamic_alpha=args.training_config.ode_dynamic_alpha, + ode_dynamic_beta=args.training_config.ode_dynamic_beta, + ode_dynamic_sample_type=args.training_config.ode_dynamic_sample_type, + global_step=global_step, + ode_dynamic_step=args.training_config.ode_dynamic_step, + ) + optimizer.step() + lr_scheduler.step() + optimizer.zero_grad(set_to_none=True) + + else: + TRAIN_GENERATOR = global_step % args.training_config.dfake_gen_update_ratio == 0 + USE_GAN = args.training_config.is_use_gan and global_step >= args.training_config.gan_start_step + USE_REWARD = ( + args.training_config.is_use_reward_model + and global_step >= args.training_config.reward_start_step + ) + USE_GT_HIST = ( + args.training_config.is_use_gt_history + and random.random() < args.training_config.use_gt_history_ratio + ) + + VISUALIZE = ( + global_step % args.training_config.log_iters == 0 and not args.training_config.no_visualize + ) + logs = {} + + if accelerator.is_main_process: + if ( + args.training_config.is_enable_cold_start + and global_step < args.training_config.cold_start_step + ): + num_rollout_sections = ( + args.training_config.dmd_num_latent_sections_min + 1 + if args.training_config.stage_cold_start_step is not None + and global_step >= args.training_config.stage_cold_start_step + else args.training_config.dmd_num_latent_sections_min + ) + else: + num_rollout_sections = sample_dynamic_dmd_num_latent_sections( + min_sections=args.training_config.dmd_num_latent_sections_min, + max_sections=args.training_config.dmd_num_latent_sections_max, + dmd_dynamic_alpha=args.training_config.dmd_dynamic_alpha, + dmd_dynamic_beta=args.training_config.dmd_dynamic_beta, + dmd_dynamic_sample_type=args.training_config.dmd_dynamic_sample_type, + global_step=global_step, + dmd_dynamic_step=args.training_config.dmd_dynamic_step, + device=accelerator.device, + ) + num_rollout_sections = torch.tensor(num_rollout_sections, device=accelerator.device) + else: + num_rollout_sections = torch.tensor(0, device=accelerator.device) + + num_rollout_sections = broadcast(num_rollout_sections, from_process=0).item() + logs["num_rollout_sections"] = num_rollout_sections + + if args.data_config.use_stage3_dataset: + prompt_raws = text_prompt_raws + prompt_embeds = text_prompt_embeds + + if TRAIN_GENERATOR: + extras_list = [] + + if USE_GAN: + for name, param in real_score_model.named_parameters(): + if name in gan_critic_trainable_params: + param.requires_grad = False + + if args.training_config.is_use_ode_regression: + if args.training_config.dmd_is_low_vram_mode: + vram_manager.move_to_cpu(real_score_model) + vram_manager.move_to_gpu(transformer, accelerator.device) + + _, ode_log_dict = _ode_regression_loss( + args=args, + accelerator=accelerator, + transformer=transformer, + scheduler=noise_scheduler_copy, + noise=torch.randn( + noisy_model_input_shape, device=accelerator.device, dtype=weight_dtype + ), + # For Stage 1 + is_keep_x0=True, + history_sizes=args.training_config.history_sizes, + # For Stage 2 + stage2_num_stages=args.training_config.stage2_num_stages, + stage2_num_inference_steps_list=args.validation_config.stage2_simulated_inference_steps, + # For ODE Main + last_step_only=args.training_config.dmd_last_step_only, + use_dynamic_shifting=args.training_config.use_dynamic_shifting, + time_shift_type=args.training_config.time_shift_type, + is_backward_grad=True, + ode_regression_weight=args.training_config.ode_regression_weight, + ode_latents=ode_latents, + ode_prompt_embeds=ode_prompt_embeds, + ode_num_latent_sections_min=args.training_config.ode_num_latent_sections_min, + ode_num_latent_sections_max=args.training_config.ode_num_latent_sections_max, + # For Dynamic ODE Length + ode_dynamic_alpha=args.training_config.ode_dynamic_alpha, + ode_dynamic_beta=args.training_config.ode_dynamic_beta, + ode_dynamic_sample_type=args.training_config.ode_dynamic_sample_type, + global_step=global_step, + ode_dynamic_step=args.training_config.ode_dynamic_step, + ) + logs.update(ode_log_dict) + + ode_log_dict = None + del ode_log_dict + + generator_loss, generator_log_dict = _generator_loss( + args=args, + accelerator=accelerator, + real_fake_score_model=real_score_model, + transformer=transformer, + scheduler=noise_scheduler_copy, + noise=torch.randn(noisy_model_input_shape, device=accelerator.device, dtype=weight_dtype), + prompt_embeds=prompt_embeds, + negative_prompt_embeds=negative_prompt_embeds, + # For VRAM manager + dmd_is_low_vram_mode=args.training_config.dmd_is_low_vram_mode, + vram_manager=vram_manager, + dmd_is_offload_grad=args.training_config.dmd_is_offload_grad, + is_gan_low_vram_mode=args.training_config.is_gan_low_vram_mode, + # For Stage 1 + is_keep_x0=True, + history_sizes=args.training_config.history_sizes, + # For Stage 2 + is_enable_stage2=args.training_config.is_enable_stage2, + stage2_num_stages=args.training_config.stage2_num_stages, + stage2_num_inference_steps_list=args.validation_config.stage2_simulated_inference_steps, + # For DMD Main + denoising_step_list=list(args.training_config.dmd_denoising_step_list), + last_step_only=args.training_config.dmd_last_step_only, + last_section_grad_only=args.training_config.dmd_last_section_grad_only, + timestep_shift=args.training_config.dmd_timestep_shift, + use_dynamic_shifting=args.training_config.use_dynamic_shifting, + time_shift_type=args.training_config.time_shift_type, + fake_guidance_scale=args.training_config.fake_guidance_scale, + real_guidance_scale=args.training_config.real_guidance_scale, + num_critic_input_frames=args.training_config.num_critic_input_frames, + num_rollout_sections=num_rollout_sections, + is_skip_first_section=args.training_config.is_skip_first_section, + is_amplify_first_chunk=args.training_config.is_amplify_first_chunk, + # For Easy Anti-Drifting + is_corrupt_history_latents=args.training_config.corrupt_history, + is_add_saturation=args.training_config.is_add_saturation, + # For GT History + is_use_gt_history=USE_GT_HIST, + gt_history_latents=gt_history_latents, + gt_target_latents=gt_target_latents, + gt_x0_latents=gt_x0_latents, + # For VAE Re-Encode + vae=vae, + is_dmd_vae_decode=args.training_config.is_dmd_vae_decode, + # For Multi Stage Backward Simulated + is_multi_pyramid_stage_backward_simulated=args.training_config.is_multi_pyramid_stage_backward_simulated, + # For Consistency Align + is_consistency_align=args.training_config.is_consistency_align, + consistentcy_align_weight=args.training_config.consistentcy_align_weight, + # For Smoothness + is_smoothness_loss=args.training_config.is_smoothness_loss, + smoothness_loss_weight=args.training_config.smoothness_loss_weight, + # For KV Cache + use_kv_cache=args.validation_config.use_kv_cache, + # For Mean-Variance Regularization + is_mean_var_regular=args.training_config.is_mean_var_regular, + mean_var_regular_weight=args.training_config.mean_var_regular_weight, + regular_mean=args.training_config.regular_mean, + regular_var=args.training_config.regular_var, + is_x0_mean_var_regular=args.training_config.is_x0_mean_var_regular, + mean_var_regular_x0_weight=args.training_config.mean_var_regular_x0_weight, + regular_x0_mean=args.training_config.regular_x0_mean, + regular_x0_var=args.training_config.regular_x0_var, + # + is_chunk_mean_var_regular=args.training_config.is_chunk_mean_var_regular, + chunk_mean_var_regular_weight=args.training_config.chunk_mean_var_regular_weight, + chunk_regular_mean=args.training_config.chunk_regular_mean, + chunk_regular_var=args.training_config.chunk_regular_var, + is_chunk_x0_mean_var_regular=args.training_config.is_chunk_x0_mean_var_regular, + chunk_mean_var_regular_x0_weight=args.training_config.chunk_mean_var_regular_x0_weight, + chunk_regular_x0_mean=args.training_config.chunk_regular_x0_mean, + chunk_regular_x0_var=args.training_config.chunk_regular_x0_var, + # For GAN + is_use_gan=USE_GAN, + gan_prompt_embeds=gan_prompt_embeds, + gan_g_weight=args.training_config.gan_g_weight, + # For Reward + is_use_reward_model=USE_REWARD, + reward_model=reward_model, + reward_weight_vq=args.training_config.reward_weight_vq, + reward_weight_mq=args.training_config.reward_weight_mq, + reward_weight_ta=args.training_config.reward_weight_ta, + reward_texts=prompt_raws, + # For Decouple DMD + is_decouple_dmd=args.training_config.is_decouple_dmd, + decouple_ca_start_step=args.training_config.decouple_ca_start_step, + decouple_ca_end_step=args.training_config.decouple_ca_end_step, + # For Dynamic Timestep + is_forcing_low_renoise=args.training_config.generator_is_forcing_low_renoise, + dynamic_alpha=args.training_config.generator_dynamic_alpha, + dynamic_beta=args.training_config.generator_dynamic_beta, + dynamic_sample_type=args.training_config.generator_dynamic_sample_type, + global_step=global_step, + dynamic_step=args.training_config.generator_dynamic_step, + ) + + accelerator.backward(generator_loss) + + generator_grad_norm = None + if accelerator.sync_gradients: + generator_params_to_clip = transformer.parameters() + generator_grad_norm = accelerator.clip_grad_norm_( + generator_params_to_clip, args.training_config.max_grad_norm + ) + + generator_log_dict["generator_loss"] = generator_loss + if generator_grad_norm is not None: + generator_log_dict["generator_grad_norm"] = generator_grad_norm + + extra = generator_log_dict + extras_list.append(extra) + generator_log_dict = merge_dict_list(extras_list) + optimizer.step() + lr_scheduler.step() + optimizer.zero_grad(set_to_none=True) + + base_logs = { + # "generator_lr": lr_scheduler.get_last_lr()[0], + "generator_loss": generator_log_dict["generator_loss"].mean().item(), + "generator_grad_norm": safe_item(generator_log_dict["generator_grad_norm"]), + } + if args.training_config.is_decouple_dmd: + base_logs.update( + { + "dmdtrain_ca_gradient_norm": safe_item( + generator_log_dict["dmdtrain_ca_gradient_norm"] + ), + "dmdtrain_dm_gradient_norm": safe_item( + generator_log_dict["dmdtrain_dm_gradient_norm"] + ), + } + ) + else: + base_logs["dmdtrain_gradient_norm"] = safe_item( + generator_log_dict["dmdtrain_gradient_norm"] + ) + logs.update(base_logs) + base_logs = None + del base_logs + + if args.training_config.is_smoothness_loss or USE_GAN or USE_REWARD: + logs["dmd_loss_raw"] = generator_log_dict["dmd_loss_raw"] + + if args.training_config.is_consistency_align: + logs["consistency_align_loss"] = generator_log_dict["consistency_align_loss"] + + if args.training_config.is_smoothness_loss: + logs["smoothness_loss"] = generator_log_dict["smoothness_loss"] + + if args.training_config.is_mean_var_regular: + logs["kl_mean_var_loss"] = generator_log_dict["kl_mean_var_loss"] + logs["pred_mean_avg"] = generator_log_dict["pred_mean_avg"] + logs["pred_var_avg"] = generator_log_dict["pred_var_avg"] + + if args.training_config.is_x0_mean_var_regular: + logs["kl_mean_var_x0_loss"] = generator_log_dict["kl_mean_var_x0_loss"] + logs["pred_x0_mean_avg"] = generator_log_dict["pred_x0_mean_avg"] + logs["pred_x0_var_avg"] = generator_log_dict["pred_x0_var_avg"] + + if args.training_config.is_chunk_mean_var_regular: + logs["kl_chunk_mean_var_loss"] = generator_log_dict["kl_chunk_mean_var_loss"] + logs["pred_chunk_mean_avg"] = generator_log_dict["pred_chunk_mean_avg"] + logs["pred_chunk_var_avg"] = generator_log_dict["pred_chunk_var_avg"] + + if args.training_config.is_chunk_x0_mean_var_regular: + logs["kl_chunk_mean_var_x0_loss"] = generator_log_dict["kl_chunk_mean_var_x0_loss"] + logs["pred_chunk_x0_mean_avg"] = generator_log_dict["pred_chunk_x0_mean_avg"] + logs["pred_chunk_x0_var_avg"] = generator_log_dict["pred_chunk_x0_var_avg"] + + if USE_GAN: + logs["gan_G_loss"] = generator_log_dict["gan_G_loss"] + + if USE_REWARD: + logs["reward_score_vq"] = generator_log_dict["reward_score_vq"] + logs["reward_score_mq"] = generator_log_dict["reward_score_mq"] + logs["reward_score_ta"] = generator_log_dict["reward_score_ta"] + + generator_loss = None + generator_grad_norm = None + del generator_loss + del generator_grad_norm + free_memory() + + if USE_GAN: + for name, param in real_score_model.named_parameters(): + if name in gan_critic_trainable_params: + param.requires_grad = True + + # Train the critic + extras_list = [] + critic_loss, critic_log_dict = _critic_loss( + args=args, + critic_accelerator=critic_accelerator, + fake_score_model=real_score_model, + transformer=transformer, + scheduler=critic_noise_scheduler, + noise=torch.randn( + noisy_model_input_shape, device=critic_accelerator.device, dtype=weight_dtype + ), + prompt_embeds=prompt_embeds, + # For VRAM manager + dmd_is_low_vram_mode=args.training_config.dmd_is_low_vram_mode, + vram_manager=vram_manager, + is_gan_low_vram_mode=args.training_config.is_gan_low_vram_mode, + # For Stage 1 + is_keep_x0=True, + history_sizes=args.training_config.history_sizes, + # For Stage 2 + is_enable_stage2=args.training_config.is_enable_stage2, + stage2_num_stages=args.training_config.stage2_num_stages, + stage2_num_inference_steps_list=args.validation_config.stage2_simulated_inference_steps, + # For DMD Main + denoising_step_list=list(args.training_config.dmd_denoising_step_list), + last_step_only=args.training_config.dmd_last_step_only, + last_section_grad_only=args.training_config.dmd_last_section_grad_only, + timestep_shift=args.training_config.dmd_timestep_shift, + use_dynamic_shifting=args.training_config.use_dynamic_shifting, + time_shift_type=args.training_config.time_shift_type, + num_critic_input_frames=args.training_config.num_critic_input_frames, + num_rollout_sections=num_rollout_sections, + is_skip_first_section=args.training_config.is_skip_first_section, + is_amplify_first_chunk=args.training_config.is_amplify_first_chunk, + # For Easy Anti-Drifting + is_corrupt_history_latents=args.training_config.corrupt_history, + is_add_saturation=args.training_config.is_add_saturation, + # GT History + is_use_gt_history=USE_GT_HIST, + gt_history_latents=gt_history_latents_2, + gt_target_latents=gt_target_latents_2, + gt_x0_latents=gt_x0_latents_2, + # For VAE Re-Encode + vae=vae, + is_dmd_vae_decode=args.training_config.is_dmd_vae_decode, + # For Multi Stage Backward Simulated + is_multi_pyramid_stage_backward_simulated=args.training_config.is_multi_pyramid_stage_backward_simulated, + # For KV Cache + use_kv_cache=args.validation_config.use_kv_cache, + # For GAN + is_use_gan=USE_GAN, + is_separate_gan_grad=args.training_config.is_separate_gan_grad, + gan_base_critic_trainable_params=gan_base_critic_trainable_params, + gan_extra_critic_trainable_params=gan_extra_critic_trainable_params, + gan_vae_latents=gan_vae_latents, + gan_prompt_embeds=gan_prompt_embeds, + gan_d_weight=args.training_config.gan_d_weight, + aprox_r1=args.training_config.aprox_r1, + aprox_r2=args.training_config.aprox_r2, + r1_weight=args.training_config.r1_weight, + r2_weight=args.training_config.r2_weight, + r1_sigma=args.training_config.r1_sigma, + r2_sigma=args.training_config.r2_sigma, + # For Dynamic Timestep + dynamic_alpha=args.training_config.critic_dynamic_alpha, + dynamic_beta=args.training_config.critic_dynamic_beta, + dynamic_sample_type=args.training_config.critic_dynamic_sample_type, + global_step=global_step, + dynamic_step=args.training_config.critic_dynamic_step, + ) + if not ( + USE_GAN + and (args.training_config.is_gan_aprox_grad or args.training_config.is_gan_low_vram_mode) + ): + critic_accelerator.backward(critic_loss) + + critic_grad_norm = None + if critic_accelerator.sync_gradients: + critic_params_to_clip = real_score_model.parameters() + critic_grad_norm = critic_accelerator.clip_grad_norm_( + critic_params_to_clip, args.training_config.max_grad_norm_critic + ) + + critic_log_dict["critic_loss"] = critic_loss + if critic_grad_norm is not None: + critic_log_dict["critic_grad_norm"] = critic_grad_norm + + extra = critic_log_dict + extras_list.append(extra) + critic_log_dict = merge_dict_list(extras_list) + critic_optimizer.step() + critic_lr_scheduler.step() + critic_optimizer.zero_grad(set_to_none=True) + + if args.training_config.use_ema and ema_transformer is not None: + if ( + global_step < args.training_config.ema_start_step + or not args.training_config.is_train_dmd + or TRAIN_GENERATOR + ): + if args.training_config.dmd_is_low_vram_mode: + vram_manager.move_to_cpu(real_score_model) + vram_manager.move_to_gpu(transformer, accelerator.device) + + logs.update( + { + # "critic_lr": critic_lr_scheduler.get_last_lr()[0], + "critic_loss": critic_log_dict["critic_loss"].mean().item(), + "critic_grad_norm": safe_item(critic_log_dict["critic_grad_norm"]), + } + ) + if USE_GAN: + logs.update( + { + "denoising_loss": critic_log_dict["denoising_loss"], + "gan_D_loss": critic_log_dict["gan_D_loss"], + "r1_loss": critic_log_dict["r1_loss"], + "r2_loss": critic_log_dict["r2_loss"], + } + ) + + critic_loss = None + critic_grad_norm = None + del critic_loss + del critic_grad_norm + free_memory() + + batch = None + model_input = None + prompt_embeds = None + indices_hidden_states = None + indices_latents_history_short = None + indices_latents_history_mid = None + indices_latents_history_long = None + latents_history_short = None + latents_history_mid = None + latents_history_long = None + gan_vae_latents = None + gan_prompt_embeds = None + gt_history_latents = None + gt_target_latents = None + gt_x0_latents = None + gt_history_latents_2 = None + gt_target_latents_2 = None + gt_x0_latents_2 = None + ode_latents = None + ode_prompt_embeds = None + text_prompt_raws = None + text_prompt_embeds = None + del batch + del model_input + del prompt_embeds + del indices_hidden_states + del indices_latents_history_short + del indices_latents_history_mid + del indices_latents_history_long + del latents_history_short + del latents_history_mid + del latents_history_long + del gan_vae_latents + del gan_prompt_embeds + del gt_history_latents + del gt_target_latents + del gt_x0_latents + del gt_history_latents_2 + del gt_target_latents_2 + del gt_x0_latents_2 + del ode_latents + del ode_prompt_embeds + del text_prompt_raws + del text_prompt_embeds + free_memory() + + # Checks if the accelerator has performed an optimization step behind the scenes + if accelerator.sync_gradients: + if args.training_config.use_ema and ema_transformer is not None: + if ( + global_step < args.training_config.ema_start_step + or not args.training_config.is_train_dmd + or TRAIN_GENERATOR + ): + ema_transformer.step(transformer.parameters()) + + progress_bar.update(1) + global_step += 1 + + if args.training_config.is_train_dmd: + if accelerator.is_main_process and VISUALIZE: + phase_name = "dmd_visualize" + if args.training_config.dmd_is_low_vram_mode: + vram_manager.move_to_cpu(transformer) + vram_manager.move_to_cpu(real_score_model) + + if vae is None: + vae = AutoencoderKLWan.from_pretrained( + args.model_config.pretrained_model_name_or_path, + subfolder="vae", + revision=args.model_config.revision, + variant=args.model_config.variant, + torch_dtype=torch.float32, + device_map=accelerator.device, + ) + if args.model_config.enable_slicing: + vae.enable_slicing() + if args.model_config.enable_tiling: + vae.enable_tiling() + + if args.training_config.dmd_is_low_vram_mode and args.training_config.is_dmd_vae_decode: + vram_manager.move_to_gpu(vae, accelerator.device) + else: + vae.to(accelerator.device, non_blocking=True) + latents_mean = ( + torch.tensor(vae.config.latents_mean) + .view(1, vae.config.z_dim, 1, 1, 1) + .to(vae.device, vae.dtype) + ) + latents_std = 1.0 / torch.tensor(vae.config.latents_std).view(1, vae.config.z_dim, 1, 1, 1).to( + vae.device, vae.dtype + ) + + for tracker in accelerator.trackers: + if tracker.name == "wandb": + video_logs = [] + + def decode_latent(latent): + with torch.no_grad(): + latent = latent[0:1] # [1, C, T, H, W] + latent = latent / latents_std + latents_mean + return vae.decode(latent)[0] # [1, C, T, H, W] + + def prepare_for_saving(tensor, fps=30, caption=None): + tensor = (tensor * 0.5 + 0.5).clamp(0, 1).detach() + tensor = tensor.permute(0, 2, 1, 3, 4) + video_array = (tensor * 255).cpu().numpy().astype(np.uint8) + return wandb.Video(video_array, fps=fps, format="mp4", caption=caption) + + log_configs = [ + ( + critic_log_dict, + ["critictrain_latent", "critictrain_noisy_latent", "critictrain_pred_image"], + ), + ] + generator_keys = [ + "dmdtrain_clean_latent", + "dmdtrain_pred_real_image", + "dmdtrain_pred_fake_image", + ] + if args.training_config.is_decouple_dmd: + generator_keys.extend(["dmdtrain_ca_noisy_latent", "dmdtrain_dm_noisy_latent"]) + else: + generator_keys.append("dmdtrain_noisy_latent") + log_configs.append((generator_log_dict, generator_keys)) + for log_dict, keys in log_configs: + for key in keys: + if key in log_dict: + with torch.no_grad(): + decoded = decode_latent(log_dict[key]) + video_logs.append(prepare_for_saving(decoded, fps=30, caption=key)) + del decoded + + tracker.log({phase_name: video_logs}, step=global_step) + + if ( + args.training_config.is_train_dmd and args.training_config.dmd_is_low_vram_mode + ) or args.data_config.use_stage3_dataset: + if ( + not args.training_config.is_dmd_vae_decode + and not args.training_config.is_use_reward_model + and not args.training_config.is_smoothness_loss + ): + vae = None + free_memory() + + if vae is not None: + vae.to("cpu", non_blocking=True) + + optimizer.zero_grad(set_to_none=True) + critic_optimizer.zero_grad(set_to_none=True) + if "generator_log_dict" in locals(): + generator_log_dict.clear() + del generator_log_dict + if "critic_log_dict" in locals(): + critic_log_dict.clear() + del critic_log_dict + if "video_logs" in locals(): + del video_logs + if "log_configs" in locals(): + del log_configs + free_memory() + + if global_step % args.training_config.checkpointing_steps == 0: + save_path = os.path.join(args.output_dir, f"checkpoint-{global_step}") + + states = { + "dataloader": train_dataloader, + } + dcp_dir = os.path.join(save_path, "distributed_checkpoint") + dcp.save(states, checkpoint_id=dcp_dir) + states = None + del states + free_memory() + + if accelerator.is_main_process or accelerator.distributed_type == DistributedType.DEEPSPEED: + # _before_ saving state, check if this save would set us over the `checkpoints_total_limit` + if args.training_config.checkpoints_total_limit is not None: + checkpoints = os.listdir(args.output_dir) + checkpoints = [d for d in checkpoints if d.startswith("checkpoint")] + checkpoints = sorted(checkpoints, key=lambda x: int(x.split("-")[1])) + + # before we save the new checkpoint, we need to have at _most_ `checkpoints_total_limit - 1` checkpoints + if len(checkpoints) >= args.training_config.checkpoints_total_limit: + num_to_remove = len(checkpoints) - args.training_config.checkpoints_total_limit + 1 + removing_checkpoints = checkpoints[0:num_to_remove] + + logger.info( + f"{len(checkpoints)} checkpoints already exist, removing {len(removing_checkpoints)} checkpoints" + ) + accelerator.print(f"removing checkpoints: {', '.join(removing_checkpoints)}") + + for removing_checkpoint in removing_checkpoints: + removing_checkpoint = os.path.join(args.output_dir, removing_checkpoint) + shutil.rmtree(removing_checkpoint) + + if args.training_config.save_checkpoints_custom: + if accelerator.is_main_process: + save_model_checkpoint( + transformer=transformer, + args=args, + save_path=save_path, + weight_dtype=weight_dtype, + unwrap_model_fn=unwrap_model, + get_peft_model_state_dict_fn=get_peft_model_state_dict, + collate_lora_metadata_fn=_collate_lora_metadata, + save_extra_components_fn=save_extra_components, + pipeline_class=HeliosPipeline, + norm_layer_prefixes=NORM_LAYER_PREFIXES, + ) + if args.training_config.is_train_dmd: + save_model_checkpoint( + transformer=real_score_model, + args=args, + save_path=os.path.join(save_path, "critic"), + weight_dtype=weight_dtype, + unwrap_model_fn=unwrap_model, + get_peft_model_state_dict_fn=get_peft_model_state_dict, + collate_lora_metadata_fn=_collate_lora_metadata, + save_extra_components_fn=save_extra_components, + pipeline_class=HeliosPipeline, + norm_layer_prefixes=NORM_LAYER_PREFIXES, + ) + else: + accelerator.save_state(save_path) + if args.training_config.is_train_dmd: + critic_accelerator.save_state(os.path.join(save_path, "critic")) + accelerator.print(f"Saved state to {save_path}") + + if args.training_config.use_ema and ema_transformer is not None: + ema_transformer.save_pretrained( + args, + os.path.join(save_path, "model_ema"), + args.model_config.transformer_model_name_or_path, + lora_config=transformer_lora_config, + transformer_additional_kwargs=transformer_additional_kwargs, + ) + + if ( + args.validation_config.validation_prompts is not None + and global_step % args.validation_config.validation_steps == 0 + ) or (args.validation_config.first_step_valid and global_step == (initial_global_step + 1)): + if args.training_config.is_train_dmd and args.training_config.dmd_is_low_vram_mode: + vram_manager.move_to_cpu(real_score_model) + + if args.training_config.is_train_dmd: + optimizer.zero_grad(set_to_none=True) + critic_optimizer.zero_grad(set_to_none=True) + + if "generator_log_dict" in locals(): + generator_log_dict.clear() + del generator_log_dict + if "critic_log_dict" in locals(): + critic_log_dict.clear() + del critic_log_dict + + free_memory() + + if ( + args.training_config.use_ema_validation + and args.training_config.use_ema + and ema_transformer is not None + and global_step >= args.training_config.ema_start_step + ): + accelerator.print("Starting EMA store and copy_to...") + ema_transformer.store(transformer.parameters()) + ema_state_dict = gather_zero3ema(accelerator, ema_transformer) + transformer.load_state_dict({"module." + k: v for k, v in ema_state_dict.items()}) + accelerator.print("EMA store and copy_to completed") + ema_state_dict = None + del ema_state_dict + + free_memory() + if accelerator.is_main_process: + with torch.no_grad(): + if vae is None: + vae = AutoencoderKLWan.from_pretrained( + args.model_config.pretrained_model_name_or_path, + subfolder="vae", + revision=args.model_config.revision, + variant=args.model_config.variant, + torch_dtype=torch.float32, + device_map=accelerator.device, + ) + if args.model_config.enable_slicing: + vae.enable_slicing() + if args.model_config.enable_tiling: + vae.enable_tiling() + + if text_encoder is None: + text_encoder = UMT5EncoderModel.from_pretrained( + args.model_config.pretrained_model_name_or_path, + subfolder="text_encoder", + revision=args.model_config.revision, + variant=args.model_config.variant, + dtype=weight_dtype, + device_map=accelerator.device, + ) + + if args.data_config.use_stage1_dataset or args.training_config.offload: + vae.to(accelerator.device, non_blocking=True) + text_encoder.to(accelerator.device, non_blocking=True) + + pipe = HeliosPipeline.from_pretrained( + args.model_config.pretrained_model_name_or_path, + vae=vae, + transformer=unwrap_model(transformer), + tokenizer=tokenizer, + text_encoder=text_encoder, + scheduler=noise_scheduler, + revision=args.model_config.revision, + variant=args.model_config.variant, + torch_dtype=weight_dtype, + ) + + all_videos = [] + all_prompts = [] + for validation_prompt in args.validation_config.validation_prompts: + pipeline_args = { + "prompt": args.data_config.id_token + validation_prompt, + "negative_prompt": "Bright tones, overexposed, static, blurred details, subtitles, style, works, paintings, images, static, overall gray, worst quality, low quality, JPEG compression residue, ugly, incomplete, extra fingers, poorly drawn hands, poorly drawn faces, deformed, disfigured, misshapen limbs, fused fingers, still picture, messy background, three legs, many people in the background, walking backwards", + "guidance_scale": args.validation_config.validation_guidance_scale, + "num_frames": args.validation_config.validation_max_num_frames, + "height": args.validation_config.validation_height, + "width": args.validation_config.validation_width, + "num_inference_steps": args.validation_config.num_inference_steps, + # ---- Dynamic Shifting ---- + "use_dynamic_shifting": args.validation_config.use_dynamic_shifting, + "time_shift_type": args.validation_config.time_shift_type, + # For Stage 1 + "history_sizes": args.training_config.history_sizes, + "latent_window_size": args.validation_config.validation_latent_window_size[0], + "is_keep_x0": True, + "use_kv_cache": args.validation_config.use_kv_cache, + # For Stage 2 + "is_enable_stage2": args.training_config.is_enable_stage2, + "stage2_num_stages": args.training_config.stage2_num_stages, + "stage2_num_inference_steps_list": args.validation_config.stage2_simulated_inference_steps, + "vae_decode_type": args.training_config.vae_decode_type, + # For Stage 3 + "use_dmd": args.training_config.is_train_dmd, + "is_amplify_first_chunk": args.training_config.is_amplify_first_chunk, + } + + videos, prompt = log_validation( + pipe=pipe, + args=args, + accelerator=accelerator, + pipeline_args=pipeline_args, + ) + + all_videos.extend(videos) + all_prompts.extend([prompt] * len(videos)) + + for tracker in accelerator.trackers: + phase_name = "validation" + if tracker.name == "wandb": + video_logs = [] + + for i, (video, prompt) in enumerate(zip(all_videos, all_prompts)): + filename = os.path.join( + args.output_dir, + f"global_step{global_step}_{phase_name}_video_{i}_{prompt[:25].replace(' ', '_')}.mp4", + ) + export_to_video(video, filename, fps=30) + video_logs.append( + wandb.Video(filename, caption=f"{i}: {prompt}", format="mp4") + ) + + tracker.log({phase_name: video_logs}, step=global_step) + + videos = None + prompt = None + all_videos = None + all_prompts = None + video_logs = None + del videos + del prompt + del all_videos + del all_prompts + del video_logs + free_memory() + + if ( + args.training_config.is_train_dmd and args.training_config.dmd_is_low_vram_mode + ) or args.data_config.use_stage3_dataset: + if ( + not args.training_config.is_dmd_vae_decode + and not args.training_config.is_use_reward_model + and not args.training_config.is_smoothness_loss + ): + vae = None + text_encoder = None + free_memory() + + del pipe + free_memory() + + if ( + args.training_config.use_ema_validation + and args.training_config.use_ema + and ema_transformer is not None + and global_step >= args.training_config.ema_start_step + ): + accelerator.wait_for_everyone() + ema_transformer.restore(transformer.parameters()) + + if args.data_config.use_stage1_dataset: + if vae is not None: + vae.to("cpu", non_blocking=True) + if text_encoder is not None: + text_encoder.to("cpu", non_blocking=True) + free_memory() + + if args.training_config.offload: + if vae is not None: + vae.to(accelerator.device, non_blocking=True) + if text_encoder is not None: + text_encoder.to(accelerator.device, non_blocking=True) + + if prof is not None: + prof.step() + + progress_bar.set_postfix(**logs) + accelerator.log(logs, step=global_step) + + if global_step >= args.training_config.max_train_steps: + break + + logs = None + del logs + free_memory() + + if prof is not None: + prof.stop() + print(f"Profiler stopped. Check results in: {args.training_config.profile_out_dir}") + + # Save the lora layers + if args.training_config.is_train_dmd: + real_score_model.to("cpu", non_blocking=True) + accelerator.wait_for_everyone() + save_path = os.path.join(args.output_dir, f"checkpoint-{global_step}-final") + if args.training_config.use_ema and ema_transformer is not None: + ema_transformer.save_pretrained( + args, + os.path.join(save_path, "model_ema"), + args.model_config.transformer_model_name_or_path, + lora_config=transformer_lora_config, + transformer_additional_kwargs=transformer_additional_kwargs, + ) + if accelerator.is_main_process: + modules_to_save = {} + model_to_save = unwrap_model(transformer) + original_dtype = next(model_to_save.parameters()).dtype + if args.model_config.bnb_quantization_config_path is None: + if args.training_config.upcast_before_saving: + model_to_save.to(torch.float32) + else: + model_to_save.to(weight_dtype) + transformer_lora_layers = get_peft_model_state_dict(model_to_save) + if args.model_config.train_norm_layers: + transformer_norm_layers = { + f"transformer.{name}": param + for name, param in model_to_save.named_parameters() + if any(k in name for k in NORM_LAYER_PREFIXES) + } + transformer_lora_layers = { + **transformer_lora_layers, + **transformer_norm_layers, + } + modules_to_save["transformer"] = model_to_save + + HeliosPipeline.save_lora_weights( + save_directory=save_path, + transformer_lora_layers=transformer_lora_layers, + **_collate_lora_metadata(modules_to_save), + ) + save_extra_components(args, model=model_to_save, output_dir=save_path) + model_to_save.to(original_dtype) + + if args.training_config.use_ema and ema_transformer is not None: + ema_state_dict = gather_zero3ema(accelerator, ema_transformer) + transformer.load_state_dict(ema_state_dict) + + # Run a final round of validation. + # Setting `vae`, `unet`, and `controlnet` to None to load automatically from `args.output_dir`. + if args.validation_config.validation_prompts is not None: + with torch.no_grad(): + if vae is None: + vae = AutoencoderKLWan.from_pretrained( + args.model_config.pretrained_model_name_or_path, + subfolder="vae", + revision=args.model_config.revision, + variant=args.model_config.variant, + torch_dtype=torch.float32, + device_map=accelerator.device, + ) + if args.model_config.enable_slicing: + vae.enable_slicing() + if args.model_config.enable_tiling: + vae.enable_tiling() + + if text_encoder is None: + text_encoder = UMT5EncoderModel.from_pretrained( + args.model_config.pretrained_model_name_or_path, + subfolder="text_encoder", + revision=args.model_config.revision, + variant=args.model_config.variant, + dtype=weight_dtype, + device_map=accelerator.device, + ) + + if args.data_config.use_stage1_dataset: + vae.to(accelerator.device, non_blocking=True) + text_encoder.to(accelerator.device, non_blocking=True) + + pipe = HeliosPipeline.from_pretrained( + args.model_config.pretrained_model_name_or_path, + vae=vae, + transformer=unwrap_model(transformer), + tokenizer=tokenizer, + text_encoder=text_encoder, + scheduler=noise_scheduler, + revision=args.model_config.revision, + variant=args.model_config.variant, + torch_dtype=weight_dtype, + ) + + all_videos = [] + all_prompts = [] + for validation_prompt in args.validation_config.validation_prompts: + pipeline_args = { + "prompt": args.data_config.id_token + validation_prompt, + "negative_prompt": "Bright tones, overexposed, static, blurred details, subtitles, style, works, paintings, images, static, overall gray, worst quality, low quality, JPEG compression residue, ugly, incomplete, extra fingers, poorly drawn hands, poorly drawn faces, deformed, disfigured, misshapen limbs, fused fingers, still picture, messy background, three legs, many people in the background, walking backwards", + "guidance_scale": args.validation_config.validation_guidance_scale, + "num_frames": args.validation_config.validation_max_num_frames, + "height": args.validation_config.validation_height, + "width": args.validation_config.validation_width, + "num_inference_steps": args.validation_config.num_inference_steps, + # ---- Dynamic Shifting ---- + "use_dynamic_shifting": args.validation_config.use_dynamic_shifting, + "time_shift_type": args.validation_config.time_shift_type, + # For Stage 1 + "history_sizes": args.training_config.history_sizes, + "latent_window_size": args.validation_config.validation_latent_window_size[0], + "is_keep_x0": True, + "use_kv_cache": args.validation_config.use_kv_cache, + # For Stage 2 + "is_enable_stage2": args.training_config.is_enable_stage2, + "stage2_num_stages": args.training_config.stage2_num_stages, + "stage2_num_inference_steps_list": args.validation_config.stage2_simulated_inference_steps, + "vae_decode_type": args.training_config.vae_decode_type, + # For Stage 3 + "use_dmd": args.training_config.is_train_dmd, + "is_amplify_first_chunk": args.training_config.is_amplify_first_chunk, + } + videos, prompt = log_validation( + pipe=pipe, + args=args, + accelerator=accelerator, + pipeline_args=pipeline_args, + ) + + all_videos.extend(videos) + all_prompts.extend([prompt] * len(videos)) + + for tracker in accelerator.trackers: + phase_name = "final_step_validation" + if tracker.name == "wandb": + video_logs = [] + + for i, (video, prompt) in enumerate(zip(all_videos, all_prompts)): + filename = os.path.join( + args.output_dir, + f"global_step{global_step}_{phase_name}_video_{i}_{prompt[:25].replace(' ', '_')}.mp4", + ) + export_to_video(video, filename, fps=30) + video_logs.append(wandb.Video(filename, caption=f"{i}: {prompt}", format="mp4")) + + tracker.log({phase_name: video_logs}, step=global_step) + + accelerator.end_training() + + +@torch.no_grad() +def log_validation( + pipe, + args, + accelerator, + pipeline_args, +): + logger.info( + f"Running validation... \n Generating {args.validation_config.num_validation_videos} videos with prompt: {pipeline_args['prompt']}." + ) + + pipe = pipe.to(accelerator.device) + + # run inference + generator = torch.Generator(device=accelerator.device).manual_seed(args.seed) if args.seed else None + + videos = [] + for _ in range(args.validation_config.num_validation_videos): + video = pipe(**pipeline_args, generator=generator, output_type="np").frames[0] + videos.append(video) + + del pipe + free_memory() + + return videos, pipeline_args["prompt"] + + +if __name__ == "__main__": + from omegaconf import OmegaConf + + parser = argparse.ArgumentParser() + parser.add_argument("--config", type=str, required=True) + args = parser.parse_args() + + config = OmegaConf.load(args.config) + schema = OmegaConf.structured(Args) + conf = OmegaConf.merge(schema, config) + + global_rank = int(os.environ.get("RANK", -1)) + env_local_rank = int(os.environ.get("LOCAL_RANK", -1)) + if env_local_rank != -1 and env_local_rank != conf.training_config.local_rank: + conf.training_config.local_rank = env_local_rank + + assert ( + len(conf.validation_config.validation_latent_window_size) == 1 + and len(conf.validation_config.validation_stream_chunk_size) == 1 + ), "Only a single value is currently supported for validation_latent_window_size and validation_stream_chunk_size" + + assert not (conf.data_config.use_stage1_dataset and conf.training_config.offload), ( + "use_stage1_dataset and offload cannot both be True" + ) + + assert not (conf.data_config.use_stage1_dataset and conf.training_config.offload), ( + "use_stage1_dataset and offload cannot both be True" + ) + + if conf.model_config.lora_layers is not None: + assert len(conf.model_config.lora_target_modules) == 0, ( + f"Error: lora_target_modules length is {len(conf.model_config.lora_target_modules)}, expected 0 when lora_layers is not None." + ) + + if conf.training_config.efficient_sample: + assert conf.training_config.pyramid_sample_mode == "full", ( + f"efficient_sample requires pyramid_sample_mode='full', got '{conf.training_config.pyramid_sample_mode}'" + ) + + if conf.data_config.dataset_sampling_ratios: + assert conf.data_config.use_stage1_dataset, ( + "dataset_sampling_ratios is only supported when use_stage1_dataset=True" + ) + if len(conf.data_config.instance_data_root) != len(conf.data_config.dataset_sampling_ratios): + raise ValueError( + f"Length mismatch: instance_data_root ({len(conf.data_config.instance_data_root)}) " + f"vs dataset_sampling_ratios ({len(conf.data_config.dataset_sampling_ratios)})" + ) + + basenames = [] + for temp_key, temp_value in zip(conf.data_config.instance_data_root, conf.data_config.dataset_sampling_ratios): + basename = temp_key.rstrip("/") + if basename in basenames: + raise ValueError(f"Duplicate dataset name: {basename}") + basenames.append(basename) + + if conf.data_config.single_res: + assert conf.data_config.force_rebuild, "force_rebuild must be True when single_res is enabled" + + # ---------------------- For Wan ---------------------- + if ( + conf.training_config.is_train_full_multi_term_memory_patchg + or conf.training_config.is_train_lora_multi_term_memory_patchg + or conf.training_config.zero_history_timestep + ): + assert conf.training_config.has_multi_term_memory_patch, "Missing clean patch embedding configuration." + assert conf.training_config.is_enable_stage1, ( + "is_enable_stage1 must be enabled when using clean patch embedding." + ) + + if conf.training_config.restrict_lora: + assert conf.training_config.restrict_self_attn, ( + "Self-attention restriction must be enabled when restricting LoRA." + ) + + if conf.training_config.is_train_restrict_lora: + assert conf.training_config.restrict_lora, ( + "LoRA restriction must be enabled when training with LoRA restriction." + ) + + assert not ( + conf.training_config.is_train_full_multi_term_memory_patchg + and conf.training_config.is_train_lora_multi_term_memory_patchg + ), ( + "Both 'is_train_full_multi_term_memory_patchg' and 'is_train_lora_multi_term_memory_patchg' cannot be True at the same time." + ) + assert not ( + conf.training_config.is_train_full_patch_embedding and conf.training_config.is_train_lora_patch_embedding + ), "Both 'is_train_full_patch_embedding' and 'is_train_lora_patch_embedding' cannot be True at the same time." + + assert not (conf.training_config.use_error_recycling and conf.training_config.corrupt_history), ( + "Both 'use_error_recycling' and 'corrupt_history' cannot be True at the same time." + ) + + if conf.training_config.is_enable_stage2: + if not conf.training_config.is_train_dmd and not conf.training_config.is_use_ode_regression: + assert conf.training_config.use_dynamic_shifting is False, ( + "Dynamic shifting cannot be used with pyramid sampling unless is_train_dmd or is_use_ode_regression is True." + ) + + if conf.training_config.is_use_ode_regression: + assert conf.training_config.use_dynamic_shifting, ( + "use_dynamic_shifting must be True when is_use_ode_regression is enabled." + ) + + if conf.validation_config.use_kv_cache: + assert conf.training_config.restrict_self_attn, "When use_kv_cache=True, restrict_self_attn must also be True!" + + assert not (conf.training_config.use_error_recycling and conf.training_config.corrupt_history), ( + "Both 'use_error_recycling' and 'corrupt_history' cannot be True at the same time." + ) + + assert not (conf.training_config.use_error_recycling and conf.training_config.corrupt_model_input), ( + "Both 'use_error_recycling' and 'corrupt_model_input' cannot be True at the same time." + ) + + if conf.training_config.is_multi_pyramid_stage_backward_simulated: + assert conf.training_config.is_enable_stage2, ( + "Multi_Pyramid_Stage_Backward_Simulated requires is_enable_stage2 to be enabled" + ) + + if conf.training_config.use_ema_validation: + assert conf.training_config.use_ema, "EMA validation requires use_ema to be enabled" + + if conf.training_config.is_use_reward_model: + assert conf.training_config.reward_weight_vq > 0 or conf.training_config.reward_weight_mq > 0, ( + "At least one of reward_weight_vq or reward_weight_mq must be greater than 0 when using reward model" + ) + + if conf.training_config.is_use_gan: + assert conf.training_config.is_train_dmd, "GAN training requires is_train_dmd to be enabled" + assert conf.training_config.is_use_gan_hooks or conf.training_config.is_use_gan_final, ( + "GAN training requires either is_use_gan_hooks or is_use_gan_final to be enabled" + ) + + if conf.training_config.stage_cold_start_step is not None: + assert conf.training_config.stage_cold_start_step <= conf.training_config.cold_start_step, ( + f"stage_cold_start_step ({conf.training_config.stage_cold_start_step}) must be less than or equal to cold_start_step ({conf.training_config.cold_start_step})" + ) + + if conf.training_config.is_decouple_dmd: + assert conf.training_config.decouple_ca_start_step >= conf.training_config.generator_dynamic_step, ( + "decouple_ca_start_step must be greater than or equal to generator_dynamic_step" + ) + + assert conf.training_config.decouple_ca_end_step >= conf.training_config.generator_dynamic_step, ( + "decouple_ca_end_step must be greater than or equal to generator_dynamic_step" + ) + + main(conf)