import random import torch import torch.nn.functional as F from accelerate.logging import get_logger from einops import rearrange from diffusers.training_utils import compute_density_for_timestep_sampling, compute_loss_weighting_for_sd3, free_memory from .utils_base import apply_schedule_shift, get_config_value from .utils_recycle_batch import apply_error_injection, process_and_update_error_buffers logger = get_logger(__name__) # ======================================== flow loss ======================================== def _flow_loss( args, accelerator, lr_scheduler, transformer, prompt_embeds, prompt_attention_masks, noisy_model_input_list, sigmas_list, timesteps_list, targets_list, indices_hidden_states, latents_history_short, indices_latents_history_short, latents_history_mid, indices_latents_history_mid, latents_history_long, indices_latents_history_long, recycle_vars, global_step, noise_scheduler_copy, use_clean_input, ): assert len(noisy_model_input_list) == len(sigmas_list) == len(timesteps_list) == len(targets_list) for noisy_model_input, sigmas, timesteps, target in zip( noisy_model_input_list, sigmas_list, timesteps_list, targets_list ): # ----- w/o mini batch ------ model_pred = transformer( hidden_states=noisy_model_input, timestep=timesteps, encoder_hidden_states=prompt_embeds, indices_hidden_states=indices_hidden_states, # torch.Size([2, 9]) indices_latents_history_short=indices_latents_history_short, # torch.Size([2, 2]) indices_latents_history_mid=indices_latents_history_mid, # torch.Size([2, 2]) indices_latents_history_long=indices_latents_history_long, # torch.Size([2, 16]) latents_history_short=latents_history_short, # torch.Size([2, 16, 2, 60, 104]) latents_history_mid=latents_history_mid, # torch.Size([2, 16, 2, 60, 104]) latents_history_long=latents_history_long, # torch.Size([2, 16, 16, 60, 104]) return_dict=False, )[0] # Compute regular loss. if isinstance(model_pred, list): loss_list = [] for cur_model_pred, cur_target, cur_sigmas in zip(model_pred, target, sigmas): cur_weighting = compute_loss_weighting_for_sd3( weighting_scheme=args.training_config.weighting_scheme, sigmas=cur_sigmas ) loss = torch.mean( (cur_weighting.float() * (cur_model_pred.float() - cur_target.float()) ** 2).reshape( cur_target.shape[0], -1 ), 1, ).mean() loss_list.append(loss) loss = torch.stack(loss_list, dim=0).mean() del loss_list else: # these weighting schemes use a uniform timestep sampling # and instead post-weight the loss weighting = compute_loss_weighting_for_sd3( weighting_scheme=args.training_config.weighting_scheme, sigmas=sigmas ) loss = torch.mean( (weighting.float() * (model_pred.float() - target.float()) ** 2).reshape(target.shape[0], -1), 1, ).mean() # loss = loss * (batch_size / total_sample_count) assert loss.requires_grad, f"Loss should have gradient! Got {loss.requires_grad}" assert loss.grad_fn is not None, "Loss should have grad_fn!" accelerator.backward(loss) if args.training_config.use_error_recycling: if isinstance(model_pred, list): with torch.no_grad(): for cur_model_pred, cur_target, cur_timesteps, cur_noisy_model_input in zip( model_pred, target, timesteps, noisy_model_input ): process_and_update_error_buffers( args, recycle_vars, accelerator, global_step, noise_scheduler_copy, cur_model_pred, cur_target, cur_timesteps, cur_noisy_model_input, use_clean_input, ) else: with torch.no_grad(): process_and_update_error_buffers( args, recycle_vars, accelerator, global_step, noise_scheduler_copy, model_pred, target, timesteps, noisy_model_input, use_clean_input, ) # Check if the gradient of each model parameter contains NaN for name, param in transformer.named_parameters(): if param.grad is not None and torch.isnan(param.grad).any(): logger.error(f"Gradient for {name} contains NaN!") grad_norm = None if accelerator.sync_gradients: params_to_clip = transformer.parameters() grad_norm = accelerator.clip_grad_norm_(params_to_clip, args.training_config.max_grad_norm) logs = { "loss": loss.detach().item(), "lr": lr_scheduler.get_last_lr()[0], } if grad_norm is not None: logs["grad_norm"] = grad_norm.item() if hasattr(grad_norm, "item") else grad_norm del noisy_model_input_list del sigmas_list del timesteps_list del targets_list del noisy_model_input del timesteps del prompt_embeds del prompt_attention_masks del indices_hidden_states del latents_history_short del indices_latents_history_short del latents_history_mid del indices_latents_history_mid del latents_history_long del indices_latents_history_long del model_pred del target del loss free_memory() return logs # ======================================== easy anti-drifting ======================================== def downsample_corrupt(model_input, downsample_min_corrupt_ratio, downsample_max_corrupt_ratio): corrupt_ratio = random.uniform(downsample_min_corrupt_ratio, downsample_max_corrupt_ratio) is_5d = model_input.ndim == 5 if is_5d: B, C, T, H, W = model_input.shape model_input = model_input.permute(0, 2, 1, 3, 4).reshape(B * T, C, H, W) else: B, C, H, W = model_input.shape h0, w0 = model_input.shape[-2:] h1 = max(1, int(round(h0 * corrupt_ratio))) w1 = max(1, int(round(w0 * corrupt_ratio))) model_input = F.interpolate(model_input, size=(h1, w1), mode="bilinear", align_corners=False, antialias=True) model_input = F.interpolate(model_input, size=(h0, w0), mode="bilinear", align_corners=False, antialias=True) if is_5d: model_input = model_input.reshape(B, T, C, H, W).permute(0, 2, 1, 3, 4) return model_input def get_corrupt_noise_sigma(model_input, batch_size, corrupt_ratio=1 / 3, num_frames=None, is_frame_independent=False): if is_frame_independent: noise_sigma_shape = (batch_size, 1, num_frames) else: noise_sigma_shape = (batch_size,) noise_sigma = ( torch.rand(size=noise_sigma_shape, device=model_input.device, dtype=model_input.dtype) * corrupt_ratio ) while len(noise_sigma.shape) < model_input.ndim: noise_sigma = noise_sigma.unsqueeze(-1) return noise_sigma def corrupt_model_input( model_input, # choose mode corrupt_mode="noise", # "noise" | "downsample" | "random" noise_mode_prob=0.9, # when corrupt_mode="random", select the probability of noise (select downsample for the remaining probability). # for noise is_frame_independent=False, is_chunk_independent=False, noise_corrupt_ratio=1 / 3, noise_corrupt_clean_prob=0.1, # for downsample downsample_min_corrupt_ratio=0.9, downsample_max_corrupt_ratio=1.0, ): assert not (is_frame_independent and is_chunk_independent), ( "is_frame_independent and is_chunk_independent cannot both be True" ) assert corrupt_mode in ("noise", "downsample", "random"), ( f"corrupt_mode must be 'noise', 'downsample', or 'random', got '{corrupt_mode}'" ) # ==================== choose mode ==================== if corrupt_mode == "random": mode = "noise" if random.random() < noise_mode_prob else "downsample" else: mode = corrupt_mode # ==================== downsample branch ==================== if mode == "downsample": model_input = downsample_corrupt( model_input=model_input, downsample_min_corrupt_ratio=downsample_min_corrupt_ratio, downsample_max_corrupt_ratio=downsample_max_corrupt_ratio, ) return model_input # ==================== noise branch ==================== clean_random = random.random() if clean_random < noise_corrupt_clean_prob: return model_input noise_sigma = get_corrupt_noise_sigma( model_input=model_input, batch_size=model_input.shape[0], corrupt_ratio=noise_corrupt_ratio, num_frames=model_input.shape[2], is_frame_independent=is_frame_independent, ) model_input = noise_sigma * torch.randn_like(model_input) + (1 - noise_sigma) * model_input return model_input def corrupt_history_latents( latents_history_short, latents_history_mid, latents_history_long, latent_window_size, is_keep_x0=True, # choose mode corrupt_mode="noise", # "noise" | "downsample" | "random" noise_mode_prob=0.9, # when corrupt_mode="random", select the probability of noise (select downsample for the remaining probability). # for noise is_frame_independent=False, is_chunk_independent=False, corrupt_ratio_1x=1 / 3, corrupt_ratio_2x=1 / 3, corrupt_ratio_4x=1 / 3, noise_corrupt_clean_prob=0.1, # for downsample downsample_min_corrupt_ratio=0.9, downsample_max_corrupt_ratio=1.0, ): assert not (is_frame_independent and is_chunk_independent), ( "is_frame_independent and is_chunk_independent cannot both be True" ) assert corrupt_mode in ("noise", "downsample", "random"), ( f"corrupt_mode must be 'noise', 'downsample', or 'random', got '{corrupt_mode}'" ) clean_random = random.random() if clean_random < noise_corrupt_clean_prob: return latents_history_short, latents_history_mid, latents_history_long # ==================== choose mode ==================== if corrupt_mode == "random": mode = "noise" if random.random() < noise_mode_prob else "downsample" else: mode = corrupt_mode # ==================== noise branch ==================== if mode == "noise": batch_size = latents_history_short.shape[0] if not is_frame_independent and not is_chunk_independent: noise_sigma = get_corrupt_noise_sigma( model_input=latents_history_short, batch_size=batch_size, corrupt_ratio=corrupt_ratio_1x ) len_4x = latents_history_long.shape[2] len_2x = latents_history_mid.shape[2] len_1x = latents_history_short.shape[2] hist_seq_len = len_4x + len_2x + len_1x hist_seq_len_copy = hist_seq_len ori_len_1x = len_1x if is_keep_x0: len_1x -= 1 hist_seq_len -= 1 begin_num = 1 else: begin_num = 0 max_windows = hist_seq_len // latent_window_size tail_num = hist_seq_len % latent_window_size assert hist_seq_len_copy == tail_num + max_windows * latent_window_size + begin_num tail_latents_history = None begin_latents_history = None if tail_num != 0: tail_latents_history = latents_history_long[:, :, :tail_num, :, :] latents_history_long = latents_history_long[:, :, tail_num:, :, :] if tail_latents_history.sum() != 0: if mode == "downsample": tail_latents_history = downsample_corrupt( model_input=tail_latents_history, downsample_min_corrupt_ratio=downsample_min_corrupt_ratio, downsample_max_corrupt_ratio=downsample_max_corrupt_ratio, ) else: noise_sigma = get_corrupt_noise_sigma( model_input=latents_history_short, batch_size=batch_size, corrupt_ratio=corrupt_ratio_4x, num_frames=tail_latents_history.shape[2], is_frame_independent=is_frame_independent, ) tail_latents_history = ( noise_sigma * torch.randn_like(tail_latents_history) + (1 - noise_sigma) * tail_latents_history ) if begin_num != 0: begin_latents_history = latents_history_short[:, :, :begin_num, :, :] latents_history_short = latents_history_short[:, :, begin_num:, :, :] if begin_latents_history.sum() != 0: if mode == "downsample": begin_latents_history = downsample_corrupt( model_input=begin_latents_history, downsample_min_corrupt_ratio=downsample_min_corrupt_ratio, downsample_max_corrupt_ratio=downsample_max_corrupt_ratio, ) else: noise_sigma = get_corrupt_noise_sigma( model_input=latents_history_short, batch_size=batch_size, corrupt_ratio=corrupt_ratio_1x, num_frames=begin_latents_history.shape[2], is_frame_independent=is_frame_independent, ) begin_latents_history = ( noise_sigma * torch.randn_like(begin_latents_history) + (1 - noise_sigma) * begin_latents_history ) mid_latents_history = torch.cat([latents_history_long, latents_history_mid, latents_history_short], dim=2) window_num = mid_latents_history.shape[2] // latent_window_size assert mid_latents_history.shape[2] % latent_window_size == 0, ( f"mid length {mid_latents_history.shape[2]} not divisible by window size {latent_window_size}" ) seq_begin = 0 for idx in range(window_num): seq_end = seq_begin + latent_window_size if mid_latents_history[:, :, seq_begin:seq_end, :, :].sum() != 0: if idx == window_num - 1: len_2x_end = seq_begin + len_2x if mode == "downsample": mid_latents_history[:, :, seq_begin:len_2x_end, :, :] = downsample_corrupt( model_input=mid_latents_history[:, :, seq_begin:len_2x_end, :, :], downsample_min_corrupt_ratio=downsample_min_corrupt_ratio, downsample_max_corrupt_ratio=downsample_max_corrupt_ratio, ) else: noise_sigma_4x = get_corrupt_noise_sigma( model_input=latents_history_short, batch_size=batch_size, corrupt_ratio=corrupt_ratio_4x, num_frames=len_2x, is_frame_independent=is_frame_independent, ) mid_latents_history[:, :, seq_begin:len_2x_end, :, :] = ( noise_sigma_4x * torch.randn_like(mid_latents_history[:, :, seq_begin:len_2x_end, :, :]) + (1 - noise_sigma_4x) * mid_latents_history[:, :, seq_begin:len_2x_end, :, :] ) remaining_frames = seq_end - len_2x_end if mode == "downsample": mid_latents_history[:, :, len_2x_end:seq_end, :, :] = downsample_corrupt( model_input=mid_latents_history[:, :, len_2x_end:seq_end, :, :], downsample_min_corrupt_ratio=downsample_min_corrupt_ratio, downsample_max_corrupt_ratio=downsample_max_corrupt_ratio, ) else: noise_sigma_2x = get_corrupt_noise_sigma( model_input=latents_history_short, batch_size=batch_size, corrupt_ratio=corrupt_ratio_2x, num_frames=remaining_frames, is_frame_independent=is_frame_independent, ) mid_latents_history[:, :, len_2x_end:seq_end, :, :] = ( noise_sigma_2x * torch.randn_like(mid_latents_history[:, :, len_2x_end:seq_end, :, :]) + (1 - noise_sigma_2x) * mid_latents_history[:, :, len_2x_end:seq_end, :, :] ) else: if mode == "downsample": mid_latents_history[:, :, seq_begin:seq_end, :, :] = downsample_corrupt( model_input=mid_latents_history[:, :, seq_begin:seq_end, :, :], downsample_min_corrupt_ratio=downsample_min_corrupt_ratio, downsample_max_corrupt_ratio=downsample_max_corrupt_ratio, ) else: noise_sigma = get_corrupt_noise_sigma( model_input=latents_history_short, batch_size=batch_size, corrupt_ratio=corrupt_ratio_4x, num_frames=latent_window_size, is_frame_independent=is_frame_independent, ) mid_latents_history[:, :, seq_begin:seq_end, :, :] = ( noise_sigma * torch.randn_like(mid_latents_history[:, :, seq_begin:seq_end, :, :]) + (1 - noise_sigma) * mid_latents_history[:, :, seq_begin:seq_end, :, :] ) seq_begin = seq_end recovers = [] if tail_latents_history is not None: recovers.append(tail_latents_history) recovers.append(mid_latents_history[:, :, :-len_1x, :, :]) if begin_latents_history is not None: recovers.append(begin_latents_history) recovers.append(mid_latents_history[:, :, -len_1x:, :, :]) mid_latents_history = torch.cat(recovers, dim=2) # Split and update back to original tensors latents_4x_recovered, latents_2x_recovered, latents_history_short_recovered = mid_latents_history.split( [len_4x, len_2x, ori_len_1x], dim=2 ) return ( latents_history_short_recovered, latents_2x_recovered, latents_4x_recovered, ) def add_saturation_to_history_latents( latents_history_short, latents_history_mid, latents_history_long, latent_window_size, is_keep_x0=False, saturation_ratio_min=0.7, saturation_ratio_max=2.0, saturation_clean_prob=0.2, ): # clean_random = random.random() # if clean_random < saturation_clean_prob: # return latents_history_short, latents_history_mid, latents_history_long def get_saturation(x1, saturation_ratio_min, saturation_ratio_max): if random.random() < 0.5: sat_factor = random.uniform(saturation_ratio_min, 1.0 - 1e-3) else: sat_factor = random.uniform(1.0 + 1e-3, saturation_ratio_max) latent_mean = torch.mean(x1, dim=1, keepdim=True) x1_saturated = (x1 - latent_mean) * sat_factor + latent_mean return x1_saturated len_4x = latents_history_long.shape[2] len_2x = latents_history_mid.shape[2] len_1x = latents_history_short.shape[2] hist_seq_len = len_4x + len_2x + len_1x hist_seq_len_copy = hist_seq_len ori_len_1x = len_1x if is_keep_x0: len_1x -= 1 hist_seq_len -= 1 begin_num = 1 else: begin_num = 0 max_windows = hist_seq_len // latent_window_size tail_num = hist_seq_len % latent_window_size assert hist_seq_len_copy == tail_num + max_windows * latent_window_size + begin_num tail_latents_history = None begin_latents_history = None if tail_num != 0: tail_latents_history = latents_history_long[:, :, :tail_num, :, :] latents_history_long = latents_history_long[:, :, tail_num:, :, :] if tail_latents_history.sum() != 0: if random.random() < saturation_clean_prob: tail_latents_history = tail_latents_history else: tail_latents_history = get_saturation( tail_latents_history, saturation_ratio_min=saturation_ratio_min, saturation_ratio_max=saturation_ratio_max, ) if begin_num != 0: begin_latents_history = latents_history_short[:, :, :begin_num, :, :] latents_history_short = latents_history_short[:, :, begin_num:, :, :] # if begin_latents_history.sum() != 0: # begin_latents_history = get_saturation( # begin_latents_history, # saturation_ratio_min=saturation_ratio_min, # saturation_ratio_max=saturation_ratio_max, # ) mid_latents_history = torch.cat([latents_history_long, latents_history_mid, latents_history_short], dim=2) window_num = mid_latents_history.shape[2] // latent_window_size assert mid_latents_history.shape[2] % latent_window_size == 0, ( f"mid length {mid_latents_history.shape[2]} not divisible by window size {latent_window_size}" ) seq_begin = 0 for idx in range(window_num): seq_end = seq_begin + latent_window_size if mid_latents_history[:, :, seq_begin:seq_end, :, :].sum() != 0: if idx == window_num - 1: len_2x_end = seq_begin + len_2x if random.random() < saturation_clean_prob: mid_latents_history[:, :, seq_begin:len_2x_end, :, :] = mid_latents_history[ :, :, seq_begin:len_2x_end, :, : ] else: mid_latents_history[:, :, seq_begin:len_2x_end, :, :] = get_saturation( mid_latents_history[:, :, seq_begin:len_2x_end, :, :], saturation_ratio_min=saturation_ratio_min, saturation_ratio_max=saturation_ratio_max, ) if random.random() < saturation_clean_prob: mid_latents_history[:, :, len_2x_end:seq_end, :, :] = mid_latents_history[ :, :, len_2x_end:seq_end, :, : ] else: mid_latents_history[:, :, len_2x_end:seq_end, :, :] = get_saturation( mid_latents_history[:, :, len_2x_end:seq_end, :, :], saturation_ratio_min=saturation_ratio_min, saturation_ratio_max=saturation_ratio_max, ) else: if random.random() < saturation_clean_prob: mid_latents_history[:, :, seq_begin:seq_end, :, :] = mid_latents_history[ :, :, seq_begin:seq_end, :, : ] else: mid_latents_history[:, :, seq_begin:seq_end, :, :] = get_saturation( mid_latents_history[:, :, seq_begin:seq_end, :, :], saturation_ratio_min=saturation_ratio_min, saturation_ratio_max=saturation_ratio_max, ) seq_begin = seq_end recovers = [] if tail_latents_history is not None: recovers.append(tail_latents_history) recovers.append(mid_latents_history[:, :, :-len_1x, :, :]) if begin_latents_history is not None: recovers.append(begin_latents_history) recovers.append(mid_latents_history[:, :, -len_1x:, :, :]) mid_latents_history = torch.cat(recovers, dim=2) # Split and update back to original tensors latents_4x_recovered, latents_2x_recovered, latents_history_short_recovered = mid_latents_history.split( [len_4x, len_2x, ori_len_1x], dim=2 ) return ( latents_history_short_recovered, latents_2x_recovered, latents_4x_recovered, ) # ======================================== prepare stage1 training ======================================== def prepare_stage1_clean_input_from_latents( history_latents, # VAE latents, (B, C_latent, F_latent, H_latent, W_latent) target_latents, x0_latents=None, latent_window_size: int = 9, history_sizes: list = [16, 2, 1], is_random_drop: bool = False, random_drop_i2v_ratio: float = 0, random_drop_v2v_ratio: float = 0, random_drop_t2v_ratio: float = 0, is_keep_x0: bool = True, dtype=torch.bfloat16, device="cpu", ): if is_keep_x0: latents_prefix = x0_latents.to(device, dtype=dtype) else: assert x0_latents is None history_sizes = sorted(history_sizes, reverse=True) # From big to small history_window_size = sum(history_sizes) total_window_size = history_window_size + latent_window_size assert total_window_size == history_latents.shape[2] + target_latents.shape[2], ( f"total_window_size mismatch: expected {total_window_size}" f"(history={history_latents.shape[2]} + target={target_latents.shape[2]}), " f"but got {history_latents.shape[2] + target_latents.shape[2]}" ) indices = ( torch.arange(0, sum([1, *history_sizes, latent_window_size])).unsqueeze(0).expand(target_latents.shape[0], -1) ) ( indices_prefix, indices_latents_history_long, indices_latents_history_mid, indices_latents_history_1x, indices_hidden_states, ) = indices.split([1, *history_sizes, latent_window_size], dim=1) indices_latents_history_short = torch.cat([indices_prefix, indices_latents_history_1x], dim=1) latents_history_long, latents_history_mid, latents_history_1x = history_latents.split(history_sizes, dim=2) if is_random_drop: if random_drop_t2v_ratio != 0 and torch.rand(1).item() <= random_drop_t2v_ratio: if is_keep_x0: latents_prefix = torch.zeros_like( latents_prefix, device=latents_history_1x.device, dtype=latents_history_1x.dtype ) latents_history_1x = torch.zeros_like( latents_history_1x, device=latents_history_1x.device, dtype=latents_history_1x.dtype, ) latents_history_mid = torch.zeros_like( latents_history_mid, device=latents_history_1x.device, dtype=latents_history_1x.dtype, ) latents_history_long = torch.zeros_like( latents_history_long, device=latents_history_1x.device, dtype=latents_history_1x.dtype, ) else: len_4x = latents_history_long.shape[2] len_2x = latents_history_mid.shape[2] len_1x = latents_history_1x.shape[2] hist_seq_len = len_4x + len_2x + len_1x total_drop = 0 is_drop_triggered = False if random_drop_i2v_ratio != 0 and torch.rand(1).item() <= random_drop_i2v_ratio: total_drop = max(0, hist_seq_len - 1) is_drop_triggered = True elif random_drop_v2v_ratio != 0 and torch.rand(1).item() <= random_drop_v2v_ratio: max_windows = hist_seq_len // latent_window_size tail_num = hist_seq_len % latent_window_size total_drop = tail_num if max_windows > 0: drop_windows = random.randint(0, max_windows) total_drop += drop_windows * latent_window_size is_drop_triggered = True if is_drop_triggered and total_drop > 0: remaining_drop = total_drop if remaining_drop > 0 and len_4x > 0: drop_4x = min(remaining_drop, len_4x) latents_history_long[:, :, :drop_4x, :, :] = 0 remaining_drop -= drop_4x if remaining_drop > 0 and len_2x > 0: drop_2x = min(remaining_drop, len_2x) latents_history_mid[:, :, :drop_2x, :, :] = 0 remaining_drop -= drop_2x if remaining_drop > 0 and len_1x > 0: drop_1x = min(remaining_drop, len_1x) latents_history_1x[:, :, :drop_1x, :, :] = 0 if is_keep_x0: latents_history_short = torch.cat([latents_prefix, latents_history_1x], dim=2) else: latents_history_short = latents_history_1x return ( target_latents, indices_hidden_states, indices_latents_history_short, indices_latents_history_mid, indices_latents_history_long, latents_history_short, latents_history_mid, latents_history_long, ) def prepare_stage1_noise_input( args, model_input, noise_scheduler, recycle_vars=None, latents_history_short=None, latents_history_mid=None, latents_history_long=None, latent_window_size=9, is_keep_x0=True, return_list=True, ): # Sample noise that we'll add to the latents noise = torch.randn_like(model_input) bsz = model_input.shape[0] use_clean_input = False noise_w_error = noise model_input_w_error = model_input # 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.training_config.weighting_scheme, batch_size=bsz, logit_mean=args.training_config.logit_mean, logit_std=args.training_config.logit_std, mode_scale=args.training_config.mode_scale, ) indices = (u * noise_scheduler.config.num_train_timesteps).long() noise_scheduler.temp_sigmas = noise_scheduler.sigmas noise_scheduler.temp_timesteps = noise_scheduler.timesteps if args.training_config.use_dynamic_shifting: noise_scheduler.temp_sigmas = apply_schedule_shift( noise_scheduler.sigmas, noise, base_seq_len=args.training_config.base_seq_len, max_seq_len=args.training_config.max_seq_len, base_shift=args.training_config.base_shift, max_shift=args.training_config.max_shift, ) # torch.Size([2, 1, 1, 1, 1]) noise_scheduler.temp_timesteps = noise_scheduler.temp_sigmas * 1000.0 # rescale to [0, 1000.0) while noise_scheduler.temp_timesteps.ndim > 1: noise_scheduler.temp_timesteps = noise_scheduler.temp_timesteps.squeeze(-1) timesteps = noise_scheduler.temp_timesteps[indices].to( device=model_input.device, non_blocking=True ) # torch.Size([2]), torch.float32 # Add noise according to flow matching. # zt = (1 - texp) * x + texp * z1 sigmas = noise_scheduler.temp_sigmas[indices].flatten() while len(sigmas.shape) < model_input.ndim: sigmas = sigmas.unsqueeze(-1) sigmas = sigmas.to(model_input.device, dtype=model_input.dtype) if args.training_config.use_error_recycling: ( model_input_w_error, noise_w_error, latents_history_long, latents_history_mid, latents_history_short, use_clean_input, ) = apply_error_injection( args, recycle_vars, model_input, noise, timesteps, latents_history_long, latents_history_mid, latents_history_short, model_input_w_error, noise_w_error, is_keep_x0, latent_window_size, ) if args.training_config.corrupt_history and latents_history_short is not None: latents_history_short, latents_history_mid, latents_history_long = corrupt_history_latents( latents_history_short, latents_history_mid, latents_history_long, latent_window_size, is_keep_x0=True, # choose mode corrupt_mode=args.training_config.corrupt_mode_history, noise_mode_prob=args.training_config.corrupt_mode_prob_history, # for noise is_frame_independent=args.training_config.is_frame_independent_corrupt_history, is_chunk_independent=args.training_config.is_chunk_independent_corrupt_history, corrupt_ratio_1x=args.training_config.noise_corrupt_ratio_history_short, corrupt_ratio_2x=args.training_config.noise_corrupt_ratio_history_mid, corrupt_ratio_4x=args.training_config.noise_corrupt_ratio_history_long, noise_corrupt_clean_prob=args.training_config.noise_corrupt_clean_prob_history, # for downsample downsample_min_corrupt_ratio=args.training_config.downsample_min_corrupt_ratio_history, downsample_max_corrupt_ratio=args.training_config.downsample_max_corrupt_ratio_history, ) if args.training_config.corrupt_model_input: model_input_w_error = corrupt_model_input( model_input_w_error, # choose mode corrupt_mode=args.training_config.corrupt_mode_model_input, noise_mode_prob=args.training_config.corrupt_mode_prob_model_input, # for noise is_frame_independent=args.training_config.is_frame_independent_corrupt_model_input, is_chunk_independent=args.training_config.is_chunk_independent_corrupt_model_input, noise_corrupt_ratio=args.training_config.noise_corrupt_ratio_model_input, noise_corrupt_clean_prob=args.training_config.noise_corrupt_clean_prob_model_input, # for downsample downsample_min_corrupt_ratio=args.training_config.downsample_min_corrupt_ratio_model_input, downsample_max_corrupt_ratio=args.training_config.downsample_max_corrupt_ratio_model_input, ) # Get flow-matching target noisy_model_input = (1.0 - sigmas) * model_input_w_error + sigmas * noise_w_error target = noise_w_error - model_input noisy_model_input_list = [noisy_model_input] if return_list else noisy_model_input sigmas_list = [sigmas] if return_list else sigmas timesteps_list = [timesteps] if return_list else timesteps targets_list = [target] if return_list else target return ( noisy_model_input_list, sigmas_list, timesteps_list, targets_list, latents_history_short, latents_history_mid, latents_history_long, use_clean_input, ) # ======================================== prepare stage2 training ======================================== def prepare_stage2_clean_input( args, scheduler, latents, # [b c t h w] pyramid_stage_num=3, stage2_sample_ratios=[1, 1, 1], ): assert pyramid_stage_num == len(stage2_sample_ratios) # Get clen pyramid latent list pyramid_latent_list = [] pyramid_latent_list.append(latents) num_frames, height, width = latents.shape[-3], latents.shape[-2], latents.shape[-1] for _ in range(pyramid_stage_num - 1): height //= 2 width //= 2 latents = rearrange(latents, "b c t h w -> (b t) c h w") latents = torch.nn.functional.interpolate(latents, size=(height, width), mode="bilinear") latents = rearrange(latents, "(b t) c h w -> b c t h w", t=num_frames) pyramid_latent_list.append(latents) pyramid_latent_list = list(reversed(pyramid_latent_list)) # Get pyramid noise list noise = torch.randn_like(pyramid_latent_list[-1]) device = noise.device dtype = pyramid_latent_list[-1].dtype latent_frame_num = noise.shape[2] input_video_num = noise.shape[0] height, width = noise.shape[-2], noise.shape[-1] noise_list = [noise] cur_noise = noise for i_s in range(pyramid_stage_num - 1): height //= 2 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=latent_frame_num) noise_list.append(cur_noise) noise_list = list(reversed(noise_list)) # make sure from low res to high res # Get pyramid target list # To calculate the batchsize bsz = input_video_num # from low resolution to high resolution noisy_latents_list = [] sigmas_list = [] targets_list = [] timesteps_list = [] training_steps = scheduler.config.num_train_timesteps for i_s, cur_sample_ratio in zip(range(pyramid_stage_num), stage2_sample_ratios): clean_latent = pyramid_latent_list[i_s] # [bs, c, t, h, w] last_clean_latent = None if i_s == 0 else pyramid_latent_list[i_s - 1] start_sigma = scheduler.start_sigmas[i_s] end_sigma = scheduler.end_sigmas[i_s] if i_s == 0: start_point = noise_list[i_s] 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=( last_clean_latent.shape[-2] * 2, last_clean_latent.shape[-1] * 2, ), mode="nearest", ) last_clean_latent = rearrange(last_clean_latent, "(b t) c h w -> b c t h w", t=latent_frame_num) start_point = start_sigma * noise_list[i_s] + (1 - start_sigma) * last_clean_latent if i_s == pyramid_stage_num - 1: end_point = clean_latent else: end_point = end_sigma * noise_list[i_s] + (1 - end_sigma) * clean_latent for _ in range(cur_sample_ratio): # Sample a random timestep for each image # for weighting schemes where we sample timesteps non-uniformly u = compute_density_for_timestep_sampling( weighting_scheme=get_config_value(args, "weighting_scheme"), batch_size=bsz, logit_mean=get_config_value(args, "logit_mean"), logit_std=get_config_value(args, "logit_std"), mode_scale=get_config_value(args, "mode_scale"), ) indices = (u * training_steps).long() # Totally 1000 training steps per stage indices = indices.clamp(0, training_steps - 1) timesteps = scheduler.timesteps_per_stage[i_s][indices].to(device=device) # Add noise according to flow matching. # zt = (1 - texp) * x + texp * z1 sigmas = scheduler.sigmas_per_stage[i_s][indices].to(device=device) while len(sigmas.shape) < start_point.ndim: sigmas = sigmas.unsqueeze(-1) if get_config_value(args, "use_dynamic_shifting"): temp_sigmas = apply_schedule_shift( sigmas, start_point, base_seq_len=get_config_value(args, "base_seq_len"), max_seq_len=get_config_value(args, "max_seq_len"), base_shift=get_config_value(args, "base_shift"), max_shift=get_config_value(args, "max_shift"), ) # torch.Size([2, 1, 1, 1, 1]) temp_timesteps = scheduler.timesteps_per_stage[i_s].min() + temp_sigmas * ( scheduler.timesteps_per_stage[i_s].max() - scheduler.timesteps_per_stage[i_s].min() ) while temp_timesteps.ndim > 1: temp_timesteps = temp_timesteps.squeeze(-1) sigmas = temp_sigmas timesteps = temp_timesteps if args.training_config.corrupt_model_input: end_point = corrupt_model_input( end_point, # choose mode corrupt_mode=args.training_config.corrupt_mode_model_input, noise_mode_prob=args.training_config.corrupt_mode_prob_model_input, # for noise is_frame_independent=args.training_config.is_frame_independent_corrupt_model_input, is_chunk_independent=args.training_config.is_chunk_independent_corrupt_model_input, noise_corrupt_ratio=args.training_config.noise_corrupt_ratio_model_input, noise_corrupt_clean_prob=args.training_config.noise_corrupt_clean_prob_model_input, # for downsample downsample_min_corrupt_ratio=args.training_config.downsample_min_corrupt_ratio_model_input, downsample_max_corrupt_ratio=args.training_config.downsample_max_corrupt_ratio_model_input, ) noisy_latents = sigmas * start_point + (1 - sigmas) * end_point # [stage1_latent, stage2_latent, ..., stagen_latent] noisy_latents_list.append(noisy_latents.to(dtype)) sigmas_list.append(sigmas.to(dtype)) timesteps_list.append(timesteps) targets_list.append(start_point - end_point) # The standard rectified flow matching objective return noisy_latents_list, sigmas_list, timesteps_list, targets_list def prepare_stage2_noise_input( args, scheduler, latents, # [b c t h w] pyramid_stage_num=3, stage2_sample_ratios=[1, 1, 1], latents_history_short=None, latents_history_mid=None, latents_history_long=None, latent_window_size=9, return_list=True, is_navit_pyramid=False, is_efficient_sample=False, ): noisy_model_input_list, sigmas_list, timesteps_list, targets_list = prepare_stage2_clean_input( args=args, scheduler=scheduler, latents=latents, pyramid_stage_num=pyramid_stage_num, stage2_sample_ratios=stage2_sample_ratios, ) if args.training_config.corrupt_history and latents_history_short is not None: latents_history_short, latents_history_mid, latents_history_long = corrupt_history_latents( latents_history_short, latents_history_mid, latents_history_long, latent_window_size, is_keep_x0=True, # choose mode corrupt_mode=args.training_config.corrupt_mode_history, noise_mode_prob=args.training_config.corrupt_mode_prob_history, # for noise is_frame_independent=args.training_config.is_frame_independent_corrupt_history, is_chunk_independent=args.training_config.is_chunk_independent_corrupt_history, corrupt_ratio_1x=args.training_config.noise_corrupt_ratio_history_short, corrupt_ratio_2x=args.training_config.noise_corrupt_ratio_history_mid, corrupt_ratio_4x=args.training_config.noise_corrupt_ratio_history_long, noise_corrupt_clean_prob=args.training_config.noise_corrupt_clean_prob_history, # for downsample downsample_min_corrupt_ratio=args.training_config.downsample_min_corrupt_ratio_history, downsample_max_corrupt_ratio=args.training_config.downsample_max_corrupt_ratio_history, ) if is_navit_pyramid: return ( [noisy_model_input_list], [sigmas_list], [timesteps_list], [targets_list], latents_history_short, latents_history_mid, latents_history_long, ) if is_efficient_sample: temp_list = list(range(len(noisy_model_input_list))) random_index = random.choice(temp_list) noisy_model_input = noisy_model_input_list[random_index] sigmas = sigmas_list[random_index] timesteps = timesteps_list[random_index] targets = targets_list[random_index] base_results = (noisy_model_input, sigmas, timesteps, targets) additional_results = (latents_history_short, latents_history_mid, latents_history_long) if return_list: return tuple([item] for item in base_results) + additional_results else: return base_results + additional_results return ( noisy_model_input_list, sigmas_list, timesteps_list, targets_list, latents_history_short, latents_history_mid, latents_history_long, )