Helios/_DEV2/helios/utils/utils_recycle_single.py

import random

import torch

from .utils_base import apply_schedule_shift


def 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,
):
    # Check if buffer has data for the current timestep grid
    current_grid_idx = get_timestep_grid(args, recycle_vars, timesteps, noise)
    has_latent_buffer_data = len(recycle_vars.latent_error_buffer[current_grid_idx]) > 0
    has_y_buffer_data = any(len(buffer) > 0 for buffer in recycle_vars.y_error_buffer.values())

    add_error_latent = False
    add_error_noise = False
    add_error_y = False
    use_clean_input = False

    latent_random = random.random()
    noise_random = random.random()
    y_random = random.random()
    clean_random = random.random()

    if latent_random < args.training_config.latent_prob:
        add_error_latent = True
    if noise_random < args.training_config.noise_prob:
        add_error_noise = True
    if y_random < args.training_config.y_prob:
        add_error_y = True
    if clean_random < args.training_config.clean_prob:
        add_error_noise = False
        add_error_y = False
        add_error_latent = False
        use_clean_input = True

    if add_error_noise and has_latent_buffer_data:
        noise_error_sampled = sample_noise_error_from_noise_buffer(
            args, recycle_vars, model_input, timesteps, model_input.dtype, model_input.device
        )
        noise_w_error = noise + noise_error_sampled.to(model_input.dtype)

    if add_error_y and has_y_buffer_data:
        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 = (
                latents_history_long[:, :, :tail_num, :, :],
                latents_history_long[:, :, tail_num:, :, :],
            )
            # for tail
            if random.random() < args.training_config.y_prob:
                y_error_sampled = sample_y_error_from_latent_buffer(
                    args, recycle_vars, model_input, model_input.dtype, model_input.device
                )
                random_error_num = torch.randint(1, tail_num + 1, (1,)).item()
                tail_latents_history[:, :, -random_error_num:, ...] = (
                    tail_latents_history[:, :, -random_error_num:, ...]
                    + y_error_sampled[:, :, -random_error_num:, ...]
                )
        if begin_num != 0:
            begin_latents_history, latents_history_short = (
                latents_history_short[:, :, :begin_num, :, :],
                latents_history_short[:, :, begin_num:, :, :],
            )
            # for begin
            if random.random() < args.training_config.y_prob:
                y_error_sampled = sample_y_error_from_latent_buffer(
                    args, recycle_vars, model_input, model_input.dtype, model_input.device
                )
                begin_latents_history = begin_latents_history + y_error_sampled[:, :, :1, ...]

        # for mid
        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 _ in range(window_num):
            seq_end = seq_begin + latent_window_size
            if random.random() < args.training_config.y_prob:
                y_error_sampled = sample_y_error_from_latent_buffer(
                    args, recycle_vars, model_input, model_input.dtype, model_input.device
                )
                max_start_idx = max(0, y_error_sampled.shape[2] - args.training_config.y_error_num)
                random_frame_idx = torch.randint(0, max_start_idx + 1, (1,)).item()
                error_to_add = y_error_sampled[
                    :, :, random_frame_idx : random_frame_idx + args.training_config.y_error_num, ...
                ]
                # Modify
                mid_latents_history[:, :, seq_begin:seq_end, :, :][
                    :, :, random_frame_idx : random_frame_idx + args.training_config.y_error_num, :, :
                ] = (
                    mid_latents_history[:, :, seq_begin:seq_end, :, :][
                        :, :, random_frame_idx : random_frame_idx + args.training_config.y_error_num, :, :
                    ]
                    + error_to_add
                )
            seq_begin = seq_end

        # recover
        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)
        latents_history_long, latents_history_mid, latents_history_short = mid_latents_history.split(
            [len_4x, len_2x, ori_len_1x], dim=2
        )

    if add_error_latent and has_latent_buffer_data:
        latent_error_sampled = sample_latent_error_from_latent_buffer(
            args, recycle_vars, model_input, timesteps, model_input.dtype, model_input.device
        )
        model_input_w_error = model_input + latent_error_sampled.to(model_input.dtype)

    return (
        model_input_w_error,
        noise_w_error,
        latents_history_long,
        latents_history_mid,
        latents_history_short,
        use_clean_input,
    )


def step_recycle(scheduler, model_output, timestep, sample, to_final=False, self_corr=False):
    if isinstance(timestep, torch.Tensor):
        timestep = timestep.cpu()
    timestep_id = torch.argmin((scheduler.temp_timesteps - timestep).abs())
    sigma = scheduler.temp_sigmas[timestep_id]
    if to_final or timestep_id + 1 >= len(scheduler.temp_timesteps):
        sigma_ = 1 if self_corr else 0
    else:
        sigma_ = scheduler.temp_sigmas[timestep_id + 1]
    prev_sample = sample + model_output * (sigma_ - sigma)
    return prev_sample


def get_timesteps(
    num_inference_steps=50,
    denoising_strength=1,
    shift=1.0,
    num_train_timesteps=1000,
    sigma_max=1.0,
    sigma_min=0.0,
    inverse_timesteps=False,
    extra_one_step=True,
    reverse_sigmas=False,
):
    sigma_start = sigma_min + (sigma_max - sigma_min) * denoising_strength
    if extra_one_step:
        sigmas = torch.linspace(sigma_start, sigma_min, num_inference_steps + 1)[:-1]
    else:
        sigmas = torch.linspace(sigma_start, sigma_min, num_inference_steps)
    if inverse_timesteps:
        sigmas = torch.flip(sigmas, dims=[0])
    sigmas = shift * sigmas / (1 + (shift - 1) * sigmas)
    if reverse_sigmas:
        sigmas = 1 - sigmas
    timesteps = sigmas * num_train_timesteps
    return timesteps, sigmas


def get_timestep_grid(args, recycle_vars, timesteps, noise):
    """Get the grid index for a given timesteps."""
    # Handle different timesteps formats (scalar tensor, tensor with batch dim, etc.)
    if isinstance(timesteps, torch.Tensor):
        if timesteps.numel() == 1:
            # Single timesteps value
            timestep_val = timesteps.item()
        else:
            # Tensor with batch dimension, take the first element
            timestep_val = timesteps.flatten()[0].item()
    else:
        # Already a scalar value
        timestep_val = timesteps

    if args.training_config.use_dynamic_shifting:
        temp_sigmas = apply_schedule_shift(
            recycle_vars.recycle_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])

        temp_inferece_timesteps = temp_sigmas * 1000.0  # rescale to [0, 1000.0)
        while temp_inferece_timesteps.ndim > 1:
            temp_inferece_timesteps = temp_inferece_timesteps.squeeze(-1)
    else:
        temp_inferece_timesteps = recycle_vars.recycle_inferece_timesteps

    # Ensure timesteps is within valid range and calculate grid index
    timestep_val = max(0, min(timestep_val, 999))  # Clamp to [0, 999]
    grid_idx = torch.argmin((temp_inferece_timesteps - timestep_val).abs()).item()

    # Ensure grid index is within valid range
    max_grid_idx = len(recycle_vars.latent_error_buffer) - 1
    grid_idx = min(grid_idx, max_grid_idx)

    return grid_idx


def sample_noise_error_from_noise_buffer(args, recycle_vars, latents, timestep, dtype=torch.bfloat16, device="cpu"):
    """Randomly sample an error from the buffer based on timestep grid."""
    grid_idx = get_timestep_grid(args, recycle_vars, timestep, latents)

    if not recycle_vars.latent_error_buffer[grid_idx]:
        return torch.zeros_like(latents)

    # Randomly select one sample from the corresponding grid
    selected_sample = random.choice(recycle_vars.latent_error_buffer[grid_idx])
    error_sample = selected_sample

    min_mod = 1.0 - args.training_config.error_modulate_factor
    max_mod = 1.0 + args.training_config.error_modulate_factor
    intensity_mod = random.uniform(min_mod, max_mod)
    error_sample = error_sample * intensity_mod

    error_sample = error_sample.to(device, dtype=dtype)

    return error_sample


def sample_latent_error_from_latent_buffer(args, recycle_vars, latents, timestep, dtype=torch.bfloat16, device="cpu"):
    """Randomly sample an error from the buffer based on timestep grid."""
    grid_idx = get_timestep_grid(args, recycle_vars, timestep, latents)

    if not recycle_vars.y_error_buffer[grid_idx]:
        return torch.zeros_like(latents)

    # Randomly select one sample from the corresponding grid
    selected_sample = random.choice(recycle_vars.y_error_buffer[grid_idx])
    error_sample = selected_sample

    min_mod = 1.0 - args.training_config.error_modulate_factor
    max_mod = 1.0 + args.training_config.error_modulate_factor
    intensity_mod = random.uniform(min_mod, max_mod)
    error_sample = error_sample * intensity_mod

    error_sample = error_sample.to(device, dtype=dtype)

    return error_sample


def sample_y_error_from_latent_buffer(args, recycle_vars, latents, dtype=torch.bfloat16, device="cpu"):
    """Specially sample y_error from buffer - can be configured to sample from all grids or custom range."""
    # Sample from all grids that have data
    all_samples = []
    for grid_idx, buffer in recycle_vars.y_error_buffer.items():
        if buffer:  # Only add non-empty buffers
            all_samples.extend(buffer)

    if not all_samples:
        return torch.zeros_like(latents)

    # Randomly select one sample from all available samples
    selected_sample = random.choice(all_samples)
    error_sample = selected_sample

    min_mod = 1.0 - args.training_config.error_modulate_factor
    max_mod = 1.0 + args.training_config.error_modulate_factor
    intensity_mod = random.uniform(min_mod, max_mod)
    error_sample = error_sample * intensity_mod

    error_sample = error_sample.to(device, dtype=dtype)

    return error_sample


def compute_l2_distance_batch(new_tensor, stored_tensors):
    """Compute L2 distances between new tensor and all stored tensors efficiently."""
    if not stored_tensors:
        return torch.tensor([])

    # Stack all stored tensors for batch computation
    stored_stack = torch.stack(stored_tensors)  # [num_stored, ...]
    new_flat = new_tensor.flatten()
    stored_flat = stored_stack.flatten(start_dim=1)  # [num_stored, flattened_size]

    # Compute L2 distances in batch
    distances = torch.norm(stored_flat - new_flat.unsqueeze(0), p=2, dim=1)
    return distances


def compute_l2_distance(tensor1, tensor2):
    """Compute L2 distance between two tensors"""
    # Flatten tensors
    flat1 = tensor1.flatten()
    flat2 = tensor2.flatten()

    # Compute L2 distance (Euclidean distance)
    l2_distance = torch.norm(flat1 - flat2, p=2)
    return l2_distance.item()


def add_error_to_latent_buffer(args, recycle_vars, error_sample, timestep, noisy_model_input):
    """Add error sample to buffer using specified replacement strategy based on timestep grid."""
    grid_idx = get_timestep_grid(args, recycle_vars, timestep, noisy_model_input)
    error_cpu = error_sample.detach().cpu()

    if len(recycle_vars.latent_error_buffer[grid_idx]) < args.training_config.error_buffer_size:
        # Buffer not full, simply add
        recycle_vars.latent_error_buffer[grid_idx].append(error_cpu)
    else:
        # Buffer full, use specified replacement strategy
        if args.training_config.buffer_replacement_strategy == "random":
            # Random replacement - O(1), fastest
            replace_idx = random.randint(0, len(recycle_vars.latent_error_buffer[grid_idx]) - 1)
            recycle_vars.latent_error_buffer[grid_idx][replace_idx] = error_cpu

        elif args.training_config.buffer_replacement_strategy == "fifo":
            # First-in-first-out - O(1), simple queue behavior
            recycle_vars.latent_error_buffer[grid_idx].pop(0)
            recycle_vars.latent_error_buffer[grid_idx].append(error_cpu)

        elif args.training_config.buffer_replacement_strategy == "l2_batch":
            # Batch L2 computation - O(n) but vectorized, much faster than original
            distances = compute_l2_distance_batch(error_cpu, recycle_vars.latent_error_buffer[grid_idx])
            most_similar_idx = torch.argmin(distances).item()
            recycle_vars.latent_error_buffer[grid_idx][most_similar_idx] = error_cpu

        elif args.training_config.buffer_replacement_strategy == "l2_similarity":
            # Original L2 similarity method - O(n), slowest but most precise
            min_distance = float("inf")
            most_similar_idx = -1

            for i, stored_error in enumerate(recycle_vars.latent_error_buffer[grid_idx]):
                distance = compute_l2_distance(error_cpu, stored_error)
                if distance < min_distance:
                    min_distance = distance
                    most_similar_idx = i

            if most_similar_idx != -1:
                recycle_vars.latent_error_buffer[grid_idx][most_similar_idx] = error_cpu


def add_error_to_y_buffer(args, recycle_vars, error_sample, timestep, noisy_model_input):
    """Add error sample to buffer using specified replacement strategy based on timestep grid."""
    grid_idx = get_timestep_grid(args, recycle_vars, timestep, noisy_model_input)
    error_cpu = error_sample.detach().cpu()

    if len(recycle_vars.y_error_buffer[grid_idx]) < args.training_config.error_buffer_size:
        # Buffer not full, simply add
        recycle_vars.y_error_buffer[grid_idx].append(error_cpu)
    else:
        # Buffer full, use specified replacement strategy
        if args.training_config.buffer_replacement_strategy == "random":
            # Random replacement - O(1), fastest
            replace_idx = random.randint(0, len(recycle_vars.y_error_buffer[grid_idx]) - 1)
            recycle_vars.y_error_buffer[grid_idx][replace_idx] = error_cpu

        elif args.training_config.buffer_replacement_strategy == "fifo":
            # First-in-first-out - O(1), simple queue behavior
            recycle_vars.y_error_buffer[grid_idx].pop(0)
            recycle_vars.y_error_buffer[grid_idx].append(error_cpu)

        elif args.training_config.buffer_replacement_strategy == "l2_batch":
            # Batch L2 computation - O(n) but vectorized, much faster than original
            distances = compute_l2_distance_batch(error_cpu, recycle_vars.y_error_buffer[grid_idx])
            most_similar_idx = torch.argmin(distances).item()
            recycle_vars.y_error_buffer[grid_idx][most_similar_idx] = error_cpu

        elif args.training_config.buffer_replacement_strategy == "l2_similarity":
            # Original L2 similarity method - O(n), slowest but most precise
            min_distance = float("inf")
            most_similar_idx = -1

            for i, stored_error in enumerate(recycle_vars.y_error_buffer[grid_idx]):
                distance = compute_l2_distance(error_cpu, stored_error)
                if distance < min_distance:
                    min_distance = distance
                    most_similar_idx = i

            if most_similar_idx != -1:
                recycle_vars.y_error_buffer[grid_idx][most_similar_idx] = error_cpu


def update_error_buffers_distributed(
    args, recycle_vars, gathered_noise_errors, gathered_y_errors, gathered_timesteps, noisy_model_input
):
    """Update error buffers with samples gathered from all processes."""
    # gathered_tensors have shape [num_gpus, batch_size, ...] for errors
    # gathered_timesteps have shape [num_gpus, batch_size] for timesteps
    # In this case, batch_size is 1, so shapes are [num_gpus, 1, ...] and [num_gpus, 1]
    num_gpus = gathered_noise_errors.shape[0]
    for i in range(num_gpus):
        noise_error_sample = gathered_noise_errors[i]
        y_error_sample = gathered_y_errors[i]
        timestep_sample = gathered_timesteps[i]  # Get the corresponding timestep for this GPU

        add_error_to_latent_buffer(args, recycle_vars, noise_error_sample, timestep_sample, noisy_model_input)
        add_error_to_y_buffer(args, recycle_vars, y_error_sample, timestep_sample, noisy_model_input)


def update_error_buffers_local(args, recycle_vars, noise_error, y_error, timestep, noisy_model_input):
    """Update error buffers with samples from local GPU only (post-warmup)."""
    add_error_to_latent_buffer(args, recycle_vars, noise_error, timestep, noisy_model_input)
    add_error_to_y_buffer(args, recycle_vars, y_error, timestep, noisy_model_input)