inversion_utils.py

import torch
from tqdm import tqdm
# from torchvision import transforms as T
from typing import List, Optional, Dict, Union
from models import PipelineWrapper


def mu_tilde(model, xt, x0, timestep):
    "mu_tilde(x_t, x_0) DDPM paper eq. 7"
    prev_timestep = timestep - model.scheduler.config.num_train_timesteps // model.scheduler.num_inference_steps
    alpha_prod_t_prev = model.scheduler.alphas_cumprod[prev_timestep] if prev_timestep >= 0 \
        else model.scheduler.final_alpha_cumprod
    alpha_t = model.scheduler.alphas[timestep]
    beta_t = 1 - alpha_t
    alpha_bar = model.scheduler.alphas_cumprod[timestep]
    return ((alpha_prod_t_prev ** 0.5 * beta_t) / (1-alpha_bar)) * x0 + \
        ((alpha_t**0.5 * (1-alpha_prod_t_prev)) / (1 - alpha_bar)) * xt


def sample_xts_from_x0(model, x0, num_inference_steps=50, x_prev_mode=False):
    """
    Samples from P(x_1:T|x_0)
    """
    # torch.manual_seed(43256465436)
    alpha_bar = model.model.scheduler.alphas_cumprod
    sqrt_one_minus_alpha_bar = (1-alpha_bar) ** 0.5
    alphas = model.model.scheduler.alphas
    # betas = 1 - alphas
    variance_noise_shape = (
            num_inference_steps + 1,
            model.model.unet.config.in_channels,
            # model.unet.sample_size,
            # model.unet.sample_size)
            x0.shape[-2],
            x0.shape[-1])

    timesteps = model.model.scheduler.timesteps.to(model.device)
    t_to_idx = {int(v): k for k, v in enumerate(timesteps)}
    xts = torch.zeros(variance_noise_shape).to(x0.device)
    xts[0] = x0
    x_prev = x0
    for t in reversed(timesteps):
        # idx = t_to_idx[int(t)]
        idx = num_inference_steps-t_to_idx[int(t)]
        if x_prev_mode:
            xts[idx] = x_prev * (alphas[t] ** 0.5) + torch.randn_like(x0) * ((1-alphas[t]) ** 0.5)
            x_prev = xts[idx].clone()
        else:
            xts[idx] = x0 * (alpha_bar[t] ** 0.5) + torch.randn_like(x0) * sqrt_one_minus_alpha_bar[t]
    # xts = torch.cat([xts, x0 ],dim = 0)

    return xts


def forward_step(model, model_output, timestep, sample):
    next_timestep = min(model.scheduler.config.num_train_timesteps - 2,
                        timestep + model.scheduler.config.num_train_timesteps // model.scheduler.num_inference_steps)

    # 2. compute alphas, betas
    alpha_prod_t = model.scheduler.alphas_cumprod[timestep]
    # alpha_prod_t_next = self.scheduler.alphas_cumprod[next_timestep] if next_ltimestep >= 0 \
    #     else self.scheduler.final_alpha_cumprod

    beta_prod_t = 1 - alpha_prod_t

    # 3. compute predicted original sample from predicted noise also called
    # "predicted x_0" of formula (12) from https://arxiv.org/pdf/2010.02502.pdf
    pred_original_sample = (sample - beta_prod_t ** (0.5) * model_output) / alpha_prod_t ** (0.5)

    # 5. TODO: simple noising implementatiom
    next_sample = model.scheduler.add_noise(pred_original_sample, model_output, torch.LongTensor([next_timestep]))
    return next_sample


def inversion_forward_process(model: PipelineWrapper,
                              x0: torch.Tensor,
                              etas: Optional[float] = None,
                              prog_bar: bool = False,
                              prompts: List[str] = [""],
                              cfg_scales: List[float] = [3.5],
                              num_inference_steps: int = 50,
                              eps: Optional[float] = None,
                              cutoff_points: Optional[List[float]] = None,
                              numerical_fix: bool = False,
                              extract_h_space: bool = False,
                              extract_skipconns: bool = False,
                              x_prev_mode: bool = False):
    if len(prompts) > 1 and extract_h_space:
        raise NotImplementedError("How do you split cfg_scales for hspace? TODO")

    if len(prompts) > 1 or prompts[0] != "":
        text_embeddings_hidden_states, text_embeddings_class_labels, \
            text_embeddings_boolean_prompt_mask = model.encode_text(prompts)
        # text_embeddings = encode_text(model, prompt)

        # # classifier free guidance
        batch_size = len(prompts)
        cfg_scales_tensor = torch.ones((batch_size, *x0.shape[1:]), device=model.device, dtype=x0.dtype)

        # if len(prompts) > 1:
        #     if cutoff_points is None:
        #         cutoff_points = [i * 1 / batch_size for i in range(1, batch_size)]
        #     if len(cfg_scales) == 1:
        #         cfg_scales *= batch_size
        #     elif len(cfg_scales) < batch_size:
        #         raise ValueError("Not enough target CFG scales")

        #     cutoff_points = [int(x * cfg_scales_tensor.shape[2]) for x in cutoff_points]
        #     cutoff_points = [0, *cutoff_points, cfg_scales_tensor.shape[2]]

        #     for i, (start, end) in enumerate(zip(cutoff_points[:-1], cutoff_points[1:])):
        #         cfg_scales_tensor[i, :, end:] = 0
        #         cfg_scales_tensor[i, :, :start] = 0
        #         cfg_scales_tensor[i] *= cfg_scales[i]
        #         if prompts[i] == "":
        #             cfg_scales_tensor[i] = 0
        #     cfg_scales_tensor = T.functional.gaussian_blur(cfg_scales_tensor, kernel_size=15, sigma=1)
        # else:
        cfg_scales_tensor *= cfg_scales[0]

    uncond_embedding_hidden_states, uncond_embedding_class_lables, uncond_boolean_prompt_mask = model.encode_text([""])
    # uncond_embedding = encode_text(model, "")
    timesteps = model.model.scheduler.timesteps.to(model.device)
    variance_noise_shape = (
        num_inference_steps,
        model.model.unet.config.in_channels,
        # model.unet.sample_size,
        # model.unet.sample_size)
        x0.shape[-2],
        x0.shape[-1])

    if etas is None or (type(etas) in [int, float] and etas == 0):
        eta_is_zero = True
        zs = None
    else:
        eta_is_zero = False
        if type(etas) in [int, float]:
            etas = [etas]*model.model.scheduler.num_inference_steps
        xts = sample_xts_from_x0(model, x0, num_inference_steps=num_inference_steps, x_prev_mode=x_prev_mode)
        alpha_bar = model.model.scheduler.alphas_cumprod
        zs = torch.zeros(size=variance_noise_shape, device=model.device)
    hspaces = []
    skipconns = []
    t_to_idx = {int(v): k for k, v in enumerate(timesteps)}
    xt = x0
    # op = tqdm(reversed(timesteps)) if prog_bar else reversed(timesteps)
    op = tqdm(timesteps) if prog_bar else timesteps

    for t in op:
        # idx = t_to_idx[int(t)]
        idx = num_inference_steps - t_to_idx[int(t)] - 1
        # 1. predict noise residual
        if not eta_is_zero:
            xt = xts[idx+1][None]

        with torch.no_grad():
            out, out_hspace, out_skipconns = model.unet_forward(xt, timestep=t,
                                                                encoder_hidden_states=uncond_embedding_hidden_states,
                                                                class_labels=uncond_embedding_class_lables,
                                                                encoder_attention_mask=uncond_boolean_prompt_mask)
            # out = model.unet.forward(xt, timestep= t, encoder_hidden_states=uncond_embedding)
            if len(prompts) > 1 or prompts[0] != "":
                cond_out, cond_out_hspace, cond_out_skipconns = model.unet_forward(
                    xt.expand(len(prompts), -1, -1, -1), timestep=t,
                    encoder_hidden_states=text_embeddings_hidden_states,
                    class_labels=text_embeddings_class_labels,
                    encoder_attention_mask=text_embeddings_boolean_prompt_mask)
                # cond_out = model.unet.forward(xt, timestep=t, encoder_hidden_states = text_embeddings)

        if len(prompts) > 1 or prompts[0] != "":
            # # classifier free guidance
            noise_pred = out.sample + \
                (cfg_scales_tensor * (cond_out.sample - out.sample.expand(batch_size, -1, -1, -1))
                 ).sum(axis=0).unsqueeze(0)
            if extract_h_space or extract_skipconns:
                noise_h_space = out_hspace + cfg_scales[0] * (cond_out_hspace - out_hspace)
            if extract_skipconns:
                noise_skipconns = {k: [out_skipconns[k][j] + cfg_scales[0] *
                                       (cond_out_skipconns[k][j] - out_skipconns[k][j])
                                       for j in range(len(out_skipconns[k]))]
                                   for k in out_skipconns}
        else:
            noise_pred = out.sample
            if extract_h_space or extract_skipconns:
                noise_h_space = out_hspace
            if extract_skipconns:
                noise_skipconns = out_skipconns
        if extract_h_space or extract_skipconns:
            hspaces.append(noise_h_space)
        if extract_skipconns:
            skipconns.append(noise_skipconns)

        if eta_is_zero:
            # 2. compute more noisy image and set x_t -> x_t+1
            xt = forward_step(model.model, noise_pred, t, xt)
        else:
            # xtm1 =  xts[idx+1][None]
            xtm1 = xts[idx][None]
            # pred of x0
            if model.model.scheduler.config.prediction_type == 'epsilon':
                pred_original_sample = (xt - (1 - alpha_bar[t]) ** 0.5 * noise_pred) / alpha_bar[t] ** 0.5
            elif model.model.scheduler.config.prediction_type == 'v_prediction':
                pred_original_sample = (alpha_bar[t] ** 0.5) * xt - ((1 - alpha_bar[t]) ** 0.5) * noise_pred

            # direction to xt
            prev_timestep = t - model.model.scheduler.config.num_train_timesteps // \
                model.model.scheduler.num_inference_steps

            alpha_prod_t_prev = model.get_alpha_prod_t_prev(prev_timestep)
            variance = model.get_variance(t, prev_timestep)

            if model.model.scheduler.config.prediction_type == 'epsilon':
                radom_noise_pred = noise_pred
            elif model.model.scheduler.config.prediction_type == 'v_prediction':
                radom_noise_pred = (alpha_bar[t] ** 0.5) * noise_pred + ((1 - alpha_bar[t]) ** 0.5) * xt

            pred_sample_direction = (1 - alpha_prod_t_prev - etas[idx] * variance) ** (0.5) * radom_noise_pred

            mu_xt = alpha_prod_t_prev ** (0.5) * pred_original_sample + pred_sample_direction

            z = (xtm1 - mu_xt) / (etas[idx] * variance ** 0.5)

            zs[idx] = z

            # correction to avoid error accumulation
            if numerical_fix:
                xtm1 = mu_xt + (etas[idx] * variance ** 0.5)*z
            xts[idx] = xtm1

    if zs is not None:
        # zs[-1] = torch.zeros_like(zs[-1])
        zs[0] = torch.zeros_like(zs[0])
        # zs_cycle[0] = torch.zeros_like(zs[0])

    if extract_h_space:
        hspaces = torch.concat(hspaces, axis=0)
        return xt, zs, xts, hspaces

    if extract_skipconns:
        hspaces = torch.concat(hspaces, axis=0)
        return xt, zs, xts, hspaces, skipconns

    return xt, zs, xts


def reverse_step(model, model_output, timestep, sample, eta=0, variance_noise=None):
    # 1. get previous step value (=t-1)
    prev_timestep = timestep - model.model.scheduler.config.num_train_timesteps // \
        model.model.scheduler.num_inference_steps
    # 2. compute alphas, betas
    alpha_prod_t = model.model.scheduler.alphas_cumprod[timestep]
    alpha_prod_t_prev = model.get_alpha_prod_t_prev(prev_timestep)
    beta_prod_t = 1 - alpha_prod_t
    # 3. compute predicted original sample from predicted noise also called
    # "predicted x_0" of formula (12) from https://arxiv.org/pdf/2010.02502.pdf
    if model.model.scheduler.config.prediction_type == 'epsilon':
        pred_original_sample = (sample - beta_prod_t ** (0.5) * model_output) / alpha_prod_t ** (0.5)
    elif model.model.scheduler.config.prediction_type == 'v_prediction':
        pred_original_sample = (alpha_prod_t ** 0.5) * sample - (beta_prod_t ** 0.5) * model_output

    # 5. compute variance: "sigma_t(η)" -> see formula (16)
    # σ_t = sqrt((1 − α_t−1)/(1 − α_t)) * sqrt(1 − α_t/α_t−1)
    # variance = self.scheduler._get_variance(timestep, prev_timestep)
    variance = model.get_variance(timestep, prev_timestep)
    # std_dev_t = eta * variance ** (0.5)
    # Take care of asymetric reverse process (asyrp)
    if model.model.scheduler.config.prediction_type == 'epsilon':
        model_output_direction = model_output
    elif model.model.scheduler.config.prediction_type == 'v_prediction':
        model_output_direction = (alpha_prod_t**0.5) * model_output + (beta_prod_t**0.5) * sample
    # 6. compute "direction pointing to x_t" of formula (12) from https://arxiv.org/pdf/2010.02502.pdf
    # pred_sample_direction = (1 - alpha_prod_t_prev - std_dev_t**2) ** (0.5) * model_output_direction
    pred_sample_direction = (1 - alpha_prod_t_prev - eta * variance) ** (0.5) * model_output_direction
    # 7. compute x_t without "random noise" of formula (12) from https://arxiv.org/pdf/2010.02502.pdf
    prev_sample = alpha_prod_t_prev ** (0.5) * pred_original_sample + pred_sample_direction
    # 8. Add noice if eta > 0
    if eta > 0:
        if variance_noise is None:
            variance_noise = torch.randn(model_output.shape, device=model.device)
        sigma_z = eta * variance ** (0.5) * variance_noise
        prev_sample = prev_sample + sigma_z

    return prev_sample


def inversion_reverse_process(model: PipelineWrapper,
                              xT: torch.Tensor,
                              skips: torch.Tensor,
                              fix_alpha: float = 0.1,
                              etas: float = 0,
                              prompts: List[str] = [""],
                              neg_prompts: List[str] = [""],
                              cfg_scales: Optional[List[float]] = None,
                              prog_bar: bool = False,
                              zs: Optional[List[torch.Tensor]] = None,
                            #   controller=None,
                              cutoff_points: Optional[List[float]] = None,
                              hspace_add: Optional[torch.Tensor] = None,
                              hspace_replace: Optional[torch.Tensor] = None,
                              skipconns_replace: Optional[Dict[int, torch.Tensor]] = None,
                              zero_out_resconns: Optional[Union[int, List]] = None,
                              asyrp: bool = False,
                              extract_h_space: bool = False,
                              extract_skipconns: bool = False):

    batch_size = len(prompts)

    text_embeddings_hidden_states, text_embeddings_class_labels, \
        text_embeddings_boolean_prompt_mask = model.encode_text(prompts)
    uncond_embedding_hidden_states, uncond_embedding_class_lables, \
        uncond_boolean_prompt_mask = model.encode_text(neg_prompts)
    # text_embeddings = encode_text(model, prompts)
    # uncond_embedding = encode_text(model, [""] * batch_size)

    masks = torch.ones((batch_size, *xT.shape[1:]), device=model.device, dtype=xT.dtype)
    cfg_scales_tensor = torch.ones((batch_size, *xT.shape[1:]), device=model.device, dtype=xT.dtype)

    # if batch_size > 1:
    #     if cutoff_points is None:
    #         cutoff_points = [i * 1 / batch_size for i in range(1, batch_size)]
    #     if len(cfg_scales) == 1:
    #         cfg_scales *= batch_size
    #     elif len(cfg_scales) < batch_size:
    #         raise ValueError("Not enough target CFG scales")

    #     cutoff_points = [int(x * cfg_scales_tensor.shape[2]) for x in cutoff_points]
    #     cutoff_points = [0, *cutoff_points, cfg_scales_tensor.shape[2]]

    #     for i, (start, end) in enumerate(zip(cutoff_points[:-1], cutoff_points[1:])):
    #         cfg_scales_tensor[i, :, end:] = 0
    #         cfg_scales_tensor[i, :, :start] = 0
    #         masks[i, :, end:] = 0
    #         masks[i, :, :start] = 0
    #         cfg_scales_tensor[i] *= cfg_scales[i]
    #     cfg_scales_tensor = T.functional.gaussian_blur(cfg_scales_tensor, kernel_size=15, sigma=1)
    #     masks = T.functional.gaussian_blur(masks, kernel_size=15, sigma=1)
    # else:
    cfg_scales_tensor *= cfg_scales[0]

    if etas is None:
        etas = 0
    if type(etas) in [int, float]:
        etas = [etas]*model.model.scheduler.num_inference_steps
    assert len(etas) == model.model.scheduler.num_inference_steps
    timesteps = model.model.scheduler.timesteps.to(model.device)

    # xt = xT.expand(1, -1, -1, -1)
    xt = xT[skips.max()].unsqueeze(0)
    op = tqdm(timesteps[-zs.shape[0]:]) if prog_bar else timesteps[-zs.shape[0]:]

    t_to_idx = {int(v): k for k, v in enumerate(timesteps[-zs.shape[0]:])}
    hspaces = []
    skipconns = []

    for it, t in enumerate(op):
        # idx = t_to_idx[int(t)]
        idx = model.model.scheduler.num_inference_steps - t_to_idx[int(t)] - \
            (model.model.scheduler.num_inference_steps - zs.shape[0] + 1)
        # # Unconditional embedding
        with torch.no_grad():
            uncond_out, out_hspace, out_skipconns = model.unet_forward(
                xt, timestep=t,
                encoder_hidden_states=uncond_embedding_hidden_states,
                class_labels=uncond_embedding_class_lables,
                encoder_attention_mask=uncond_boolean_prompt_mask,
                mid_block_additional_residual=(None if hspace_add is None else
                                               (1 / (cfg_scales[0] + 1)) *
                                               (hspace_add[-zs.shape[0]:][it] if hspace_add.shape[0] > 1
                                                else hspace_add)),
                replace_h_space=(None if hspace_replace is None else
                                 (hspace_replace[-zs.shape[0]:][it].unsqueeze(0) if hspace_replace.shape[0] > 1
                                  else hspace_replace)),
                zero_out_resconns=zero_out_resconns,
                replace_skip_conns=(None if skipconns_replace is None else
                                    (skipconns_replace[-zs.shape[0]:][it] if len(skipconns_replace) > 1
                                     else skipconns_replace))
                )  # encoder_hidden_states = uncond_embedding)

        # # Conditional embedding
        if prompts:
            with torch.no_grad():
                cond_out, cond_out_hspace, cond_out_skipconns = model.unet_forward(
                    xt.expand(batch_size, -1, -1, -1),
                    timestep=t,
                    encoder_hidden_states=text_embeddings_hidden_states,
                    class_labels=text_embeddings_class_labels,
                    encoder_attention_mask=text_embeddings_boolean_prompt_mask,
                    mid_block_additional_residual=(None if hspace_add is None else
                                                   (cfg_scales[0] / (cfg_scales[0] + 1)) *
                                                   (hspace_add[-zs.shape[0]:][it] if hspace_add.shape[0] > 1
                                                    else hspace_add)),
                    replace_h_space=(None if hspace_replace is None else
                                     (hspace_replace[-zs.shape[0]:][it].unsqueeze(0) if hspace_replace.shape[0] > 1
                                      else hspace_replace)),
                    zero_out_resconns=zero_out_resconns,
                    replace_skip_conns=(None if skipconns_replace is None else
                                        (skipconns_replace[-zs.shape[0]:][it] if len(skipconns_replace) > 1
                                         else skipconns_replace))
                    )  # encoder_hidden_states = text_embeddings)

        z = zs[idx] if zs is not None else None
        # print(f'idx: {idx}')
        # print(f't: {t}')
        z = z.unsqueeze(0)
        # z = z.expand(batch_size, -1, -1, -1)
        if prompts:
            # # classifier free guidance
            # noise_pred = uncond_out.sample + cfg_scales_tensor * (cond_out.sample - uncond_out.sample)
            noise_pred = uncond_out.sample + \
                (cfg_scales_tensor * (cond_out.sample - uncond_out.sample.expand(batch_size, -1, -1, -1))
                 ).sum(axis=0).unsqueeze(0)
            if extract_h_space or extract_skipconns:
                noise_h_space = out_hspace + cfg_scales[0] * (cond_out_hspace - out_hspace)
            if extract_skipconns:
                noise_skipconns = {k: [out_skipconns[k][j] + cfg_scales[0] *
                                       (cond_out_skipconns[k][j] - out_skipconns[k][j])
                                       for j in range(len(out_skipconns[k]))]
                                   for k in out_skipconns}
        else:
            noise_pred = uncond_out.sample
            if extract_h_space or extract_skipconns:
                noise_h_space = out_hspace
            if extract_skipconns:
                noise_skipconns = out_skipconns

        if extract_h_space or extract_skipconns:
            hspaces.append(noise_h_space)
        if extract_skipconns:
            skipconns.append(noise_skipconns)

        # 2. compute less noisy image and set x_t -> x_t-1
        xt = reverse_step(model, noise_pred, t, xt, eta=etas[idx], variance_noise=z)
        # if controller is not None:
            # xt = controller.step_callback(xt)

        # "fix" xt
        apply_fix = ((skips.max() - skips) > it)
        if apply_fix.any():
            apply_fix = (apply_fix * fix_alpha).unsqueeze(1).unsqueeze(2).unsqueeze(3).to(xT.device)
            xt = (masks * (xt.expand(batch_size, -1, -1, -1) * (1 - apply_fix) +
                           apply_fix * xT[skips.max() - it - 1].expand(batch_size, -1, -1, -1))
                  ).sum(axis=0).unsqueeze(0)

    if extract_h_space:
        return xt, zs, torch.concat(hspaces, axis=0)

    if extract_skipconns:
        return xt, zs, torch.concat(hspaces, axis=0), skipconns

    return xt, zs