Helios/_DEV2/helios/utils/utils_recycle_batch.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,
):
    batch_size, _, _, h, w = noise.shape

    # Get grid indices for all batch items
    current_grid_indices = get_timestep_grid(args, recycle_vars, timesteps, noise)

    # Handle single item (backward compatibility)
    if isinstance(current_grid_indices, int):
        current_grid_indices = torch.tensor([current_grid_indices], device=noise.device)

    # Check buffer availability for each batch item
    has_latent_buffer_data = torch.tensor(
        [len(recycle_vars.latent_error_buffer[(h, w)][grid_idx.item()]) > 0 for grid_idx in current_grid_indices],
        device=noise.device,
    )

    has_y_buffer_data = any(len(buffer) > 0 for buffer in recycle_vars.y_error_buffer[(h, w)].values())

    # Generate random decisions for each batch item
    latent_random = torch.rand(batch_size, device=noise.device)
    noise_random = torch.rand(batch_size, device=noise.device)
    y_random = torch.rand(batch_size, device=noise.device)
    clean_random = torch.rand(batch_size, device=noise.device)

    # Determine which operations to apply for each batch item
    add_error_latent = latent_random < args.training_config.latent_prob
    add_error_noise = noise_random < args.training_config.noise_prob
    add_error_y = y_random < args.training_config.y_prob
    use_clean_input = clean_random < args.training_config.clean_prob

    # Clean input overrides all errors
    add_error_noise = add_error_noise & ~use_clean_input
    add_error_y = add_error_y & ~use_clean_input
    add_error_latent = add_error_latent & ~use_clean_input

    # Apply noise error
    if add_error_noise.any() and has_latent_buffer_data.any():
        noise_error_sampled = sample_noise_error_from_noise_buffer(
            args, recycle_vars, model_input, timesteps, model_input.dtype, model_input.device
        )
        mask = add_error_noise & has_latent_buffer_data
        if mask.any():
            noise_w_error[mask] = noise[mask] + noise_error_sampled[mask].to(model_input.dtype)

    # Apply y error for selected batch items
    if add_error_y.any() 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

        # Process each batch item independently
        for batch_idx in range(batch_size):
            if not add_error_y[batch_idx]:
                continue

            # Split history for this batch item
            tail_latents_history = None
            begin_latents_history = None

            latents_4x_item = latents_history_long[batch_idx : batch_idx + 1]
            latents_2x_item = latents_history_mid[batch_idx : batch_idx + 1]
            latents_clean_item = latents_history_short[batch_idx : batch_idx + 1]

            if tail_num != 0:
                tail_latents_history = latents_4x_item[:, :, :tail_num, :, :]
                latents_4x_item = latents_4x_item[:, :, tail_num:, :, :]
                # Apply tail error
                if tail_latents_history.sum() != 0 and random.random() < args.training_config.y_prob:
                    y_error_sampled = sample_y_error_from_latent_buffer(
                        args,
                        recycle_vars,
                        model_input[batch_idx : batch_idx + 1],
                        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_clean_item[:, :, :begin_num, :, :]
                latents_clean_item = latents_clean_item[:, :, begin_num:, :, :]
                # Apply begin error
                if begin_latents_history.sum() != 0 and random.random() < args.training_config.y_prob:
                    y_error_sampled = sample_y_error_from_latent_buffer(
                        args,
                        recycle_vars,
                        model_input[batch_idx : batch_idx + 1],
                        model_input.dtype,
                        model_input.device,
                    )
                    begin_latents_history = begin_latents_history + y_error_sampled[:, :, :1, ...]

            # Process mid windows
            mid_latents_history = torch.cat([latents_4x_item, latents_2x_item, latents_clean_item], 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 (
                    mid_latents_history[:, :, seq_begin:seq_end, :, :].sum() != 0
                    and random.random() < args.training_config.y_prob
                ):
                    y_error_sampled = sample_y_error_from_latent_buffer(
                        args,
                        recycle_vars,
                        model_input[batch_idx : batch_idx + 1],
                        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 structure
            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_clean_recovered = mid_latents_history.split(
                [len_4x, len_2x, ori_len_1x], dim=2
            )
            latents_history_long[batch_idx : batch_idx + 1] = latents_4x_recovered
            latents_history_mid[batch_idx : batch_idx + 1] = latents_2x_recovered
            latents_history_short[batch_idx : batch_idx + 1] = latents_clean_recovered

    # Apply latent error
    if add_error_latent.any() and has_latent_buffer_data.any():
        latent_error_sampled = sample_latent_error_from_latent_buffer(
            args, recycle_vars, model_input, timesteps, model_input.dtype, model_input.device
        )
        mask = add_error_latent & has_latent_buffer_data
        if mask.any():
            model_input_w_error[mask] = model_input[mask] + latent_error_sampled[mask].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):
    """
    Args:
        timestep: scalar, 1D tensor with shape [batch_size], or tensor that can be flattened
    """
    # Normalize timestep to 1D tensor
    if isinstance(timestep, torch.Tensor):
        timestep_vals = timestep.flatten().cpu()
    else:
        # Scalar value, convert to tensor
        timestep_vals = torch.tensor([timestep])

    batch_size = timestep_vals.shape[0]

    # Find timestep indices for all batch items
    # timestep_vals: [batch_size], scheduler.temp_timesteps: [num_timesteps]
    diffs = torch.abs(
        scheduler.temp_timesteps.unsqueeze(0) - timestep_vals.unsqueeze(-1)
    )  # [batch_size, num_timesteps]
    timestep_ids = torch.argmin(diffs, dim=-1)  # [batch_size]

    # Get sigmas for all batch items
    sigmas = scheduler.temp_sigmas[timestep_ids]  # [batch_size]

    # Calculate next sigmas
    if to_final:
        # All items go to final
        sigmas_next = torch.ones(batch_size) if self_corr else torch.zeros(batch_size)
    else:
        # Check which items are at the end
        at_end = timestep_ids + 1 >= len(scheduler.temp_timesteps)

        # Get next sigmas (clamped to valid range)
        next_ids = torch.clamp(timestep_ids + 1, 0, len(scheduler.temp_timesteps) - 1)
        sigmas_next = scheduler.temp_sigmas[next_ids]  # [batch_size]

        # Override with 1 or 0 for items at the end
        if self_corr:
            sigmas_next[at_end] = 1.0
        else:
            sigmas_next[at_end] = 0.0

    # Move sigmas to same device as sample
    sigmas = sigmas.to(sample.device, dtype=sample.dtype)
    sigmas_next = sigmas_next.to(sample.device, dtype=sample.dtype)

    # Compute prev_sample for all batch items
    # Reshape sigmas to broadcast correctly: [batch_size, 1, 1, 1, 1] for 5D tensors
    shape = [batch_size] + [1] * (sample.ndim - 1)
    sigma_diff = (sigmas_next - sigmas).view(*shape)

    prev_sample = sample + model_output * sigma_diff

    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."""
    _, _, _, h, w = noise.shape

    # Handle different timesteps formats (scalar tensor, tensor with batch dim, etc.)
    if isinstance(timesteps, torch.Tensor):
        timestep_vals = timesteps.flatten()
    else:
        # Already a scalar value
        timestep_vals = torch.tensor([timesteps], device=noise.device if hasattr(noise, "device") else "cpu")

    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_vals = torch.clamp(timestep_vals, 0, 999)
    grid_timesteps = temp_inferece_timesteps.to(timestep_vals.device)

    diffs = torch.abs(grid_timesteps.unsqueeze(0) - timestep_vals.unsqueeze(-1))
    grid_indices = torch.argmin(diffs, dim=-1)

    # Ensure grid index is within valid range
    max_grid_idx = len(recycle_vars.latent_error_buffer[(h, w)]) - 1
    grid_indices = torch.clamp(grid_indices, 0, max_grid_idx)

    return grid_indices


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."""
    batch_size, _, _, h, w = latents.shape
    grid_indices = get_timestep_grid(args, recycle_vars, timestep, latents)

    # Handle single item (backward compatibility)
    if isinstance(grid_indices, int):
        grid_indices = torch.tensor([grid_indices], device=device)

    # Initialize output tensor
    error_samples = torch.zeros_like(latents)

    # Sample error for each item in batch
    for i, grid_idx in enumerate(grid_indices):
        grid_idx = grid_idx.item()

        if not recycle_vars.latent_error_buffer[(h, w)][grid_idx]:
            continue  # Keep zeros for this batch item

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

        # Apply random intensity modulation
        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 = selected_sample * intensity_mod
        error_sample = error_sample

        # Assign to the i-th batch item
        error_samples[i] = error_sample

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

    return error_samples


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."""
    batch_size, _, _, h, w = latents.shape
    grid_indices = get_timestep_grid(args, recycle_vars, timestep, latents)

    # Handle single item (backward compatibility)
    if isinstance(grid_indices, int):
        grid_indices = torch.tensor([grid_indices], device=device)

    # Initialize output tensor
    error_samples = torch.zeros_like(latents)

    # Sample error for each item in batch
    for i, grid_idx in enumerate(grid_indices):
        grid_idx = grid_idx.item()

        if not recycle_vars.y_error_buffer[(h, w)][grid_idx]:
            continue  # Keep zeros for this batch item

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

        # Apply random intensity modulation
        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 = selected_sample * intensity_mod
        error_sample = error_sample

        # Assign to the i-th batch item
        error_samples[i] = error_sample

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

    return error_samples


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."""
    batch_size, _, _, h, w = latents.shape

    # Sample from all grids that have data
    all_samples = []
    for grid_idx, buffer in recycle_vars.y_error_buffer[(h, w)].items():
        if buffer:  # Only add non-empty buffers
            all_samples.extend(buffer)

    if not all_samples:
        return torch.zeros_like(latents)

    # Initialize output tensor
    error_samples = torch.zeros_like(latents)

    # Sample independently for each batch item
    for i in range(batch_size):
        # Randomly select one sample from all available samples
        selected_sample = random.choice(all_samples)

        # Apply random intensity modulation
        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 = selected_sample * intensity_mod
        error_sample = error_sample

        # Assign to the i-th batch item
        error_samples[i] = error_sample

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

    return error_samples


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."""
    batch_size, _, _, h, w = noisy_model_input.shape
    grid_indices = get_timestep_grid(args, recycle_vars, timestep, noisy_model_input)
    error_cpu = error_sample.detach().cpu()

    # Process each batch item
    for i, grid_idx in enumerate(grid_indices):
        grid_idx = grid_idx.item()
        error_cpu = error_sample[i].detach().cpu()

        if len(recycle_vars.latent_error_buffer[(h, w)][grid_idx]) < args.training_config.error_buffer_size:
            # Buffer not full, simply add
            recycle_vars.latent_error_buffer[(h, w)][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[(h, w)][grid_idx]) - 1)
                recycle_vars.latent_error_buffer[(h, w)][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[(h, w)][grid_idx].pop(0)
                recycle_vars.latent_error_buffer[(h, w)][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[(h, w)][grid_idx])
                most_similar_idx = torch.argmin(distances).item()
                recycle_vars.latent_error_buffer[(h, w)][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 j, stored_error in enumerate(recycle_vars.latent_error_buffer[(h, w)][grid_idx]):
                    distance = compute_l2_distance(error_cpu, stored_error)
                    if distance < min_distance:
                        min_distance = distance
                        most_similar_idx = j

                if most_similar_idx != -1:
                    recycle_vars.latent_error_buffer[(h, w)][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."""
    batch_size, _, _, h, w = noisy_model_input.shape
    grid_indices = get_timestep_grid(args, recycle_vars, timestep, noisy_model_input)
    error_cpu = error_sample.detach().cpu()

    # Process each batch item
    for i, grid_idx in enumerate(grid_indices):
        grid_idx = grid_idx.item()
        error_cpu = error_sample[i].detach().cpu()

        if len(recycle_vars.y_error_buffer[(h, w)][grid_idx]) < args.training_config.error_buffer_size:
            # Buffer not full, simply add
            recycle_vars.y_error_buffer[(h, w)][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[(h, w)][grid_idx]) - 1)
                recycle_vars.y_error_buffer[(h, w)][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[(h, w)][grid_idx].pop(0)
                recycle_vars.y_error_buffer[(h, w)][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[(h, w)][grid_idx])
                most_similar_idx = torch.argmin(distances).item()
                recycle_vars.y_error_buffer[(h, w)][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 j, stored_error in enumerate(recycle_vars.y_error_buffer[(h, w)][grid_idx]):
                    distance = compute_l2_distance(error_cpu, stored_error)
                    if distance < min_distance:
                        min_distance = distance
                        most_similar_idx = j

                if most_similar_idx != -1:
                    recycle_vars.y_error_buffer[(h, w)][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.
    Args:
        gathered_noise_errors: shape [num_gpus, batch_size, ...]
        gathered_y_errors: shape [num_gpus, batch_size, ...]
        gathered_timesteps: shape [num_gpus, batch_size]
    """
    num_gpus = gathered_noise_errors.shape[0]

    # Process each GPU's batch
    for gpu_idx in range(num_gpus):
        noise_error_batch = gathered_noise_errors[gpu_idx]  # [batch_size, ...]
        y_error_batch = gathered_y_errors[gpu_idx]  # [batch_size, ...]
        timestep_batch = gathered_timesteps[gpu_idx]  # [batch_size]

        # Add the entire batch to buffers
        add_error_to_latent_buffer(args, recycle_vars, noise_error_batch, timestep_batch, noisy_model_input)
        add_error_to_y_buffer(args, recycle_vars, y_error_batch, timestep_batch, 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).
    Args:
        noise_error: shape [batch_size, ...]
        y_error: shape [batch_size, ...]
        timestep: shape [batch_size] or scalar
    """
    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)


def process_and_update_error_buffers(
    args,
    recycle_vars,
    accelerator,
    global_step,
    noise_scheduler_copy,
    model_pred,
    target,
    timesteps,
    noisy_model_input,
    use_clean_input,
):
    x_0_pred = step_recycle(
        noise_scheduler_copy,
        model_pred,
        timesteps,
        noisy_model_input,
        to_final=True,
        self_corr=True,
    )
    noise_corr_gt = step_recycle(
        noise_scheduler_copy,
        target,
        timesteps,
        noisy_model_input,
        to_final=True,
        self_corr=True,
    )
    noise_error = x_0_pred - noise_corr_gt

    x_1_pred = step_recycle(
        noise_scheduler_copy,
        model_pred,
        timesteps,
        noisy_model_input,
        to_final=True,
        self_corr=False,
    )
    latent_corr_gt = step_recycle(
        noise_scheduler_copy,
        target,
        timesteps,
        noisy_model_input,
        to_final=True,
        self_corr=False,
    )
    y_error = x_1_pred - latent_corr_gt

    # Check if we're in warmup phase
    if global_step <= args.training_config.buffer_warmup_iter:

        def gather_with_optional_gpu_dim(tensor, keep_gpu_dim=False):
            gathered = accelerator.gather(tensor)

            if keep_gpu_dim:
                num_processes = accelerator.num_processes
                batch_size = tensor.shape[0]
                gathered = gathered.view(num_processes, batch_size, *gathered.shape[1:])

            return gathered

        # During warmup: gather errors and timesteps from all GPUs and update buffers
        gathered_noise_errors = gather_with_optional_gpu_dim(noise_error, keep_gpu_dim=True)
        gathered_y_errors = gather_with_optional_gpu_dim(y_error, keep_gpu_dim=True)
        gathered_timesteps = gather_with_optional_gpu_dim(timesteps, keep_gpu_dim=True)
        gathered_use_clean = gather_with_optional_gpu_dim(use_clean_input, keep_gpu_dim=True)
        # Shape: [num_gpus, batch_size]

        clean_mask = gathered_use_clean  # [num_gpus, batch_size]
        non_clean_mask = ~clean_mask  # [num_gpus, batch_size]
        num_gpus = gathered_noise_errors.shape[0]

        # Process clean samples: update with probability for each one
        if clean_mask.any():
            for gpu_idx in range(num_gpus):
                gpu_clean_mask = clean_mask[gpu_idx]
                if gpu_clean_mask.any():
                    p = random.random()
                    if p < args.training_config.clean_buffer_update_prob:
                        update_error_buffers_distributed(
                            args,
                            recycle_vars,
                            gathered_noise_errors[gpu_idx : gpu_idx + 1, gpu_clean_mask],
                            gathered_y_errors[gpu_idx : gpu_idx + 1, gpu_clean_mask],
                            gathered_timesteps[gpu_idx : gpu_idx + 1, gpu_clean_mask],
                            noisy_model_input,
                        )

        # Process non-clean samples: always update
        if non_clean_mask.any():
            for gpu_idx in range(num_gpus):
                gpu_non_clean_mask = non_clean_mask[gpu_idx]
                if gpu_non_clean_mask.any():
                    update_error_buffers_distributed(
                        args,
                        recycle_vars,
                        gathered_noise_errors[gpu_idx : gpu_idx + 1, gpu_non_clean_mask],
                        gathered_y_errors[gpu_idx : gpu_idx + 1, gpu_non_clean_mask],
                        gathered_timesteps[gpu_idx : gpu_idx + 1, gpu_non_clean_mask],
                        noisy_model_input,
                    )

    else:
        # After warmup: only use local GPU errors
        # Separate clean and non-clean samples
        clean_mask = use_clean_input  # Boolean tensor
        non_clean_mask = ~use_clean_input

        # Process clean samples: update with probability
        if clean_mask.any():
            p = random.random()
            if p < args.training_config.clean_buffer_update_prob:
                update_error_buffers_local(
                    args,
                    recycle_vars,
                    noise_error[clean_mask],
                    y_error[clean_mask],
                    timesteps[clean_mask],
                    noisy_model_input,
                )

        # Process non-clean samples: always update
        if non_clean_mask.any():
            update_error_buffers_local(
                args,
                recycle_vars,
                noise_error[non_clean_mask],
                y_error[non_clean_mask],
                timesteps[non_clean_mask],
                noisy_model_input,
            )