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)