import argparse import copy import logging import math import os import os.path as osp import pathlib import random import time import warnings from collections import OrderedDict from datetime import datetime from pathlib import Path import diffusers import mlflow import torch import torch.nn as nn import torch.nn.functional as F import torch.utils.checkpoint import transformers from accelerate import Accelerator from accelerate.logging import get_logger from accelerate.utils import DistributedDataParallelKwargs from diffusers import AutoencoderKL, DDIMScheduler from diffusers.optimization import get_scheduler from einops import rearrange from omegaconf import OmegaConf from tqdm.auto import tqdm from transformers import Wav2Vec2Model, Wav2Vec2Processor from diffusers.utils.import_utils import is_torch_npu_available from accelerate.utils import ProjectConfiguration, set_seed from dataset import TalkingFaceVideo from modules import UNet2DConditionModel, UNet3DConditionModel, VKpsGuider, AudioProjection, ReferenceAttentionControl from utils import seed_everything from pipelines.utils import zero_module from pipelines import VExpressPipeline from pipelines.context import compute_context_indices, compute_num_context from pipelines.utils import save_video from dataset.utils import draw_kps_image from PIL import Image import torchaudio from insightface.app import FaceAnalysis import cv2 from datetime import datetime warnings.filterwarnings("ignore") logger = get_logger(__name__, log_level="INFO") class Net(nn.Module): def __init__( self, reference_net: UNet2DConditionModel, denoising_unet: UNet3DConditionModel, v_kps_guider: VKpsGuider, audio_projection: AudioProjection, reference_control_writer: ReferenceAttentionControl, reference_control_reader: ReferenceAttentionControl, device, weight_dtype, kps_drop_rate: float = 0.0, ): super().__init__() self.reference_net = reference_net self.denoising_unet = denoising_unet self.v_kps_guider = v_kps_guider self.audio_projection = audio_projection self.reference_control_writer = reference_control_writer self.reference_control_reader = reference_control_reader self.device = device self.weight_dtype = weight_dtype self.kps_drop_rate = kps_drop_rate def forward( self, noisy_latents, timesteps, reference_image_latents, audio_frame_embeddings, kps_images, do_unconditional_forward: bool = False, ): kps_features = self.v_kps_guider(kps_images) if do_unconditional_forward: kps_features = torch.zeros_like(kps_features) elif self.kps_drop_rate != 0.0: drop_mask = torch.rand(kps_features.shape[0]) < self.kps_drop_rate kps_features[drop_mask, ...] = 0. batch_size, num_frames, num_embeds, dim = audio_frame_embeddings.shape audio_frame_embeddings = audio_frame_embeddings.reshape(-1, num_embeds, dim) audio_frame_embeddings = self.audio_projection(audio_frame_embeddings) _, num_embeds, dim = audio_frame_embeddings.shape audio_frame_embeddings = audio_frame_embeddings.reshape(batch_size, num_frames, num_embeds, dim) if do_unconditional_forward: audio_frame_embeddings = torch.zeros_like(audio_frame_embeddings) ref_timesteps = torch.zeros_like(timesteps) ref_encoder_hidden_states = torch.zeros( (batch_size, 1, 768), dtype=kps_features.dtype, device=kps_features.device, ) self.reference_net( reference_image_latents, ref_timesteps, encoder_hidden_states=ref_encoder_hidden_states, return_dict=False, ) self.reference_control_reader.update( self.reference_control_writer, do_classifier_free_guidance=False, do_unconditional_forward=do_unconditional_forward, dtype=self.weight_dtype, ) model_pred = self.denoising_unet( noisy_latents, timesteps, kps_features=kps_features, encoder_hidden_states=audio_frame_embeddings.reshape(-1, num_embeds, dim), ).sample return model_pred def get_denoising_unet_state_dict(old_state_dict, state_dict_type): new_denoising_unet_state_dict = copy.deepcopy(old_state_dict) if state_dict_type == 'old_attn': for name in old_state_dict.keys(): if 'norm1' in name: new_denoising_unet_state_dict[name.replace('norm1', 'norm1_5')] = old_state_dict[name] if 'attn1' in name: new_denoising_unet_state_dict[name.replace('attn1', 'attn1_5')] = old_state_dict[name] if 'attn2.to_q' in name: new_denoising_unet_state_dict[name] = old_state_dict[name.replace( 'attn2.to_q', 'attn2.processor.to_q_aud' )] if 'attn2.to_k' in name: new_denoising_unet_state_dict[name] = old_state_dict[name.replace( 'attn2.to_k', 'attn2.processor.to_k_aud' )] if 'attn2.to_v' in name: new_denoising_unet_state_dict[name] = old_state_dict[name.replace( 'attn2.to_v', 'attn2.processor.to_v_aud' )] if 'attn2.to_out' in name: new_denoising_unet_state_dict[name] = old_state_dict[name.replace( 'attn2.to_out', 'attn2.processor.to_out_aud' )] elif state_dict_type == 'moore_pretrained': for name in old_state_dict.keys(): if 'norm1' in name: new_denoising_unet_state_dict[name.replace('norm1', 'norm1_5')] = old_state_dict[name] if 'attn1' in name: new_denoising_unet_state_dict[name.replace('attn1', 'attn1_5')] = old_state_dict[name] elif state_dict_type == 'new_attn': pass else: raise ValueError(f'The state_dict_type {state_dict_type} is not supported. ' f'Only support "moore_pretrained", "old_attn", and "new_attn".') return new_denoising_unet_state_dict def get_module_params(module): params = list(module.parameters()) num_params = sum(p.numel() for p in params) / 1e6 params_trainable = list(filter(lambda p: p.requires_grad, module.parameters())) num_trainable_params = sum(p.numel() for p in params_trainable) / 1e6 return num_params, num_trainable_params def count_params(net: Net): num_params, num_trainable_params = get_module_params(net.reference_net) logger.info(f"#parameters of ReferenceNet is {num_params:.3f} M ({num_trainable_params:.3f} M is trainable).") num_params, num_trainable_params = get_module_params(net.denoising_unet) logger.info(f"#parameters of Denoising U-Net is {num_params:.3f} M ({num_trainable_params:.3f} M is trainable).") num_params, num_trainable_params = get_module_params(net.v_kps_guider) logger.info(f"#parameters of V-Kps Guider is {num_params:.3f} M ({num_trainable_params:.3f} M is trainable).") num_params, num_trainable_params = get_module_params(net.audio_projection) logger.info(f"#parameters of Audio Projection is {num_params:.3f} M ({num_trainable_params:.3f} M is trainable).") def compute_snr(noise_scheduler, timesteps): """ Computes SNR as per https://github.com/TiankaiHang/Min-SNR-Diffusion-Training/blob/521b624bd70c67cee4bdf49225915f5945a872e3/guided_diffusion/gaussian_diffusion.py#L847-L849 """ alphas_cumprod = noise_scheduler.alphas_cumprod sqrt_alphas_cumprod = alphas_cumprod ** 0.5 sqrt_one_minus_alphas_cumprod = (1.0 - alphas_cumprod) ** 0.5 # Expand the tensors. # Adapted from https://github.com/TiankaiHang/Min-SNR-Diffusion-Training/blob/521b624bd70c67cee4bdf49225915f5945a872e3/guided_diffusion/gaussian_diffusion.py#L1026 sqrt_alphas_cumprod = sqrt_alphas_cumprod.to(device=timesteps.device)[ timesteps ].float() while len(sqrt_alphas_cumprod.shape) < len(timesteps.shape): sqrt_alphas_cumprod = sqrt_alphas_cumprod[..., None] alpha = sqrt_alphas_cumprod.expand(timesteps.shape) sqrt_one_minus_alphas_cumprod = sqrt_one_minus_alphas_cumprod.to( device=timesteps.device )[timesteps].float() while len(sqrt_one_minus_alphas_cumprod.shape) < len(timesteps.shape): sqrt_one_minus_alphas_cumprod = sqrt_one_minus_alphas_cumprod[..., None] sigma = sqrt_one_minus_alphas_cumprod.expand(timesteps.shape) # Compute SNR. snr = (alpha / sigma) ** 2 return snr def log_validation( vae, net, scheduler, accelerator, audio_encoder, audio_processor, cfg, step, timestamp, save_dir = None, ): ori_net = accelerator.unwrap_model(net) reference_net = ori_net.reference_net denoising_unet = ori_net.denoising_unet v_kps_guider = ori_net.v_kps_guider audio_projection = ori_net.audio_projection start_time = time.time() generator = torch.Generator().manual_seed(42) device = accelerator.device if cfg.weight_dtype == 'fp16': dtype = torch.float16 elif cfg.weight_dtype == 'fp32': dtype = torch.float32 elif cfg.weight_dtype == 'bf16': dtype = torch.bfloat16 pipeline = VExpressPipeline( vae=vae, reference_net=reference_net, denoising_unet=denoising_unet, v_kps_guider=v_kps_guider, audio_processor=audio_processor, audio_encoder=audio_encoder, audio_projection=audio_projection, scheduler=scheduler, ).to(dtype=dtype, device=device) ## use the CPU for face processing to avoid OOM app = FaceAnalysis( providers=['CPUExecutionProvider'], provider_options=None, root=cfg.val.insightface_model_path, ) app.prepare(ctx_id=0, det_size=(cfg.val.image_height, cfg.val.image_width)) ref_image_paths = [ # "test_samples/emo/talk_emotion/ref.jpg", "test_samples/short_case/tys/ref.jpg", ] audio_paths = [ "test_samples/emo/talk_emotion/aud.mp3", ] for ref_image_path in ref_image_paths: reference_image = Image.open(ref_image_path).convert("RGB") reference_image_for_kps = cv2.imread(ref_image_path) reference_image_for_kps = cv2.resize(reference_image_for_kps, (cfg.val.image_width, cfg.val.image_height)) reference_kps = app.get(reference_image_for_kps)[0].kps[:3] del app torch.cuda.empty_cache() audio_waveform, audio_sample_rate = torchaudio.load(audio_paths[0]) print(f'Length of audio is {audio_waveform.shape[1]} with the sampling rate of {audio_sample_rate}.') if audio_sample_rate != 16000: audio_waveform = torchaudio.functional.resample( audio_waveform, orig_freq=audio_sample_rate, new_freq=16000, ) audio_waveform = audio_waveform.mean(dim=0) duration = audio_waveform.shape[0] / 16000 init_video_length = int(duration * cfg.val.fps) # fps=30 num_contexts = compute_num_context(init_video_length, cfg.val.context_frames, cfg.val.context_overlap) context_indices = compute_context_indices( num_context=num_contexts, context_size=cfg.val.context_frames, context_overlap=cfg.val.context_overlap ) video_length = context_indices[-1][1] + 1 fps = video_length / duration print(f"The corresponding video length is {video_length}, fps is {fps:.2f}.") kps_sequence = torch.tensor([reference_kps] * video_length) kps_images = [] for i in range(video_length): kps_image = draw_kps_image(cfg.val.image_height, cfg.val.image_width, kps_sequence[i]) kps_images.append(Image.fromarray(kps_image)) video_tensor = pipeline( reference_image=reference_image, kps_images=kps_images, audio_waveform=audio_waveform, width=cfg.val.image_width, height=cfg.val.image_height, video_length=video_length, num_inference_steps=cfg.val.num_inference_steps, guidance_scale=cfg.val.guidance_scale, context_frames=cfg.val.context_frames, context_overlap=cfg.val.context_overlap, reference_attention_weight=cfg.val.reference_attention_weight, audio_attention_weight=cfg.val.audio_attention_weight, num_pad_audio_frames=cfg.val.num_pad_audio_frames, generator=generator, do_multi_devices_inference=False, save_gpu_memory=False, ) if accelerator.is_main_process: output_path = osp.join(save_dir if save_dir is not None else cfg.val.output_dir, "validation", f"video-{step}.mp4") os.makedirs(osp.dirname(output_path), exist_ok=True) save_video(video_tensor, audio_paths[0], output_path, device, fps) consumed_time = time.time() - start_time generation_fps = video_tensor.shape[2] / consumed_time print(f'The generated video has been saved at {output_path}. ' f'The generation time is {consumed_time:.1f} seconds. ' f'The generation FPS is {generation_fps:.2f}.') def main(): parser = argparse.ArgumentParser() parser.add_argument("--config", type=str, default="./configs/stage2.yaml") args = parser.parse_args() cfg = OmegaConf.load(args.config) timestamp = datetime.now().strftime("%m%d_%H%M") exp_name = '.'.join(Path(args.config).name.split('.')[:-1]) + f"-{timestamp}" kwargs = DistributedDataParallelKwargs(find_unused_parameters=False) accelerator = Accelerator( gradient_accumulation_steps=cfg.solver.gradient_accumulation_steps, mixed_precision=cfg.solver.mixed_precision, log_with="mlflow", project_dir="./mlruns", kwargs_handlers=[kwargs], ) # 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=True) 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 cfg.seed is not None: set_seed(cfg.seed, device_specific=True) local_rank = accelerator.device save_dir = f"{cfg.output_dir}/{exp_name}" if accelerator.is_main_process: pathlib.Path(save_dir).mkdir(exist_ok=True, parents=True) os.makedirs(f"{save_dir}/log", exist_ok=True) # copy config yaml # print(cfg) OmegaConf.save(cfg, f"{save_dir}/log/config.yaml") inference_config_path = "./inference_v2.yaml" inference_config = OmegaConf.load(inference_config_path) if cfg.weight_dtype == "fp16": weight_dtype = torch.float16 elif cfg.weight_dtype == "fp32": weight_dtype = torch.float32 elif cfg.weight_dtype == "bf16": weight_dtype = torch.bfloat16 else: raise ValueError(f"Do not support weight dtype: {cfg.weight_dtype} during training") # initialize the noise scheduler scheduler_kwargs = OmegaConf.to_container(cfg.noise_scheduler_kwargs) if cfg.enable_zero_snr: scheduler_kwargs.update( rescale_betas_zero_snr=True, timestep_spacing="trailing", prediction_type="v_prediction", ) noise_scheduler = DDIMScheduler(**scheduler_kwargs) # initialize the pretrained fixed modules vae = AutoencoderKL.from_pretrained(cfg.vae_model_path).to(device=local_rank, dtype=weight_dtype) audio_encoder = Wav2Vec2Model.from_pretrained(cfg.audio_encoder_path).to(dtype=weight_dtype, device=local_rank) audio_processor = Wav2Vec2Processor.from_pretrained(cfg.audio_encoder_path) # initialize our modules reference_net = UNet2DConditionModel.from_pretrained( cfg.base_model_path, subfolder="unet", ).to(device=local_rank, dtype=weight_dtype) denoising_unet = UNet3DConditionModel.from_pretrained_2d( cfg.base_model_path, cfg.motion_module_path, subfolder="unet", unet_additional_kwargs=OmegaConf.to_container(inference_config.unet_additional_kwargs), ).to(device=local_rank, dtype=weight_dtype) v_kps_guider = VKpsGuider( conditioning_embedding_channels=320, block_out_channels=(16, 32, 96, 256), ).to(device=local_rank, dtype=weight_dtype) if cfg.data.audio_embeddings_type == 'global': inp_dim = 768 else: raise ValueError(f'Do not support {cfg.data.audio_embeddings_type}. ' f'Now only support "global".') mid_dim = denoising_unet.config.cross_attention_dim out_dim = denoising_unet.config.cross_attention_dim inp_seq_len = 2 * (2 * cfg.data.num_padding_audio_frames + 1) out_seq_len = 2 * cfg.data.num_padding_audio_frames + 1 audio_projection = AudioProjection( dim=mid_dim, depth=4, dim_head=64, heads=12, num_queries=out_seq_len, embedding_dim=inp_dim, output_dim=out_dim, ff_mult=4, max_seq_len=inp_seq_len, ).to(device=local_rank, dtype=weight_dtype) # load parameters to our modules if cfg.reference_net_path != '': info = reference_net.load_state_dict(torch.load(cfg.reference_net_path, map_location="cpu"), strict=False) logger.info( f"Loaded ReferenceNet from {cfg.reference_net_path}. Info: {info}" ) if cfg.v_kps_guider_path != '': info = v_kps_guider.load_state_dict(torch.load(cfg.v_kps_guider_path, map_location="cpu")) logger.info( f"Loaded VKpsGuider from {cfg.v_kps_guider_path}. Info: {info}" ) if cfg.audio_projection_path != '': info = audio_projection.load_state_dict(torch.load(cfg.audio_projection_path, map_location="cpu")) logger.info( f"Loaded AudioProjection from {cfg.audio_projection_path}. Info: {info}" ) if cfg.denoising_unet_path != '': state_dict = torch.load(cfg.denoising_unet_path, map_location="cpu") new_state_dict = get_denoising_unet_state_dict(state_dict, cfg.denoising_unet_state_dict_type) info = denoising_unet.load_state_dict(new_state_dict, strict=False) logger.info( f"Loaded Denoising U-Net from {cfg.denoising_unet_path} in type of {cfg.denoising_unet_state_dict_type}. " f"Info: {info}" ) if cfg.motion_module_path != '': state_dict = torch.load(cfg.motion_module_path, map_location="cpu") m, u = denoising_unet.load_state_dict(state_dict, strict=False) logger.info( f"Loaded Motion Module from {cfg.motion_module_path}. " f"Info: ### missing keys: {len(m)}; ### unexpected keys: {len(u)};" ) if cfg.train_stage == 'stage_1': for name, params in denoising_unet.named_parameters(): if 'temporal_transformer.proj_out' in name: zero_module(params) # logger.info(name) if 'attn2.to_out' in name: zero_module(params) # logger.info(name) elif cfg.train_stage == 'stage_2': for name, params in denoising_unet.named_parameters(): if 'temporal_transformer.proj_out' in name: zero_module(params) # logger.info(name) if 'attn2.to_out' in name: zero_module(params) # logger.info(name) elif cfg.train_stage == 'stage_2_resume' or cfg.train_stage == 'stage_3': pass else: raise NotImplementedError(f"{cfg.train_stage} not implement") if accelerator.is_main_process: print(f'#############') for k, v in denoising_unet.named_parameters(): if 'temporal_transformer.proj_out' in k: print(k, torch.sum(v)) if 'attn2.to_out' in k: print(k, torch.sum(v)) # set gradient state of all modules vae.requires_grad_(False) audio_encoder.requires_grad_(False) for name, param in reference_net.named_parameters(): if "up_blocks.3" in name: param.requires_grad_(False) else: param.requires_grad_(cfg.module_training.reference_net) denoising_unet.requires_grad_(cfg.module_training.denoising_unet) v_kps_guider.requires_grad_(cfg.module_training.v_kps_guider) audio_projection.requires_grad_(cfg.module_training.audio_projection) for name, module in denoising_unet.named_modules(): if "motion_modules" in name: for params in module.parameters(): params.requires_grad = cfg.module_training.motion_module if "attentions" in name and ("attn2" in name or "norm2" in name): # logger.info(name) for params in module.parameters(): params.requires_grad = cfg.module_training.audio_projection # initialize the reference control writer and reader reference_control_writer = ReferenceAttentionControl( reference_net, do_classifier_free_guidance=False, mode="write", fusion_blocks="full", ) reference_control_reader = ReferenceAttentionControl( denoising_unet, do_classifier_free_guidance=False, mode="read", fusion_blocks="full", reference_drop_rate=cfg.data.reference_drop_rate, ) net = Net( reference_net=reference_net, denoising_unet=denoising_unet, v_kps_guider=v_kps_guider, audio_projection=audio_projection, reference_control_writer=reference_control_writer, reference_control_reader=reference_control_reader, device=local_rank, weight_dtype=weight_dtype, kps_drop_rate=cfg.data.kps_drop_rate, ) if cfg.solver.reference_net_gradient_checkpointing: reference_net.enable_gradient_checkpointing() if cfg.solver.denoising_unet_gradient_checkpointing: denoising_unet.enable_gradient_checkpointing() if cfg.solver.scale_lr: learning_rate = ( cfg.solver.learning_rate * cfg.solver.gradient_accumulation_steps * cfg.data.train_bs * accelerator.num_processes ) else: learning_rate = cfg.solver.learning_rate # initialize the optimizer and lr scheduler if cfg.solver.use_8bit_adam: try: import bitsandbytes as bnb except ImportError: raise ImportError( "Please install bitsandbytes to use 8-bit Adam. You can do so by running `pip install bitsandbytes`" ) optimizer_cls = bnb.optim.AdamW8bit else: optimizer_cls = torch.optim.AdamW trainable_params = list(filter(lambda p: p.requires_grad, net.parameters())) optimizer = optimizer_cls( trainable_params, lr=learning_rate, betas=(cfg.solver.adam_beta1, cfg.solver.adam_beta2), weight_decay=cfg.solver.adam_weight_decay, eps=cfg.solver.adam_epsilon, ) lr_scheduler = get_scheduler( cfg.solver.lr_scheduler, optimizer=optimizer, num_warmup_steps=cfg.solver.lr_warmup_steps * cfg.solver.gradient_accumulation_steps, num_training_steps=cfg.solver.max_train_steps * cfg.solver.gradient_accumulation_steps, ) if 'kps_type' not in cfg.data: cfg.data.kps_type = 'v' dataset = TalkingFaceVideo( image_size=(cfg.data.train_height, cfg.data.train_width), meta_paths=cfg.data.meta_paths, flip_rate=cfg.data.flip_rate, sample_rate=cfg.data.sample_rate, num_frames=cfg.data.num_frames, reference_margin=cfg.data.reference_margin, num_padding_audio_frames=cfg.data.num_padding_audio_frames, kps_type=cfg.data.kps_type, lang=cfg.data.get("lang", None), ## Multilingual ) dataloader = torch.utils.data.DataLoader(dataset, batch_size=cfg.data.train_bs, shuffle=True, num_workers=4, pin_memory=True) (net, optimizer, dataloader, lr_scheduler) = accelerator.prepare(net, optimizer, dataloader, 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(dataloader) / cfg.solver.gradient_accumulation_steps) # Afterwards we recalculate our number of training epochs num_train_epochs = math.ceil(cfg.solver.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: run_time = datetime.now().strftime("%Y%m%d-%H%M") accelerator.init_trackers( exp_name, init_kwargs={"mlflow": {"run_name": run_time}}, ) # dump config file mlflow.log_dict(OmegaConf.to_container(cfg), "config.yaml") # Train! total_batch_size = ( cfg.data.train_bs * accelerator.num_processes * cfg.solver.gradient_accumulation_steps ) logger.info("***** Running training *****") logger.info(f" Num examples = {len(dataset)}") logger.info(f" Num Epochs = {num_train_epochs}") logger.info(f" Instantaneous batch size per device = {cfg.data.train_bs}") logger.info(f" Total train batch size (w. parallel, distributed & accumulation) = {total_batch_size}") logger.info(f" Gradient Accumulation steps = {cfg.solver.gradient_accumulation_steps}") logger.info(f" Total optimization steps = {cfg.solver.max_train_steps}") global_step = 0 first_epoch = 0 if accelerator.is_main_process: count_params(net) # Potentially load in the weights and states from a previous save if cfg.resume_from_checkpoint: if cfg.resume_from_checkpoint != "latest": resume_dir = cfg.resume_from_checkpoint else: resume_dir = save_dir # Get the most recent checkpoint dirs = os.listdir(resume_dir) dirs = [d for d in dirs if d.startswith("checkpoint")] dirs = sorted(dirs, key=lambda x: int(x.split("-")[1])) path = dirs[-1] accelerator.load_state(os.path.join(resume_dir, path)) accelerator.print(f"Resuming from checkpoint {path}") global_step = int(path.split("-")[1]) first_epoch = global_step // num_update_steps_per_epoch resume_step = global_step % num_update_steps_per_epoch ## validate before training. if accelerator.is_main_process and cfg.val.validate_before_training: generator = torch.Generator(device=accelerator.device) generator.manual_seed(cfg.seed) log_validation( vae=vae, net=net, scheduler=noise_scheduler, accelerator=accelerator, audio_encoder=audio_encoder, audio_processor=audio_processor, cfg=cfg, step=global_step, timestamp=timestamp, save_dir=save_dir ) # Only show the progress bar once on each machine. progress_bar = tqdm(range(global_step, cfg.solver.max_train_steps), disable=not accelerator.is_local_main_process) progress_bar.set_description(f"{exp_name}, Steps") for epoch in range(first_epoch, num_train_epochs): ## Resuming training from a breakpoint if epoch == first_epoch and cfg.resume_from_checkpoint and resume_step > 0: skip_batches = resume_step * cfg.solver.gradient_accumulation_steps dataloader = accelerator.skip_first_batches(dataloader, skip_batches) accelerator.print(f"[Resume] Skip first {skip_batches} batches (={resume_step} optimizer steps)") train_loss = 0.0 t_data_start = time.time() for step, batch in enumerate(dataloader): t_data = time.time() - t_data_start with accelerator.accumulate(net): target_images = batch["target_images"].to(weight_dtype) with torch.no_grad(): length = target_images.shape[2] target_images = rearrange(target_images, "b c f h w -> (b f) c h w") latents = vae.encode(target_images).latent_dist.sample() latents = rearrange(latents, "(b f) c h w -> b c f h w", f=length) latents = latents * 0.18215 noise = torch.randn_like(latents) if cfg.noise_offset > 0: noise += cfg.noise_offset * torch.randn( (latents.shape[0], latents.shape[1], 1, 1, 1), device=latents.device, ) bsz = latents.shape[0] # Sample a random timestep for each video timesteps = torch.randint( 0, noise_scheduler.num_train_timesteps, (bsz,), device=latents.device, ) timesteps = timesteps.long() with torch.no_grad(): reference_image = batch["reference_image"].to(dtype=vae.dtype, device=vae.device) reference_image_latents = vae.encode(reference_image).latent_dist.sample() # (bs, d, 64, 64) reference_image_latents = reference_image_latents * 0.18215 kps_images = batch["kps_images"].to(local_rank, dtype=weight_dtype) # (bs, f, c, H, W) audio_frame_embeddings = batch['audio_frame_embeddings'].to(local_rank, dtype=weight_dtype) lip_masks = batch["lip_masks"].to(dtype=vae.dtype, device=vae.device) # add noise noisy_latents = noise_scheduler.add_noise(latents, noise, timesteps) # Get the target for loss depending on the prediction type if noise_scheduler.prediction_type == "epsilon": target = noise elif noise_scheduler.prediction_type == "v_prediction": target = noise_scheduler.get_velocity(latents, noise, timesteps) else: raise ValueError(f"Unknown prediction type {noise_scheduler.prediction_type}") ## Keeping the computation graph in sync with torch.no_grad(): drop_flag = torch.rand(1, device=latents.device) torch.distributed.broadcast(drop_flag, src=0) do_uncond = (drop_flag < cfg.uncond_ratio).item() model_pred = net( noisy_latents, timesteps, reference_image_latents, audio_frame_embeddings, kps_images, do_unconditional_forward=do_uncond, ) loss = F.mse_loss(model_pred.float(), target.float(), reduction="none") if 'lip_loss_weight' in cfg.data: loss *= ((cfg.data.lip_loss_weight - 1) * lip_masks + 1.) if cfg.snr_gamma != 0: snr = compute_snr(noise_scheduler, timesteps) if noise_scheduler.config.prediction_type == "v_prediction": # Velocity objective requires that we add one to SNR values before we divide by them. snr = snr + 1 mse_loss_weights = ( torch.stack([snr, cfg.snr_gamma * torch.ones_like(timesteps)], dim=1).min(dim=1)[0] / snr ) loss = loss.mean(dim=list(range(1, len(loss.shape)))) * mse_loss_weights loss = loss.mean() # Gather the losses across all processes for logging (if we use distributed training). avg_loss = accelerator.gather(loss.repeat(cfg.data.train_bs)).mean() train_loss += avg_loss.item() / cfg.solver.gradient_accumulation_steps # Backpropagate accelerator.backward(loss) if accelerator.sync_gradients: accelerator.clip_grad_norm_(trainable_params, cfg.solver.max_grad_norm) optimizer.step() lr_scheduler.step() optimizer.zero_grad() if accelerator.sync_gradients: reference_control_reader.clear() reference_control_writer.clear() progress_bar.update(1) global_step += 1 accelerator.log({"train_loss": train_loss}, step=global_step) train_loss = 0.0 logs = { "step_loss": loss.detach().item(), "lr": lr_scheduler.get_last_lr()[0], "td": f"{t_data:.2f}s", } t_data_start = time.time() progress_bar.set_postfix(**logs) if global_step >= cfg.solver.max_train_steps: break ## save model after each epoch if global_step % cfg.checkpointing_steps == 1: save_path = os.path.join(save_dir, f"checkpoint-{global_step}") accelerator.save_state(save_path) if accelerator.is_main_process: if cfg.save_all or cfg.module_training.denoising_unet: module = accelerator.unwrap_model(net.denoising_unet) save_module_checkpoint(module, save_dir, "denoising_unet", global_step) elif cfg.module_training.motion_module or cfg.module_training.audio_projection: module = accelerator.unwrap_model(net.denoising_unet) save_module_checkpoint(module, save_dir, "denoising_unet", global_step) if cfg.save_all or cfg.module_training.reference_net: module = accelerator.unwrap_model(net.reference_net) save_module_checkpoint(module, save_dir, "reference_net", global_step) if cfg.save_all or cfg.module_training.v_kps_guider: module = accelerator.unwrap_model(net.v_kps_guider) save_module_checkpoint(module, save_dir, "v_kps_guider", global_step) if cfg.save_all or cfg.module_training.audio_projection: module = accelerator.unwrap_model(net.audio_projection) save_module_checkpoint(module, save_dir, "audio_projection", global_step) if cfg.save_all or cfg.module_training.motion_module: module = accelerator.unwrap_model(net.denoising_unet) save_motion_module_checkpoint(module, save_dir, "motion_module", global_step) ## visualize validation results if global_step % cfg.val.validation_steps == 0 or (cfg.val.validate_at_first_step and global_step == 1): if accelerator.is_main_process: generator = torch.Generator(device=accelerator.device) generator.manual_seed(cfg.seed) log_validation( vae=vae, net=net, scheduler=noise_scheduler, accelerator=accelerator, audio_encoder=audio_encoder, audio_processor=audio_processor, cfg=cfg, step=global_step, timestamp=timestamp, save_dir=save_dir, ) # save model after each epoch save_path = os.path.join(save_dir, f"checkpoint-{global_step}") accelerator.save_state(save_path) if accelerator.is_main_process: if cfg.save_all or cfg.module_training.denoising_unet: module = accelerator.unwrap_model(net.denoising_unet) save_module_checkpoint(module, save_dir, "denoising_unet", global_step) elif cfg.module_training.motion_module or cfg.module_training.audio_projection: module = accelerator.unwrap_model(net.denoising_unet) save_module_checkpoint(module, save_dir, "denoising_unet", global_step) if cfg.save_all or cfg.module_training.reference_net: module = accelerator.unwrap_model(net.reference_net) save_module_checkpoint(module, save_dir, "reference_net", global_step) if cfg.save_all or cfg.module_training.v_kps_guider: module = accelerator.unwrap_model(net.v_kps_guider) save_module_checkpoint(module, save_dir, "v_kps_guider", global_step) if cfg.save_all or cfg.module_training.audio_projection: module = accelerator.unwrap_model(net.audio_projection) save_module_checkpoint(module, save_dir, "audio_projection", global_step) if cfg.save_all or cfg.module_training.motion_module: module = accelerator.unwrap_model(net.denoising_unet) save_motion_module_checkpoint(module, save_dir, "motion_module", global_step) # Create the pipeline using the trained modules and save it. accelerator.wait_for_everyone() accelerator.end_training() def save_module_checkpoint(module, save_dir, prefix, ckpt_num): save_path = osp.join(save_dir, f"{prefix}-{ckpt_num}.pth") state_dict = module.state_dict() new_state_dict = {} for n, p in state_dict.items(): new_state_dict[n] = p.clone() torch.save(new_state_dict, save_path) def save_motion_module_checkpoint(model, save_dir, prefix, ckpt_num): save_path = osp.join(save_dir, f"{prefix}-{ckpt_num}.pth") mm_state_dict = OrderedDict() state_dict = model.state_dict() for key in state_dict: if "motion_module" in key: mm_state_dict[key] = state_dict[key].clone() torch.save(mm_state_dict, save_path) if __name__ == "__main__": main()