''' calculate diffusion loss according to different diffusion formula ''' import torch from diffusers import DDPMScheduler, PNDMScheduler, DPMSolverMultistepScheduler, FlowMatchEulerDiscreteScheduler from opensora.utils.parallel_states import initialize_sequence_parallel_state, \ destroy_sequence_parallel_group, get_sequence_parallel_state, set_sequence_parallel_state from opensora.utils.communications import prepare_parallel_data, broadcast from diffusers.training_utils import compute_snr from diffusers.utils.torch_utils import randn_tensor from torch.nn import functional as F import numpy as np from opensora.train.edm import EDMPrecond, EDMLoss from opensora.sample.pyramid_flow_matching_scheduler import AutoRegressivePyramidFlowMatchEulerDiscreteScheduler from functools import partial from copy import deepcopy from einops import rearrange import random def compute_loss_weighting_for_sd3(weighting_scheme: str, sigmas=None): """Computes loss weighting scheme for SD3 training. Courtesy: This was contributed by Rafie Walker in https://github.com/huggingface/diffusers/pull/8528. SD3 paper reference: https://arxiv.org/abs/2403.03206v1. """ if weighting_scheme == "sigma_sqrt": weighting = (sigmas**-2.0).float() elif weighting_scheme == "cosmap": bot = 1 - 2 * sigmas + 2 * sigmas**2 weighting = 2 / (math.pi * bot) else: weighting = torch.ones_like(sigmas) return weighting def compute_density_for_timestep_sampling( weighting_scheme: str, batch_size: int, logit_mean: float = None, logit_std: float = None, mode_scale: float = None ): """Compute the density for sampling the timesteps when doing SD3 training. Courtesy: This was contributed by Rafie Walker in https://github.com/huggingface/diffusers/pull/8528. SD3 paper reference: https://arxiv.org/abs/2403.03206v1. """ if weighting_scheme == "logit_normal": # See 3.1 in the SD3 paper ($rf/lognorm(0.00,1.00)$). u = torch.normal(mean=logit_mean, std=logit_std, size=(batch_size,), device="cpu") u = torch.nn.functional.sigmoid(u) elif weighting_scheme == "mode": u = torch.rand(size=(batch_size,), device="cpu") u = 1 - u - mode_scale * (torch.cos(math.pi * u / 2) ** 2 - 1 + u) else: u = torch.rand(size=(batch_size,), device="cpu") return u try: from diffusers.pipelines.cogvideo.pipeline_cogvideox import get_resize_crop_region_for_grid from diffusers.models.embeddings import get_3d_rotary_pos_embed except: pass def prepare_rotary_positional_embeddings( height: int, width: int, num_frames: int, vae_scale_factor_spatial: int = 8, patch_size: int = 2, attention_head_dim: int = 64, device = None, dtype = None, base_height: int = 480, base_width: int = 720, ): grid_height = height // (vae_scale_factor_spatial * patch_size) grid_width = width // (vae_scale_factor_spatial * patch_size) base_size_width = base_width // (vae_scale_factor_spatial * patch_size) base_size_height = base_height // (vae_scale_factor_spatial * patch_size) grid_crops_coords = get_resize_crop_region_for_grid((grid_height, grid_width), base_size_width, base_size_height) freqs_cos, freqs_sin = get_3d_rotary_pos_embed( embed_dim=attention_head_dim, crops_coords=grid_crops_coords, grid_size=(grid_height, grid_width), temporal_size=num_frames, ) freqs_cos = freqs_cos.to(device=device, dtype=dtype) freqs_sin = freqs_sin.to(device=device, dtype=dtype) return freqs_cos, freqs_sin class CustomDiffusion(): def __init__(self): from diffusers.schedulers import CogVideoXDDIMScheduler, CogVideoXDPMScheduler #TODO：优化了 self.noise_scheduler = CogVideoXDPMScheduler.from_config("/CogVideoX-5b-I2V/scheduler/scheduler_config.json") def get_loss(self, model, model_input, model_kwargs, args, accelerator, **kwargs): model.train() if args.task == 'i2v': model_input, image_latents = model_input image_latents = image_latents.permute(0, 2, 1, 3, 4) model_input = model_input.permute(0, 2, 1, 3, 4) dtype = model_input.dtype bsz = model_input.shape[0] current_step_frame = model_input.shape[1] #注意是B T C H W height, width = model_input.shape[3:] model_config = model.module.config if hasattr(model, 'module') else model.config patch_size_t = model_config.patch_size_t additional_frames = 0 if patch_size_t is not None: #TODO: not sure，对齐训练测试 additional_frames = patch_size_t - current_step_frame % patch_size_t pading_frames = model_input[:, :additional_frames] model_input = torch.cat([pading_frames, model_input], dim=1) # image_latents = torch.cat([image_latents[:, :additional_frames], image_latents], dim=1) padding_shape = (model_input.shape[0], model_input.shape[1]-1, *model_input.shape[2:]) latent_padding = image_latents.new_zeros(padding_shape) image_latents = torch.cat([image_latents, latent_padding], dim=1) noise = torch.randn_like(model_input) timesteps = torch.randint(0, self.noise_scheduler.config.num_train_timesteps, (bsz,), device=model_input.device) noisy_video_latents = self.noise_scheduler.add_noise(model_input, noise, timesteps) model_config = model.module.config if hasattr(model, 'module') else model.config ofs_emb = None if model_config.ofs_embed_dim is None else noisy_video_latents.new_full((1,), fill_value=2.0) if args.task == 't2v': noisy_model_input = noisy_video_latents elif args.task == 'i2v': noisy_model_input = torch.cat([noisy_video_latents, image_latents], dim=2) model_output = model( hidden_states = noisy_model_input, encoder_hidden_states = model_kwargs['encoder_hidden_states'], encoder_attention_mask = model_kwargs['encoder_attention_mask'], timestep = timesteps, return_dict=False, ofs = ofs_emb, )[0] model_pred = self.noise_scheduler.get_velocity(model_output, noisy_video_latents, timesteps) #[:, additional_frames:] alphas_cumprod = self.noise_scheduler.alphas_cumprod[timesteps] weights = 1 / (1 - alphas_cumprod) while len(weights.shape) < len(model_pred.shape): weights = weights.unsqueeze(-1) target = model_input #[:, additional_frames:] loss = torch.mean((weights * (model_pred - target) ** 2).reshape(bsz, -1), dim=1) loss = loss.mean() return loss def get_loss_controlnet(self, condition, controlnet, model, model_input, model_kwargs, args, accelerator, **kwargs): controlnet.train() if args.task == 'i2v': model_input, image_latents = model_input image_latents = image_latents.permute(0, 2, 1, 3, 4) model_input = model_input.permute(0, 2, 1, 3, 4) dtype = model_input.dtype bsz = model_input.shape[0] current_step_frame = model_input.shape[1] #注意是B T C H W height, width = model_input.shape[3:] model_config = model.module.config if hasattr(model, 'module') else model.config patch_size_t = model_config.patch_size_t additional_frames = 0 if patch_size_t is not None: #TODO: not sure，对齐训练测试 additional_frames = patch_size_t - current_step_frame % patch_size_t pading_frames = model_input[:, :additional_frames] model_input = torch.cat([pading_frames, model_input], dim=1) # image_latents = torch.cat([image_latents[:, :additional_frames], image_latents], dim=1) padding_shape = (model_input.shape[0], model_input.shape[1]-1, *model_input.shape[2:]) latent_padding = image_latents.new_zeros(padding_shape) image_latents = torch.cat([image_latents, latent_padding], dim=1) noise = torch.randn_like(model_input) timesteps = torch.randint(0, self.noise_scheduler.config.num_train_timesteps, (bsz,), device=model_input.device) noisy_video_latents = self.noise_scheduler.add_noise(model_input, noise, timesteps) model_config = model.module.config if hasattr(model, 'module') else model.config ofs_emb = None if model_config.ofs_embed_dim is None else noisy_video_latents.new_full((1,), fill_value=2.0) if args.task == 't2v': noisy_model_input = noisy_video_latents elif args.task == 'i2v': noisy_model_input = torch.cat([noisy_video_latents, image_latents], dim=2) controlnet_states = controlnet( hidden_states=noisy_model_input, encoder_hidden_states=model_kwargs['encoder_hidden_states'], controlnet_cond=condition, timestep=timesteps, return_dict=False, )[0] if isinstance(controlnet_states, (tuple, list)): controlnet_states = [x.to(dtype=noisy_video_latents.dtype) for x in controlnet_states] else: controlnet_states = controlnet_states.to(dtype=noisy_video_latents.dtype) model_output = model( hidden_states = noisy_model_input, encoder_hidden_states = model_kwargs['encoder_hidden_states'], encoder_attention_mask = model_kwargs['encoder_attention_mask'], timestep = timesteps, return_dict=False, ofs = ofs_emb, controlnet_states = controlnet_states, controlnet_weights = 1.0 )[0] model_pred = self.noise_scheduler.get_velocity(model_output, noisy_video_latents, timesteps) #[:, additional_frames:] alphas_cumprod = self.noise_scheduler.alphas_cumprod[timesteps] weights = 1 / (1 - alphas_cumprod) while len(weights.shape) < len(model_pred.shape): weights = weights.unsqueeze(-1) target = model_input #[:, additional_frames:] loss = torch.mean((weights * (model_pred - target) ** 2).reshape(bsz, -1), dim=1) loss = loss.mean() return loss @torch.no_grad() def get_valid_loss_controlnet(self, condition, controlnet, model, model_input, model_kwargs, args, **kwargs): if args.task == 'i2v': model_input, image_latents = model_input image_latents = image_latents.permute(0, 2, 1, 3, 4) model_input = model_input.permute(0, 2, 1, 3, 4) dtype = model_input.dtype bsz = model_input.shape[0] current_step_frame = model_input.shape[1] #注意是B T C H W height, width = model_input.shape[3:] model_config = model.module.config if hasattr(model, 'module') else model.config patch_size_t = model_config.patch_size_t additional_frames = 0 if patch_size_t is not None: #TODO: not sure additional_frames = patch_size_t - current_step_frame % patch_size_t pading_frames = model_input[:, :additional_frames] model_input = torch.cat([pading_frames, model_input], dim=1) # image_latents = torch.cat([image_latents[:, :additional_frames], image_latents], dim=1) padding_shape = (model_input.shape[0], model_input.shape[1]-1, *model_input.shape[2:]) latent_padding = image_latents.new_zeros(padding_shape) image_latents = torch.cat([image_latents, latent_padding], dim=1) evaluate_steps = kwargs['evaluate_steps'] # valid多少个timesteps的结果 generator = torch.torch.Generator(device = model_input.device) generator.manual_seed(42) loss_list = [] for step_i in range(evaluate_steps): generator = torch.torch.Generator(device = model_input.device) generator.manual_seed(42+step_i) timesteps = torch.ones((bsz,), dtype=int) * (step_i * self.noise_scheduler.config.num_train_timesteps // evaluate_steps) timesteps = timesteps.to(model_input.device) noise = torch.randn_like(model_input) noisy_video_latents = self.noise_scheduler.add_noise(model_input, noise, timesteps) ofs_emb = None if model_config.ofs_embed_dim is None else noisy_video_latents.new_full((1,), fill_value=2.0) if args.task == 't2v': noisy_model_input = noisy_video_latents elif args.task == 'i2v': noisy_model_input = torch.cat([noisy_video_latents, image_latents], dim=2) controlnet_states = controlnet( hidden_states=noisy_model_input, encoder_hidden_states=model_kwargs['encoder_hidden_states'], controlnet_cond=condition, timestep=timesteps, return_dict=False, )[0] if isinstance(controlnet_states, (tuple, list)): controlnet_states = [x.to(dtype=model_kwargs["weight_dtype"]) for x in controlnet_states] else: controlnet_states = controlnet_states.to(dtype=model_kwargs["weight_dtype"]) model_output = model( hidden_states = noisy_model_input, encoder_hidden_states = model_kwargs['encoder_hidden_states'], encoder_attention_mask = model_kwargs['encoder_attention_mask'], timestep = timesteps, return_dict=False, ofs = ofs_emb, controlnet_states = controlnet_states, controlnet_weights = args.controlnet_weights )[0] model_pred = self.noise_scheduler.get_velocity(model_output, noisy_video_latents, timesteps) #[:, additional_frames:] alphas_cumprod = self.noise_scheduler.alphas_cumprod[timesteps] weights = 1 / (1 - alphas_cumprod) while len(weights.shape) < len(model_pred.shape): weights = weights.unsqueeze(-1) target = model_input #[:, additional_frames:] loss = torch.mean((weights * (model_pred - target) ** 2).reshape(bsz, -1), dim=1) loss = loss.mean() loss_list.append(loss) loss_list = torch.stack(loss_list) return loss_list @torch.no_grad() def get_valid_loss(self, model, model_input, model_kwargs, args, **kwargs): if args.task == 'i2v': model_input, image_latents = model_input image_latents = image_latents.permute(0, 2, 1, 3, 4) model_input = model_input.permute(0, 2, 1, 3, 4) dtype = model_input.dtype bsz = model_input.shape[0] current_step_frame = model_input.shape[1] #注意是B T C H W height, width = model_input.shape[3:] model_config = model.module.config if hasattr(model, 'module') else model.config patch_size_t = model_config.patch_size_t additional_frames = 0 if patch_size_t is not None: #TODO: not sure additional_frames = patch_size_t - current_step_frame % patch_size_t pading_frames = model_input[:, :additional_frames] model_input = torch.cat([pading_frames, model_input], dim=1) # image_latents = torch.cat([image_latents[:, :additional_frames], image_latents], dim=1) padding_shape = (model_input.shape[0], model_input.shape[1]-1, *model_input.shape[2:]) latent_padding = image_latents.new_zeros(padding_shape) image_latents = torch.cat([image_latents, latent_padding], dim=1) evaluate_steps = kwargs['evaluate_steps'] # valid多少个timesteps的结果 generator = torch.torch.Generator(device = model_input.device) generator.manual_seed(42) loss_list = [] for step_i in range(evaluate_steps): generator = torch.torch.Generator(device = model_input.device) generator.manual_seed(42+step_i) timesteps = torch.ones((bsz,), dtype=int) * (step_i * self.noise_scheduler.config.num_train_timesteps // evaluate_steps) timesteps = timesteps.to(model_input.device) noise = torch.randn_like(model_input) noisy_video_latents = self.noise_scheduler.add_noise(model_input, noise, timesteps) ofs_emb = None if model_config.ofs_embed_dim is None else noisy_video_latents.new_full((1,), fill_value=2.0) if args.task == 't2v': noisy_model_input = noisy_video_latents elif args.task == 'i2v': noisy_model_input = torch.cat([noisy_video_latents, image_latents], dim=2) model_output = model( hidden_states = noisy_model_input, encoder_hidden_states = model_kwargs['encoder_hidden_states'], encoder_attention_mask = model_kwargs['encoder_attention_mask'], timestep = timesteps, return_dict=False, ofs = ofs_emb, )[0] model_pred = self.noise_scheduler.get_velocity(model_output, noisy_video_latents, timesteps) #[:, additional_frames:] alphas_cumprod = self.noise_scheduler.alphas_cumprod[timesteps] weights = 1 / (1 - alphas_cumprod) while len(weights.shape) < len(model_pred.shape): weights = weights.unsqueeze(-1) target = model_input #[:, additional_frames:] loss = torch.mean((weights * (model_pred - target) ** 2).reshape(bsz, -1), dim=1) loss = loss.mean() loss_list.append(loss) loss_list = torch.stack(loss_list) return loss_list class CogVideoXDDPM(): def __init__(self, model_path, ori_height, ori_width, vae_scale_factor_spatial): from diffusers import CogVideoXDPMScheduler #TODO: create schedulers self.noise_scheduler = CogVideoXDPMScheduler.from_pretrained(model_path, subfolder = 'scheduler') self.ori_height = ori_height self.ori_width = ori_width self.vae_scale_factor_spatial = vae_scale_factor_spatial def get_loss(self, model, model_input, model_kwargs, args, accelerator, **kwargs): model.train() if args.task == 'i2v': model_input, image_latents = model_input dtype = model_input.dtype noise = torch.randn_like(model_input) bsz = model_input.shape[0] current_step_frame = model_input.shape[1] height, width = model_input.shape[3:] timesteps = torch.randint(0, self.noise_scheduler.config.num_train_timesteps, (bsz,), device=model_input.device) noisy_video_latents = self.noise_scheduler.add_noise(model_input, noise, timesteps) model_config = model.module.config if hasattr(model, 'module') else model.config image_rotary_emb = ( prepare_rotary_positional_embeddings( height=self.ori_height, #cogvideox固定分辨率 width=self.ori_width, num_frames=current_step_frame, vae_scale_factor_spatial=self.vae_scale_factor_spatial, patch_size=model_config.patch_size, attention_head_dim=model_config.attention_head_dim, device=accelerator.device, dtype=dtype ) if model_config.use_rotary_positional_embeddings else None ) if args.task == 't2v': noisy_model_input = noisy_video_latents elif args.task == 'i2v': noisy_model_input = torch.cat([noisy_video_latents, image_latents], dim=2) model_output = model( hidden_states = noisy_model_input, encoder_hidden_states = model_kwargs['encoder_hidden_states'], timestep = timesteps, image_rotary_emb = image_rotary_emb, return_dict=False, )[0] model_pred = self.noise_scheduler.get_velocity(model_output, noisy_video_latents, timesteps) alphas_cumprod = self.noise_scheduler.alphas_cumprod[timesteps] weights = 1 / (1 - alphas_cumprod) while len(weights.shape) < len(model_pred.shape): weights = weights.unsqueeze(-1) target = model_input loss = torch.mean((weights * (model_pred - target) ** 2).reshape(bsz, -1), dim=1) loss = loss.mean() return loss class DDPM(): def __init__(self, use_flow=False): if not use_flow: self.noise_scheduler = DDPMScheduler() else: self.noise_scheduler = FlowMatchEulerDiscreteScheduler() self.noise_scheduler_copy = deepcopy(self.noise_scheduler) print(f"====> use rectified flow !!!") self.use_flow = use_flow # 前向运算计算loss def get_loss(self, model, model_input, model_kwargs, args, **kwargs): dtype = model_input.dtype noise = torch.randn_like(model_input) # if args.noise_offset: # # https://www.crosslabs.org//blog/diffusion-with-offset-noise # noise += args.noise_offset * torch.randn((model_input.shape[0], model_input.shape[1], 1, 1, 1), # device=model_input.device) bsz = model_input.shape[0] current_step_frame = model_input.shape[2] if args.reflow: # Sample a random timestep for each image # for weighting schemes where we sample timesteps non-uniformly u = compute_density_for_timestep_sampling( weighting_scheme=args.weighting_scheme, batch_size=bsz, logit_mean=args.logit_mean, logit_std=args.logit_std, mode_scale=args.mode_scale, ) indices = (u * self.noise_scheduler_copy.config.num_train_timesteps).long() timesteps = self.noise_scheduler_copy.timesteps[indices].to(device=model_input.device) else: # Sample a random timestep for each image without bias. timesteps = torch.randint(0, self.noise_scheduler.config.num_train_timesteps, (bsz,), device=model_input.device) if current_step_frame != 1 and get_sequence_parallel_state(): # image do not need sp broadcast(timesteps) if self.use_flow: sigmas = self.noise_scheduler_copy.sigmas.to(device=model_input.device, dtype=dtype) schedule_timesteps = self.noise_scheduler_copy.timesteps.to(model_input.device) timesteps = timesteps.to(model_input.device) step_indices = [(schedule_timesteps == t).nonzero().item() for t in timesteps] sigma = sigmas[step_indices].flatten() while len(sigma.shape) < model_input.ndim: sigma = sigma.unsqueeze(-1) sigmas = sigma noisy_model_input = (1.0 - sigmas) * model_input + sigmas * noise else: noisy_model_input = self.noise_scheduler.add_noise(model_input, noise, timesteps) model_pred = model( noisy_model_input, timesteps, **model_kwargs )[0] if args.reflow: # model_pred = model_pred * (-sigmas) + noisy_model_input # these weighting schemes use a uniform timestep sampling # and instead post-weight the loss weighting = compute_loss_weighting_for_sd3(weighting_scheme=args.weighting_scheme, sigmas=sigmas) if args.prediction_type is not None: # set prediction_type of scheduler if defined self.noise_scheduler.register_to_config(prediction_type=args.prediction_type) if hasattr(self.noise_scheduler.config, 'prediction_type'): if self.noise_scheduler.config.prediction_type == "epsilon": target = noise elif self.noise_scheduler.config.prediction_type == "v_prediction": target = self.noise_scheduler.get_velocity(model_input, noise, timesteps) elif self.noise_scheduler.config.prediction_type == "sample": # We set the target to latents here, but the model_pred will return the noise sample prediction. target = model_input # We will have to subtract the noise residual from the prediction to get the target sample. model_pred = model_pred - noise else: raise ValueError(f"Unknown prediction type {self.noise_scheduler.config.prediction_type}") else: # reflow # target = model_input target = noise - model_input mask = model_kwargs.get('attention_mask', None) if torch.all(mask.bool()): mask = None assert mask is None b, c, t_shard, _, _ = model_pred.shape if mask is not None: # 实际上不知道这里是哪里，因此需要所有帧的attention mask是一样的，确保在时序上不会补帧即可 mask = mask.unsqueeze(1).repeat(1, c, 1, 1, 1).float()[:, :, -t_shard:, :, :] # b t h w -> b c t h w mask = mask.reshape(b, -1) if args.reflow: # Compute regular loss. loss = (weighting.float() * (model_pred.float() - target.float()) ** 2).reshape(target.shape[0], -1) if mask is not None: loss = (loss * mask).sum() / mask.sum() # mean loss on unpad patches else: loss = loss.mean() else: if args.snr_gamma is None: # model_pred: b c t h w, attention_mask: b t h w loss = F.mse_loss(model_pred.float(), target.float(), reduction="none") loss = loss.reshape(b, -1) if mask is not None: loss = (loss * mask).sum() / mask.sum() # mean loss on unpad patches else: loss = loss.mean() else: # Compute loss-weights as per Section 3.4 of https://arxiv.org/abs/2303.09556. # Since we predict the noise instead of x_0, the original formulation is slightly changed. # This is discussed in Section 4.2 of the same paper. snr = compute_snr(self.noise_scheduler, timesteps) mse_loss_weights = torch.stack([snr, args.snr_gamma * torch.ones_like(timesteps)], dim=1).min( dim=1 )[0] if self.noise_scheduler.config.prediction_type == "epsilon": mse_loss_weights = mse_loss_weights / snr elif self.noise_scheduler.config.prediction_type == "v_prediction": mse_loss_weights = mse_loss_weights / (snr + 1) loss = F.mse_loss(model_pred.float(), target.float(), reduction="none") loss = loss.reshape(b, -1) mse_loss_weights = mse_loss_weights.reshape(b, 1) if mask is not None: loss = (loss * mask * mse_loss_weights).sum() / mask.sum() # mean loss on unpad patches else: loss = (loss * mse_loss_weights).mean() return loss class FlowMatching(): def __init__(self): self.noise_scheduler = FlowMatchEulerDiscreteScheduler( shift=1.0, num_train_timesteps=1000, use_dynamic_shifting = False ) # hunyuan def get_loss(self, model, model_input, model_kwargs, args, **kwargs): model.train() if args.task == 'i2v': model_input, image_latents = model_input padding_shape = (model_input.shape[0], model_input.shape[1], model_input.shape[2]-1, *model_input.shape[3:]) latent_padding = image_latents.new_zeros(padding_shape) image_latents = torch.cat([image_latents, latent_padding], dim=2) dtype = model_input.dtype noise = torch.randn_like(model_input) bsz = model_input.shape[0] current_step_frame = model_input.shape[2] u = compute_density_for_timestep_sampling( weighting_scheme=args.weighting_scheme, batch_size=bsz, logit_mean=args.logit_mean, logit_std=args.logit_std, mode_scale=args.mode_scale, ) indices = (u * self.noise_scheduler.config.num_train_timesteps).long() timesteps = self.noise_scheduler.timesteps[indices].to(device=model_input.device) sigmas = self.noise_scheduler.sigmas.to(device=model_input.device, dtype=dtype) schedule_timesteps = self.noise_scheduler.timesteps.to(model_input.device) timesteps = timesteps.to(model_input.device) step_indices = [(schedule_timesteps == t).nonzero().item() for t in timesteps] sigma = sigmas[step_indices].flatten() while len(sigma.shape) < model_input.ndim: sigma = sigma.unsqueeze(-1) sigmas = sigma if not self.noise_scheduler.config.invert_sigmas: noisy_video_latents = (1.0 - sigmas) * model_input + sigmas * noise else: noisy_video_latents = sigmas * model_input + (1 - sigmas) * noise if args.task == 't2v': noisy_model_input = noisy_video_latents elif args.task == 'i2v': noisy_model_input = torch.cat([noisy_video_latents, image_latents], dim=1) # no image_emb (pay attention) model_pred = model( hidden_states = noisy_model_input, encoder_hidden_states = model_kwargs['encoder_hidden_states'], encoder_attention_mask = model_kwargs['encoder_attention_mask'], embed_cfg_scale = model_kwargs['batch_embed_scale'], timestep = timesteps, return_dict=False, )[0] weighting = compute_loss_weighting_for_sd3(weighting_scheme=args.weighting_scheme, sigmas=sigmas) if not self.noise_scheduler.config.invert_sigmas: target = noise - model_input else: target = model_input - noise loss = (weighting.float() * (model_pred.float() - target.float()) ** 2).reshape(target.shape[0], -1) loss = loss.mean() return loss # hunyuan def get_loss_controlnet(self, condition, model, model_input, model_kwargs, args, **kwargs): model.train() if args.task == 'i2v': model_input, image_latents = model_input if args.repeat: image_latents = image_latents.repeat(1, 1, model_input.shape[2], 1, 1) else: padding_shape = (model_input.shape[0], model_input.shape[1], model_input.shape[2]-1, *model_input.shape[3:]) latent_padding = image_latents.new_zeros(padding_shape) image_latents = torch.cat([image_latents, latent_padding], dim=2) dtype = model_input.dtype noise = torch.randn_like(model_input) bsz = model_input.shape[0] current_step_frame = model_input.shape[2] u = compute_density_for_timestep_sampling( weighting_scheme=args.weighting_scheme, batch_size=bsz, logit_mean=args.logit_mean, logit_std=args.logit_std, mode_scale=args.mode_scale, ) indices = (u * self.noise_scheduler.config.num_train_timesteps).long() timesteps = self.noise_scheduler.timesteps[indices].to(device=model_input.device) sigmas = self.noise_scheduler.sigmas.to(device=model_input.device, dtype=dtype) schedule_timesteps = self.noise_scheduler.timesteps.to(model_input.device) timesteps = timesteps.to(model_input.device) step_indices = [(schedule_timesteps == t).nonzero().item() for t in timesteps] sigma = sigmas[step_indices].flatten() while len(sigma.shape) < model_input.ndim: sigma = sigma.unsqueeze(-1) sigmas = sigma if not self.noise_scheduler.config.invert_sigmas: noisy_video_latents = (1.0 - sigmas) * model_input + sigmas * noise else: noisy_video_latents = sigmas * model_input + (1 - sigmas) * noise if args.task == 't2v': noisy_model_input = noisy_video_latents elif args.task == 'i2v': noisy_model_input = torch.cat([noisy_video_latents, image_latents], dim=1) model_pred = model( hidden_states = noisy_model_input, encoder_hidden_states = model_kwargs['encoder_hidden_states'], encoder_attention_mask = model_kwargs['encoder_attention_mask'], embed_cfg_scale = model_kwargs['batch_embed_scale'], timestep = timesteps, controlnet_cond = condition, conditioning_scale = model_kwargs.get('conditioning_scale',1), controlnet_blocks_repeat = False, #NOTE：pay attention return_dict=False, image_emb = model_kwargs['image_emb'], image_latents = model_kwargs['image_latents'] )[0] weighting = compute_loss_weighting_for_sd3(weighting_scheme=args.weighting_scheme, sigmas=sigmas) if not self.noise_scheduler.config.invert_sigmas: target = noise - model_input else: target = model_input - noise # add_ocr mask here b, c, t, h, w = model_input.shape # print(b, c, t, h, w) ocr_mask = model_kwargs["ocr_mask"] ocr_mask = rearrange(ocr_mask, "b c t H W -> (b t) c H W") # 确保是0,1不会出现其他的值， 插值到latent shape ocr_mask = F.interpolate(ocr_mask, size=(h, w), mode='nearest') ocr_mask = rearrange(ocr_mask, "(b t) c h w -> b c t h w", t=t) # c = 1 ocr_mask = ocr_mask.expand(-1, c, -1, -1, -1) # auto broadcast loss = (weighting.float() * (model_pred.float() - target.float()) ** 2 * ocr_mask.float()) if args.face_mask: face_mask = model_kwargs["face_mask"] face_mask = rearrange(face_mask, "b c t H W -> (b t) c H W") face_mask = F.interpolate(face_mask, size=(h, w), mode='nearest') face_mask = rearrange(face_mask, "(b t) c h w -> b c t h w", t=t) face_mask = face_mask.expand(-1, c, -1, -1, -1) loss = loss * ((args.face_weight - 1) * face_mask + 1).float() loss = loss.reshape(target.shape[0], -1).mean() return loss # 4.14待完善 def get_loss_wanx(self, condition, model, model_input, model_kwargs, args, **kwargs): model.train() if args.task == 'i2v': model_input, image_latents = model_input if args.repeat: image_latents = image_latents.repeat(1, 1, model_input.shape[2], 1, 1) dtype = model_input.dtype noise = torch.randn_like(model_input) bsz = model_input.shape[0] current_step_frame = model_input.shape[2] u = compute_density_for_timestep_sampling( weighting_scheme=args.weighting_scheme, batch_size=bsz, logit_mean=args.logit_mean, logit_std=args.logit_std, mode_scale=args.mode_scale, ) indices = (u * self.noise_scheduler.config.num_train_timesteps).long() timesteps = self.noise_scheduler.timesteps[indices].to(device=model_input.device) sigmas = self.noise_scheduler.sigmas.to(device=model_input.device, dtype=dtype) schedule_timesteps = self.noise_scheduler.timesteps.to(model_input.device) timesteps = timesteps.to(model_input.device) step_indices = [(schedule_timesteps == t).nonzero().item() for t in timesteps] sigma = sigmas[step_indices].flatten() while len(sigma.shape) < model_input.ndim: sigma = sigma.unsqueeze(-1) sigmas = sigma if not self.noise_scheduler.config.invert_sigmas: noisy_video_latents = (1.0 - sigmas) * model_input + sigmas * noise else: noisy_video_latents = sigmas * model_input + (1 - sigmas) * noise if args.task == 't2v': noisy_model_input = noisy_video_latents # add i2v elif args.task == 'i2v': noisy_model_input = torch.cat([noisy_video_latents, image_latents], dim=1) # add token replace do_token_replace = False loss_mask = torch.ones_like(model_input) token_replace_prob = model_kwargs.get('token_replace_prob', 0.0) num_frames = model_input.shape[2] num_replace_frames = 2 if random.random() < token_replace_prob and num_frames > num_replace_frames: do_token_replace = True loss_mask[:, :, :num_replace_frames, :, :] = 0 noisy_model_input[:, :, :num_replace_frames, :, :] = model_input[:, :, :num_replace_frames, :, :] model_pred = model( hidden_states = noisy_model_input, encoder_hidden_states = model_kwargs['encoder_hidden_states'], timestep = timesteps, controlnet_cond = condition, conditioning_scale = model_kwargs['conditioning_scale'], controlnet_blocks_repeat = False, #NOTE：pay attention image_pose = model_kwargs.get('image_pose',None), return_dict=False, image_latents = model_kwargs['image_latents'], token_replace = do_token_replace )[0] weighting = compute_loss_weighting_for_sd3(weighting_scheme=args.weighting_scheme, sigmas=sigmas) if not self.noise_scheduler.config.invert_sigmas: target = noise - model_input else: target = model_input - noise # add_ocr mask here b, c, t, h, w = model_input.shape ocr_mask = model_kwargs["ocr_mask"] ocr_mask = rearrange(ocr_mask, "b c t H W -> (b t) c H W") # 确保是0,1不会出现其他的值， 插值到latent shape ocr_mask = F.interpolate(ocr_mask, size=(h, w), mode='nearest') ocr_mask = rearrange(ocr_mask, "(b t) c h w -> b c t h w", t=t) # c = 1 ocr_mask = ocr_mask.expand(-1, c, -1, -1, -1) final_mask = loss_mask.float() * ocr_mask.float() # auto broadcast loss = (weighting.float() * (model_pred.float() - target.float()) ** 2 * final_mask) if args.face_mask: face_mask = model_kwargs["face_mask"] face_mask = rearrange(face_mask, "b c t H W -> (b t) c H W") face_mask = F.interpolate(face_mask, size=(h, w), mode='nearest') face_mask = rearrange(face_mask, "(b t) c h w -> b c t h w", t=t) face_mask = face_mask.expand(-1, c, -1, -1, -1) loss = loss * ((args.face_weight - 1) * face_mask + 1).float() loss = loss.reshape(target.shape[0], -1).mean() return loss class PyramidFlowMatching(): #TODO: 相对SD3中的flow matching，缺少了两个部分，分别是timesteps的非均匀采样，以及loss的weighting机制 def __init__(self): # self.stages = stages # self.scheduler = AutoRegressivePyramidFlowMatchEulerDiscreteScheduler(stages = stages, stage_range = stage_range) from opensora.sample.flow_matching_scheduler import PyramidFlowMatchEulerDiscreteScheduler self.scheduler = PyramidFlowMatchEulerDiscreteScheduler(stages=3, stage_range=[0, 1/3, 2/3, 1]) self.stages = 3 # 前向运算计算loss # 暂时的训练逻辑：防止batch_size过大，先每个step计算一个stage，然后累积3步 def get_loss(self, model, model_input, model_kwargs, args, **kwargs): dtype = model_input.dtype assert 'stage_index' in kwargs, "passing stage index for pyramid training" stage_index = kwargs['stage_index'] # need # 这里对当前latent下采样到当前的stage进行计算，由于patch_size是2，所以下采样之后的长宽需要能够整除2 bsz = model_input.shape[0] current_step_frame = model_input.shape[2] height, width = model_input.shape[3:] resize_scale = 2**(self.stages - stage_index - 1) resized_height, resized_width = int(height / resize_scale), int(width / resize_scale) resized_height += resized_height % 2 resized_width += resized_width % 2 model_input = rearrange(model_input, "b c t h w -> (b t) c h w") model_input = F.interpolate(model_input, size = (resized_height, resized_width), mode = 'nearest') model_input = rearrange(model_input, "(b t) c h w -> b c t h w", t = current_step_frame) height, width = model_input.shape[3:] noise = torch.randn_like(model_input) import ipdb ipdb.set_trace() #TODO: 目前是随机采样 timesteps_indices = torch.randint(0, len(self.scheduler.timesteps_per_stage[stage_index]), (bsz,)) timesteps = self.scheduler.timesteps_per_stage[stage_index][timesteps_indices].to(model_input.device) sigmas = self.scheduler.sigmas_per_stage[stage_index][timesteps_indices].to(model_input.device) start_sigma = self.scheduler.start_sigmas[stage_index] end_sigma = self.scheduler.end_sigmas[stage_index] stage_start_point = rearrange(model_input, "b c t h w -> (b t) c h w") stage_start_point = F.interpolate(stage_start_point, size = (int(height//2), int(width//2)), mode = 'bilinear') stage_start_point = F.interpolate(stage_start_point, size = (height, width), mode = 'nearest') stage_start_point = rearrange(stage_start_point, "(b t) c h w -> b c t h w", t = current_step_frame) if self.scheduler.invert_sigmas: stage_start_point = start_sigma * stage_start_point + (1 - start_sigma) * noise stage_end_point = end_sigma * model_input + (1 - end_sigma) * noise else: stage_start_point = (1 - start_sigma) * stage_start_point + start_sigma * noise stage_end_point = (1 - end_sigma) * model_input + end_sigma * noise while len(sigmas.shape) < model_input.ndim: sigmas = sigmas.unsqueeze(-1) if self.scheduler.invert_sigmas: noisy_model_input = (1.0 - sigmas) * stage_start_point + sigmas * stage_end_point else: noisy_model_input = sigmas * stage_start_point + (1 - sigmas) * stage_end_point model_pred = model( noisy_model_input, timesteps, **model_kwargs )[0] if args.prediction_type is not None: # set prediction_type of scheduler if defined self.noise_scheduler.register_to_config(prediction_type=args.prediction_type) if self.scheduler.invert_sigmas: target = stage_end_point - stage_start_point else: target = stage_start_point - stage_end_point b, c, t_shard, _, _ = model_pred.shape # Compute regular loss. loss = ((model_pred.float() - target.float()) ** 2).reshape(target.shape[0], -1) loss = loss.mean() return loss class AutoRegressivePyramidFlowMatching(): #TODO: 相对SD3中的flow matching，缺少了两个部分，分别是timesteps的非均匀采样，以及loss的weighting机制 def __init__(self, stages, stage_range, process_index, model_name='arpf', max_unit_num=8, frame_per_unit=1, max_history_len=4, extra_sample_steps=1): self.stages = stages self.scheduler = AutoRegressivePyramidFlowMatchEulerDiscreteScheduler(stages = stages, stage_range = stage_range) self.frame_per_unit = frame_per_unit # 每次训练多少个latent if model_name == 'arpf': self.vae_shift_factor = 0.1490 self.vae_scale_factor = 1 / 1.8415 elif model_name == 'flux_arpf': self.vae_shift_factor = -0.04 self.vae_scale_factor = 1 / 1.8726 # For the video latent self.vae_video_shift_factor = -0.2343 self.vae_video_scale_factor = 1 / 3.0986 self.max_history_len = max_history_len assert self.max_history_len > self.stages - 1 self.extra_sample_steps = extra_sample_steps self.iters = 0 self.process_index = process_index self.max_unit_num = max_unit_num self.sample_ratios = [1,2,1] @torch.no_grad() def get_pyramid_latent(self, x, stage_num, generator=None): # TODO: 增加noise vae_latent_list = [] vae_latent_list.append(x) #当前stage temp, height, width = x.shape[-3:] for _ in range(stage_num): height //= 2 width //= 2 height += height % 2 width += width % 2 x = rearrange(x, 'b c t h w -> (b t) c h w') x = F.interpolate(x, size = (height, width), mode='bilinear') x = rearrange(x, '(b t) c h w -> b c t h w', t=temp) vae_latent_list.append(x) vae_latent_list = list(reversed(vae_latent_list)) # idx和stage_index相对应 return vae_latent_list def sample_stage_length(self, num_stages, max_units = None): self.video_sync_group = self.max_unit_num max_units_in_training = 1 + ((self.max_unit_num - 1) // self.frame_per_unit) cur_rank = self.process_index self.iters = self.iters + 1 total_turns = max_units_in_training // self.video_sync_group #NOTE: video_sync_group update_turn = self.iters % total_turns # # uniformly sampling each position cur_highres_unit = max(int((cur_rank % self.video_sync_group + 1) + update_turn * self.video_sync_group), 1) cur_mid_res_unit = max(1 + max_units_in_training - cur_highres_unit, 1) cur_low_res_unit = cur_mid_res_unit #平衡下速度的考量 if max_units is not None: cur_highres_unit = min(cur_highres_unit, max_units) cur_mid_res_unit = min(cur_mid_res_unit, max_units) cur_low_res_unit = min(cur_low_res_unit, max_units) length_list = [cur_low_res_unit, cur_mid_res_unit, cur_highres_unit] assert len(length_list) == num_stages return length_list @torch.no_grad() def add_pyramid_noise( self, latents_list, sample_ratios=[1, 1, 1], ): """ add the noise for each pyramidal stage noting that, this method is a general strategy for pyramid-flow, it can be used for both image and video training. You can also use this method to train pyramid-flow with full-sequence diffusion in video generation (without using temporal pyramid and autoregressive modeling) Params: latent_list: [low_res, mid_res, high_res] The vae latents of all stages sample_ratios: The proportion of each stage in the training batch """ noise = torch.randn_like(latents_list[-1]) device = noise.device dtype = latents_list[-1].dtype t = noise.shape[2] stages = self.stages tot_samples = noise.shape[0] assert tot_samples % (int(sum(sample_ratios))) == 0 assert stages == len(sample_ratios) height, width = noise.shape[-2], noise.shape[-1] noise_list = [noise] cur_noise = noise for i_s in range(stages-1): height //= 2;width //= 2 height += height % 2 width += width % 2 cur_noise = rearrange(cur_noise, 'b c t h w -> (b t) c h w') cur_noise = F.interpolate(cur_noise, size=(height, width), mode='bilinear') * 2 cur_noise = rearrange(cur_noise, '(b t) c h w -> b c t h w', t=t) noise_list.append(cur_noise) noise_list = list(reversed(noise_list)) # make sure from low res to high res # To calculate the padding batchsize and column size batch_size = tot_samples // int(sum(sample_ratios)) column_size = int(sum(sample_ratios)) column_to_stage = {} #每个数据对应哪个stage i_sum = 0 for i_s, column_num in enumerate(sample_ratios): for index in range(i_sum, i_sum + column_num): column_to_stage[index] = i_s i_sum += column_num noisy_latents_list = [] ratios_list = [] targets_list = [] timesteps_list = [] training_steps = self.scheduler.config.num_train_timesteps # from low resolution to high resolution for index in range(column_size): i_s = column_to_stage[index] clean_latent = latents_list[i_s][index::column_size] # 哪些样本在这个column # [bs, c, t, h, w] last_clean_latent = None if i_s == 0 else latents_list[i_s-1][index::column_size] # 否则的话，就是更早一级的latent start_sigma = self.scheduler.start_sigmas[i_s] end_sigma = self.scheduler.end_sigmas[i_s] if i_s == 0: start_point = noise_list[i_s][index::column_size] #stage 0的，初始的latent就是noise else: # Get the upsampled latent last_clean_latent = rearrange(last_clean_latent, 'b c t h w -> (b t) c h w') last_clean_latent = F.interpolate(last_clean_latent, size=(clean_latent.shape[-2], clean_latent.shape[-1]), mode='nearest') last_clean_latent = rearrange(last_clean_latent, '(b t) c h w -> b c t h w', t=t) start_point = start_sigma * noise_list[i_s][index::column_size] + (1 - start_sigma) * last_clean_latent if i_s == stages - 1: end_point = clean_latent else: end_point = end_sigma * noise_list[i_s][index::column_size] + (1 - end_sigma) * clean_latent # To sample a timestep u = compute_density_for_timestep_sampling( weighting_scheme='random', batch_size=batch_size, logit_mean=0.0, logit_std=1.0, mode_scale=1.29, ) indices = (u * training_steps).long() # Totally 1000 training steps per stage indices = indices.clamp(0, training_steps-1) timesteps = self.scheduler.timesteps_per_stage[i_s][indices].to(device=device) ratios = self.scheduler.sigmas_per_stage[i_s][indices].to(device=device) while len(ratios.shape) < start_point.ndim: ratios = ratios.unsqueeze(-1) # interpolate the latent noisy_latents = ratios * start_point + (1 - ratios) * end_point # last_cond_noisy_sigma = torch.rand(size=(batch_size,), device=device) * self.corrupt_ratio # [stage1_latent, stage2_latent, ..., stagen_latent], which will be concat after patching noisy_latents_list.append([noisy_latents.to(dtype)]) ratios_list.append(ratios.to(dtype)) timesteps_list.append(timesteps.to(dtype)) targets_list.append(start_point - end_point) # The standard rectified flow matching objective return noisy_latents_list, ratios_list, timesteps_list, targets_list @torch.no_grad() def add_pyramid_noise_with_temporal_pyramid( self, latents_list, sample_ratios=[1, 1, 1], ): stages = self.stages tot_samples = latents_list[0].shape[0] device = latents_list[0].device dtype = latents_list[0].dtype assert tot_samples % (int(sum(sample_ratios))) == 0 assert stages == len(sample_ratios) noise = torch.randn_like(latents_list[-1]) t = noise.shape[2] max_units = 1 + (t - 1) // self.frame_per_unit num_units_per_stage = self.sample_stage_length(stages, max_units=max_units) # [The unit number of each stage] height, width = noise.shape[-2], noise.shape[-1] noise_list = [noise] cur_noise = noise for i_s in range(stages-1): height //= 2;width //= 2 height += height % 2 width += width % 2 cur_noise = rearrange(cur_noise, 'b c t h w -> (b t) c h w') cur_noise = F.interpolate(cur_noise, size=(height, width), mode='bilinear') * 2 cur_noise = rearrange(cur_noise, '(b t) c h w -> b c t h w', t=t) noise_list.append(cur_noise) noise_list = list(reversed(noise_list)) batch_size = tot_samples // int(sum(sample_ratios)) column_size = int(sum(sample_ratios)) column_to_stage = {} i_sum = 0 for i_s, column_num in enumerate(sample_ratios): for index in range(i_sum, i_sum + column_num): column_to_stage[index] = i_s i_sum += column_num noisy_latents_list = [] ratios_list = [] targets_list = [] timesteps_list = [] training_steps = self.scheduler.config.num_train_timesteps for index in range(column_size): # First prepare the trainable latent construction i_s = column_to_stage[index] clean_latent = latents_list[i_s][index::column_size] # [bs, c, t, h, w] last_clean_latent = None if i_s == 0 else latents_list[i_s-1][index::column_size] start_sigma = self.scheduler.start_sigmas[i_s] end_sigma = self.scheduler.end_sigmas[i_s] if i_s == 0: start_point = noise_list[i_s][index::column_size] else: # Get the upsampled latent last_clean_latent = rearrange(last_clean_latent, 'b c t h w -> (b t) c h w') last_clean_latent = F.interpolate(last_clean_latent, size=(clean_latent.shape[-2], clean_latent.shape[-1]), mode='nearest') last_clean_latent = rearrange(last_clean_latent, '(b t) c h w -> b c t h w', t=t) start_point = start_sigma * noise_list[i_s][index::column_size] + (1 - start_sigma) * last_clean_latent if i_s == stages - 1: end_point = clean_latent else: end_point = end_sigma * noise_list[i_s][index::column_size] + (1 - end_sigma) * clean_latent u = compute_density_for_timestep_sampling( weighting_scheme='random', batch_size=batch_size, logit_mean=0.0, logit_std=1.0, mode_scale=1.29, ) indices = (u * training_steps).long() # Totally 1000 training steps per stage indices = indices.clamp(0, training_steps-1) timesteps = self.scheduler.timesteps_per_stage[i_s][indices].to(device=device) ratios = self.scheduler.sigmas_per_stage[i_s][indices].to(device=device) noise_ratios = ratios * start_sigma + (1 - ratios) * end_sigma while len(ratios.shape) < start_point.ndim: ratios = ratios.unsqueeze(-1) noisy_latents = ratios * start_point + (1 - ratios) * end_point # The flow matching object target_latents = start_point - end_point num_units = num_units_per_stage[i_s] num_units = min(num_units, 1 + (t - 1) // self.frame_per_unit) actual_frames = 1 + (num_units - 1) * self.frame_per_unit noisy_latents = noisy_latents[:, :, :actual_frames] target_latents = target_latents[:, :, :actual_frames] clean_latent = clean_latent[:, :, :actual_frames] stage_noise = noise_list[i_s][index::column_size][:, :, :actual_frames] # only the last latent takes part in training noisy_latents = noisy_latents[:, :, -self.frame_per_unit:] target_latents = target_latents[:, :, -self.frame_per_unit:] last_cond_noisy_sigma = torch.rand(size=(batch_size,), device=device) * 1/3 if num_units == 1: stage_input = [noisy_latents.to(dtype)] else: last_cond_latent = clean_latent[:, :, -(2*self.frame_per_unit):-self.frame_per_unit] while len(last_cond_noisy_sigma.shape) < last_cond_latent.ndim: last_cond_noisy_sigma = last_cond_noisy_sigma.unsqueeze(-1) last_cond_latent = last_cond_noisy_sigma * torch.randn_like(last_cond_latent) + (1 - last_cond_noisy_sigma) * last_cond_latent stage_input = [noisy_latents.to(dtype), last_cond_latent.to(dtype)] cur_unit_num = 2 cur_stage = i_s while cur_unit_num < num_units: cur_stage = max(cur_stage - 1, 0) if cur_stage == 0: break cur_unit_num += 1 cond_latents = latents_list[cur_stage][index::column_size][:, :, :actual_frames] cond_latents = cond_latents[:, :, -(cur_unit_num * self.frame_per_unit) : -((cur_unit_num - 1) * self.frame_per_unit)] cond_latents = last_cond_noisy_sigma * torch.randn_like(cond_latents) + (1 - last_cond_noisy_sigma) * cond_latents stage_input.append(cond_latents.to(dtype)) if cur_stage == 0 and cur_unit_num < num_units: cond_latents = latents_list[0][index::column_size][:, :, :actual_frames] cond_latents = cond_latents[:, :, :-(cur_unit_num * self.frame_per_unit)] cond_latents = last_cond_noisy_sigma * torch.randn_like(cond_latents) + (1 - last_cond_noisy_sigma) * cond_latents stage_input.append(cond_latents.to(dtype)) stage_input = list(reversed(stage_input)) noisy_latents_list.append(stage_input) ratios_list.append(ratios.to(dtype)) timesteps_list.append(timesteps.to(dtype)) targets_list.append(target_latents) return noisy_latents_list, ratios_list, timesteps_list, targets_list @torch.no_grad() def get_vae_latent(self, video, use_temporal_pyramid=True): # if video.shape[2] == 1: # # is image # video = (video - self.vae_shift_factor) * self.vae_scale_factor # else: # # is video # video[:, :, :1] = (video[:, :, :1] - self.vae_shift_factor) * self.vae_scale_factor # video[:, :, 1:] = (video[:, :, 1:] - self.vae_video_shift_factor) * self.vae_video_scale_factor vae_latent_list = self.get_pyramid_latent(video, self.stages - 1) if use_temporal_pyramid: noisy_latents_list, ratios_list, timesteps_list, targets_list = self.add_pyramid_noise_with_temporal_pyramid(vae_latent_list, self.sample_ratios) else: noisy_latents_list, ratios_list, timesteps_list, targets_list = self.add_pyramid_noise(vae_latent_list, self.sample_ratios) return noisy_latents_list, ratios_list, timesteps_list, targets_list def calculate_loss(self, model_preds_list, targets_list): loss_list = [] for model_pred, target in zip(model_preds_list, targets_list): loss_weight = torch.ones_like(target) loss = torch.mean( (loss_weight.float() * (model_pred.float() - target.float()) ** 2).reshape(target.shape[0], -1), 1, ) loss_list.append(loss) diffusion_loss = torch.cat(loss_list, dim=0).mean() return diffusion_loss def get_loss(self, model, model_input, model_kwargs, args, accelerator, **kwargs): #代码部分仍需要注意，因为这里会根据rank来进行划分 video = model_input xdim = video.ndim device = video.device with torch.no_grad(), accelerator.autocast(): batch_size = len(video) prompt_embeds, prompt_attention_mask, pooled_prompt_embeds = \ model_kwargs['encoder_hidden_states'], model_kwargs['encoder_attention_mask'], model_kwargs['encoder_pooled_projections'] noisy_latents_list, ratios_list, timesteps_list, targets_list = self.get_vae_latent(video, use_temporal_pyramid=True) timesteps = torch.cat([timestep.unsqueeze(-1) for timestep in timesteps_list], dim=-1) timesteps = timesteps.reshape(-1) assert timesteps.shape[0] == prompt_embeds.shape[0] model_preds_list = model( sample=noisy_latents_list, timestep_ratio=timesteps, encoder_hidden_states=prompt_embeds, encoder_attention_mask=prompt_attention_mask, pooled_projections=pooled_prompt_embeds, ) return self.calculate_loss(model_preds_list, targets_list) # 前向运算计算loss def get_loss_2(self, model, model_input, model_kwargs, args, **kwargs): #实际会更慢 # TODO: 优化自回归训练策略 # 如果使用不同的自回归长度，无疑会让sample的数量增长很多 # 修改成不同stages dtype = model_input.dtype assert 'stage_index' in kwargs, "passing stage index for pyramid training" stage_index = kwargs['stage_index'] # need bsz = model_input.shape[0] temp = model_input.shape[2] frame_per_unit = self.frame_per_unit model_input[:, :, 0:1] = (model_input[:, :, 0:1] - self.vae_shift_factor) * self.vae_scale_factor if model_input.shape[2] > 1: model_input[:, :, 1:] = (model_input[:, :, 1:] - self.vae_video_shift_factor) * self.vae_video_scale_factor clean_latents_list = self.get_pyramid_latent(model_input, self.stages-1) #TODO: 目前是随机采样 timesteps用相同的 #NOTE: 开头和结尾都能够取到 #TODO: 暂时只能支持frame_per_unit=1的情况 sample_list = [] target_list = [] timesteps_list = [] # stage_list = np.arange(self.stages) #同时包含所有stages self.iters += 1 assert self.stages == 3 stage_list = [1] #进行某个特定stage的优化 if (self.iters + self.process_index) % 2 == 0: stage_list.append(0) elif (self.iters + self.process_index) % 2 == 1: stage_list.append(2) else: raise ValueError # stage_list = [0,1,1,2] # stage_2_length = (self.iters + self.process_index) % (self.max_unit_num-1) + 1 # stage_1_length = self.max_unit_num - 1 - (self.iters + self.process_index) % (self.max_unit_num-1) # stage_0_length = stage_2_length #按照这个逻辑的话，stage2的耗时最长，因此最好让stage0和stage1用相同的步数 # 1到6 #如果每个stage包含多个自回归长度的话，不如从这里入手，更加均匀 应该是0到6 frame_idx_list = [(self.process_index) % (self.max_unit_num), self.max_unit_num - 1 - (self.process_index) % (self.max_unit_num)] print(self.process_index, stage_list, frame_idx_list) # frame_idx_list = [stage_0_length, stage_1_length, stage_1_length, stage_2_length] for idx, stage_index in enumerate(stage_list): #TODO: 按照rank进行分配 # u = compute_density_for_timestep_sampling( # weighting_scheme='random', # batch_size=bsz, # logit_mean=0.0, # logit_std=1.0, # mode_scale=1.29, # ) # indices = (u * len(self.scheduler.timesteps_per_stage[stage_index])).long() # timesteps_indices = indices.clamp(0, len(self.scheduler.timesteps_per_stage[stage_index])-1) timesteps_indices = torch.randint(0, len(self.scheduler.timesteps_per_stage[stage_index]), (bsz,)) timesteps = self.scheduler.timesteps_per_stage[stage_index][timesteps_indices].to(model_input.device, dtype=dtype) sigmas = self.scheduler.sigmas_per_stage[stage_index][timesteps_indices].to(model_input.device, dtype=dtype) start_sigma = self.scheduler.start_sigmas[stage_index] end_sigma = self.scheduler.end_sigmas[stage_index] while len(sigmas.shape) < model_input.ndim: sigmas = sigmas.unsqueeze(-1) # timesteps_list.append(timesteps.unsqueeze(1)) #可以最多选择两种长度？ #TODO: 可以修改成根据rank来在不同的steps中进行均衡的策略 frame_idx_list_stage = [frame_idx_list[idx]] # if temp > 2: # frame_idx_list = list(np.random.permutation(np.arange(1, temp)))[:self.extra_sample_steps] timesteps_list.append(timesteps.unsqueeze(1).repeat(1, len(frame_idx_list_stage))) for frame_idx in frame_idx_list_stage: frame_idx = min(model_input.shape[2]-1, frame_idx) cur_latent = model_input[:, :, frame_idx:frame_idx+1] if frame_idx == 0: stage_input = [] else: last_cond_latent = clean_latents_list[stage_index][:, :, frame_idx-frame_per_unit:frame_idx] last_cond_noisy_sigma = torch.rand(size=(bsz,), device=model_input.device, dtype=cur_latent.dtype) * 1 / 3 while len(last_cond_noisy_sigma.shape) < last_cond_latent.ndim: last_cond_noisy_sigma = last_cond_noisy_sigma.unsqueeze(-1) last_cond_latent = last_cond_noisy_sigma * torch.randn_like(last_cond_latent, device=model_input.device, dtype=cur_latent.dtype) + (1 - last_cond_noisy_sigma) * last_cond_latent stage_input = [last_cond_latent] cur_unit_num = frame_idx cur_stage = stage_index cur_unit_ptx = 1 #这里是diff while cur_unit_ptx < cur_unit_num: cur_stage = max(cur_stage-1, 0) if cur_stage == 0: break cur_unit_ptx += 1 cond_latents = clean_latents_list[cur_stage][:, :, frame_idx-cur_unit_ptx * frame_per_unit:frame_idx - (cur_unit_ptx-1)*frame_per_unit] cond_latents = last_cond_noisy_sigma * torch.randn_like(cond_latents, device=model_input.device, dtype=cur_latent.dtype) + (1 - last_cond_noisy_sigma) * cond_latents stage_input.append(cond_latents) if cur_stage == 0 and cur_unit_ptx < cur_unit_num: cond_latents = clean_latents_list[cur_stage][:, :, :frame_idx - cur_unit_ptx * frame_per_unit] if cond_latents.shape[2] > self.max_history_len-len(stage_input): cond_latents = cond_latents[:, :, -(self.max_history_len-len(stage_input)):] cond_latents = last_cond_noisy_sigma * torch.randn_like(cond_latents, device=model_input.device, dtype=cur_latent.dtype) + (1 - last_cond_noisy_sigma) * cond_latents stage_input.append(cond_latents) stage_input = list(reversed(stage_input)) height, width = cur_latent.shape[3:] cur_latent = rearrange(cur_latent, "b c t h w -> (b t) c h w") noise = torch.randn_like(cur_latent, device = cur_latent.device, dtype=cur_latent.dtype) #noise考虑用不同的 for _ in range(self.stages - stage_index - 1): height //= 2 width //= 2 height += height % 2 width += width % 2 cur_latent = F.interpolate(cur_latent, size = (height, width), mode = 'bilinear') noise = F.interpolate(noise, size = (height, width), mode = 'bilinear') * 2 cur_latent = rearrange(cur_latent, "(b t) c h w -> b c t h w", t = frame_per_unit) noise = rearrange(noise, "(b t) c h w -> b c t h w", t = frame_per_unit) height, width = cur_latent.shape[3:] stage_start_point = rearrange(cur_latent, "b c t h w -> (b t) c h w") stage_start_point = F.interpolate(stage_start_point, size = (int(height//2), int(width//2)), mode = 'bilinear') stage_start_point = F.interpolate(stage_start_point, size = (height, width), mode = 'nearest') #TODO: check这里是否修改 stage_start_point = rearrange(stage_start_point, "(b t) c h w -> b c t h w", t = frame_per_unit) stage_start_point = (1 - start_sigma) * stage_start_point + start_sigma * noise stage_end_point = (1 - end_sigma) * cur_latent + end_sigma * noise noisy_model_input = (1 - sigmas) * stage_end_point + sigmas * stage_start_point noisy_model_input = stage_input + [noisy_model_input] target = stage_start_point - stage_end_point sample_list.append(noisy_model_input) target_list.append(target) timesteps = torch.cat(timesteps_list, dim=1).reshape(len(sample_list)*bsz) model_pred = model( sample = sample_list, #实际上可以同一个样本构建多个自回归的序列。这样就不会出现问题了 timestep_ratio = timesteps, # torch.repeat_interleave(timesteps, repeats = len(sample_list), dim=0), encoder_hidden_states = torch.repeat_interleave(model_kwargs['encoder_hidden_states'], repeats = len(sample_list), dim=0), encoder_attention_mask = torch.repeat_interleave(model_kwargs['encoder_attention_mask'], repeats = len(sample_list), dim=0), pooled_projections = torch.repeat_interleave(model_kwargs['encoder_pooled_projections'], repeats = len(sample_list), dim=0) ) mask = model_kwargs.get('attention_mask', None) if torch.all(mask.bool()): mask = None assert mask is None #否则的话，就需要对mask也进行下采样了 # model_pred = torch.stack(model_pred) # target = torch.stack(target_list) model_pred_ = torch.cat([pred.reshape(bsz, -1) for pred in model_pred], dim=1) target_ = torch.cat([gt.reshape(bsz, -1) for gt in target_list], dim=1) loss = ((model_pred_.float() - target_.float()) ** 2).reshape(bsz, -1) loss = loss.mean() return loss @torch.no_grad() def get_valid_loss(self, model, model_input, model_kwargs, args, **kwargs): #验证的逻辑: 3个stage，所有可能的自回归长度 dtype = model_input.dtype assert 'stage_index' in kwargs, "passing stage index for pyramid training" stage_index = kwargs['stage_index'] # need assert 'evaluate_steps' in kwargs, "passing how many steps to evaluate" evaluate_steps = kwargs['evaluate_steps'] bsz = model_input.shape[0] temp = model_input.shape[2] frame_per_unit = self.frame_per_unit # model_input[:, :, 0:1] = (model_input[:, :, 0:1] - self.vae_shift_factor) * self.vae_scale_factor # if model_input.shape[2] > 1: # model_input[:, :, 1:] = (model_input[:, :, 1:] - self.vae_video_shift_factor) * self.vae_video_scale_factor generator = torch.torch.Generator(device = model_input.device) generator.manual_seed(42) clean_latents_list = self.get_pyramid_latent(model_input, self.stages-1, generator=generator) past_condition_list = [] cur_latent_list = [] for frame_idx in range(temp): cur_latent = model_input[:, :, frame_idx:frame_idx+1] if frame_idx == 0: stage_input = [] else: last_cond_latent = clean_latents_list[stage_index][:, :, frame_idx-frame_per_unit:frame_idx] stage_input = [last_cond_latent] cur_unit_num = frame_idx cur_stage = stage_index cur_unit_ptx = 1 while cur_unit_ptx < cur_unit_num: cur_stage = max(cur_stage-1, 0) if cur_stage == 0: break cur_unit_ptx += 1 cond_latents = clean_latents_list[cur_stage][:, :, frame_idx-cur_unit_ptx * frame_per_unit:frame_idx - (cur_unit_ptx-1)*frame_per_unit] stage_input.append(cond_latents) if cur_stage == 0 and cur_unit_ptx < cur_unit_num: cond_latents = clean_latents_list[cur_stage][:, :, :frame_idx - cur_unit_ptx * frame_per_unit] if cond_latents.shape[2] > self.max_history_len-len(stage_input): cond_latents = cond_latents[:, :, -(self.max_history_len-len(stage_input)):] stage_input.append(cond_latents) stage_input = list(reversed(stage_input)) past_condition_list.append(stage_input) height, width = cur_latent.shape[3:] cur_latent = rearrange(cur_latent, "b c t h w -> (b t) c h w") for _ in range(self.stages - stage_index - 1): height //= 2 width //= 2 height += height % 2 width += width % 2 cur_latent = F.interpolate(cur_latent, size = (height, width), mode = 'bilinear') cur_latent = rearrange(cur_latent, "(b t) c h w -> b c t h w", t = frame_per_unit) cur_latent_list.append(cur_latent) loss_list = [] for step_i in range(evaluate_steps): generator = torch.torch.Generator(device = model_input.device) generator.manual_seed(42+step_i) timesteps_indices = torch.ones((bsz,), dtype=int) * (step_i * len(self.scheduler.timesteps_per_stage[stage_index]) // evaluate_steps) timesteps = self.scheduler.timesteps_per_stage[stage_index][timesteps_indices].to(model_input.device, dtype=dtype) sigmas = self.scheduler.sigmas_per_stage[stage_index][timesteps_indices].to(model_input.device, dtype=dtype) start_sigma = self.scheduler.start_sigmas[stage_index] end_sigma = self.scheduler.end_sigmas[stage_index] while len(sigmas.shape) < model_input.ndim: sigmas = sigmas.unsqueeze(-1) #TODO: 暂时只能支持frame_per_unit=1的情况 sample_list = [] target_list = [] for frame_idx in range(temp): stage_input = past_condition_list[frame_idx] cur_latent = cur_latent_list[frame_idx] height, width = cur_latent.shape[3:] # noise = torch.randn_like(cur_latent, generator=generator) #noise考虑用不同的 noise = randn_tensor(cur_latent.shape, generator=generator, device=cur_latent.device, dtype=cur_latent.dtype) stage_start_point = rearrange(cur_latent, "b c t h w -> (b t) c h w") stage_start_point = F.interpolate(stage_start_point, size = (int(height//2), int(width//2)), mode = 'bilinear') stage_start_point = F.interpolate(stage_start_point, size = (height, width), mode = 'nearest') #TODO: check这里是否修改 stage_start_point = rearrange(stage_start_point, "(b t) c h w -> b c t h w", t = frame_per_unit) stage_start_point = (1 - start_sigma) * stage_start_point + start_sigma * noise stage_end_point = (1 - end_sigma) * cur_latent + end_sigma * noise noisy_model_input = (1 - sigmas) * stage_end_point + sigmas * stage_start_point noisy_model_input = stage_input + [noisy_model_input] target = stage_start_point - stage_end_point sample_list.append(noisy_model_input) target_list.append(target) model_pred = model( sample = sample_list, #实际上可以同一个样本构建多个自回归的序列。这样就不会出现问题了 timestep_ratio = torch.repeat_interleave(timesteps, repeats = len(sample_list), dim=0), encoder_hidden_states = torch.repeat_interleave(model_kwargs['encoder_hidden_states'], repeats = len(sample_list), dim=0), encoder_attention_mask = torch.repeat_interleave(model_kwargs['encoder_attention_mask'], repeats = len(sample_list), dim=0), pooled_projections = torch.repeat_interleave(model_kwargs['encoder_pooled_projections'], repeats = len(sample_list), dim=0) ) # mask = model_kwargs.get('attention_mask', None) # if torch.all(mask.bool()): # mask = None # assert mask is None #否则的话，就需要对mask也进行下采样了 model_pred = torch.stack(model_pred) target = torch.stack(target_list) loss = ((model_pred.float() - target.float()) ** 2).reshape(target.shape[0], -1) # loss = loss.mean() loss_list.append(loss) loss_list = torch.stack(loss_list) return loss_list class EDM(): def __init__(self): self.edm_loss = EDMLoss() print('====> use EDM Precondition !!!') def get_loss(self, model, model_input, model_kwargs, args, **kwargs): model = partial(model, **model_kwargs) loss = self.edm_loss(model, model_input) mask = model_kwargs.get('attention_mask', None) if torch.all(mask.bool()): mask = None b, c, t_shard, _, _ = loss.shape if mask is not None: # 实际上不知道这里是哪里，因此需要所有帧的attention mask是一样的，确保在时序上不会补帧即可 mask = mask.unsqueeze(1).repeat(1, c, 1, 1, 1).float()[:, :, -t_shard:, :, :] # b t h w -> b c t h w mask = mask.reshape(b, -1) loss = loss.reshape(b, -1) if mask is not None: loss = (loss * mask).sum() / mask.sum() else: loss = loss.mean() return loss