DiffAtlas/ddpm/diffusion.py

import math
import copy
import torch
from torch import nn, einsum
import torch.nn.functional as F
from functools import partial
from pathlib import Path
from torch.optim import Adam
from torch.cuda.amp import autocast, GradScaler
from tqdm import tqdm
from einops import rearrange
from einops_exts import check_shape, rearrange_many
from rotary_embedding_torch import RotaryEmbedding
from ddpm.text import tokenize, bert_embed, BERT_MODEL_DIM
from torch.utils.data import DataLoader
# from vq_gan_3d.model.vqgan import VQGAN

from collections import defaultdict

# 检查x是否不为None
def exists(x):
    return x is not None
# 无操作函数，用作占位符
def noop(*args, **kwargs):
    pass
# 判断数字n是否为奇数
def is_odd(n):
    return (n % 2) == 1
# 如果val存在，则返回val；否则返回d()（如果d是可调用的）或d
def default(val, d):
    if exists(val):
        return val
    return d() if callable(d) else d
# 创建一个无限生成器，循环遍历数据加载器dl
def cycle(dl):
    while True:
        for data in dl:
            yield data
# 将num分成大小为divisor的组，处理余数
def num_to_groups(num, divisor):
    groups = num // divisor
    remainder = num % divisor
    arr = [divisor] * groups
    if remainder > 0:
        arr.append(remainder)
    return arr
# 根据概率prob生成一个掩码张量
def prob_mask_like(shape, prob, device):
    if prob == 1:
        return torch.ones(shape, device=device, dtype=torch.bool)
    elif prob == 0:
        return torch.zeros(shape, device=device, dtype=torch.bool)
    else:
        return torch.zeros(shape, device=device).float().uniform_(0, 1) < prob
# 检查x是否为字符串列表或元组
def is_list_str(x):
    if not isinstance(x, (list, tuple)):
        return False
    return all([type(el) == str for el in x])

class RelativePositionBias(nn.Module):
    def __init__(
        self,
        heads=8,
        num_buckets=32,
        max_distance=128
    ):
        super().__init__()
        self.num_buckets = num_buckets
        self.max_distance = max_distance
        self.relative_attention_bias = nn.Embedding(num_buckets, heads)

    @staticmethod
    def _relative_position_bucket(relative_position, num_buckets=32, max_distance=128):
        ret = 0
        n = -relative_position
        num_buckets //= 2
        ret += (n < 0).long() * num_buckets
        n = torch.abs(n)
        max_exact = num_buckets // 2
        is_small = n < max_exact
        val_if_large = max_exact + (
            torch.log(n.float() / max_exact) / math.log(max_distance /
                                                        max_exact) * (num_buckets - max_exact)
        ).long()
        val_if_large = torch.min(
            val_if_large, torch.full_like(val_if_large, num_buckets - 1))
        ret += torch.where(is_small, n, val_if_large)
        return ret

    def forward(self, n, device):
        q_pos = torch.arange(n, dtype=torch.long, device=device)
        k_pos = torch.arange(n, dtype=torch.long, device=device)
        rel_pos = rearrange(k_pos, 'j -> 1 j') - rearrange(q_pos, 'i -> i 1')
        rp_bucket = self._relative_position_bucket(
            rel_pos, num_buckets=self.num_buckets, max_distance=self.max_distance)
        values = self.relative_attention_bias(rp_bucket)
        return rearrange(values, 'i j h -> h i j')

class EMA():
    def __init__(self, beta):
        super().__init__()
        self.beta = beta

    def update_model_average(self, ma_model, current_model):
        for current_params, ma_params in zip(current_model.parameters(), ma_model.parameters()):
            old_weight, up_weight = ma_params.data, current_params.data
            ma_params.data = self.update_average(old_weight, up_weight)

    def update_average(self, old, new):
        if old is None:
            return new
        return old * self.beta + (1 - self.beta) * new


class Residual(nn.Module):
    def __init__(self, fn):
        super().__init__()
        self.fn = fn

    def forward(self, x, *args, **kwargs):
        return self.fn(x, *args, **kwargs) + x


class SinusoidalPosEmb(nn.Module):
    def __init__(self, dim):
        super().__init__()
        self.dim = dim

    def forward(self, x):
        device = x.device
        half_dim = self.dim // 2
        emb = math.log(10000) / (half_dim - 1)
        emb = torch.exp(torch.arange(half_dim, device=device) * -emb)
        emb = x[:, None] * emb[None, :]
        emb = torch.cat((emb.sin(), emb.cos()), dim=-1)
        return emb


def Upsample(dim):
    return nn.ConvTranspose3d(dim, dim, (1, 4, 4), (1, 2, 2), (0, 1, 1))


def Downsample(dim):
    return nn.Conv3d(dim, dim, (1, 4, 4), (1, 2, 2), (0, 1, 1))


class LayerNorm(nn.Module):
    def __init__(self, dim, eps=1e-5):
        super().__init__()
        self.eps = eps
        self.gamma = nn.Parameter(torch.ones(1, dim, 1, 1, 1))

    def forward(self, x):
        var = torch.var(x, dim=1, unbiased=False, keepdim=True)
        mean = torch.mean(x, dim=1, keepdim=True)
        return (x - mean) / (var + self.eps).sqrt() * self.gamma


class PreNorm(nn.Module):
    def __init__(self, dim, fn):
        super().__init__()
        self.fn = fn
        self.norm = LayerNorm(dim)

    def forward(self, x, **kwargs):
        x = self.norm(x)
        return self.fn(x, **kwargs)



class Block(nn.Module):
    def __init__(self, dim, dim_out, groups=8):
        super().__init__()
        self.proj = nn.Conv3d(dim, dim_out, (1, 3, 3), padding=(0, 1, 1))
        self.norm = nn.GroupNorm(groups, dim_out)
        self.act = nn.SiLU()

    def forward(self, x, scale_shift=None):
        x = self.proj(x)
        x = self.norm(x)
        if exists(scale_shift):
            scale, shift = scale_shift
            x = x * (scale + 1) + shift
        return self.act(x)


class ResnetBlock(nn.Module):
    def __init__(self, dim, dim_out, *, time_emb_dim=None, groups=8):
        super().__init__()
        self.mlp = nn.Sequential(
            nn.SiLU(),
            nn.Linear(time_emb_dim, dim_out * 2)
        ) if exists(time_emb_dim) else None
        self.block1 = Block(dim, dim_out, groups=groups)
        self.block2 = Block(dim_out, dim_out, groups=groups)
        self.res_conv = nn.Conv3d(
            dim, dim_out, 1) if dim != dim_out else nn.Identity()

    def forward(self, x, time_emb=None):
        scale_shift = None
        if exists(self.mlp):
            assert exists(time_emb), 'time emb must be passed in'
            time_emb = self.mlp(time_emb)
            time_emb = rearrange(time_emb, 'b c -> b c 1 1 1')
            scale_shift = time_emb.chunk(2, dim=1)
        h = self.block1(x, scale_shift=scale_shift)
        h = self.block2(h)
        return h + self.res_conv(x)


class SpatialLinearAttention(nn.Module):
    def __init__(self, dim, heads=4, dim_head=32):
        super().__init__()
        self.scale = dim_head ** -0.5
        self.heads = heads
        hidden_dim = dim_head * heads
        self.to_qkv = nn.Conv2d(dim, hidden_dim * 3, 1, bias=False)
        self.to_out = nn.Conv2d(hidden_dim, dim, 1)

    def forward(self, x):
        b, c, f, h, w = x.shape
        x = rearrange(x, 'b c f h w -> (b f) c h w')
        qkv = self.to_qkv(x).chunk(3, dim=1)
        q, k, v = rearrange_many(
            qkv, 'b (h c) x y -> b h c (x y)', h=self.heads)
        q = q.softmax(dim=-2)
        k = k.softmax(dim=-1)
        q = q * self.scale
        context = torch.einsum('b h d n, b h e n -> b h d e', k, v)

        out = torch.einsum('b h d e, b h d n -> b h e n', context, q)
        out = rearrange(out, 'b h c (x y) -> b (h c) x y',
                        h=self.heads, x=h, y=w)
        out = self.to_out(out)
        return rearrange(out, '(b f) c h w -> b c f h w', b=b)


class EinopsToAndFrom(nn.Module):
    def __init__(self, from_einops, to_einops, fn):
        super().__init__()
        self.from_einops = from_einops
        self.to_einops = to_einops
        self.fn = fn

    def forward(self, x, **kwargs):
        shape = x.shape
        reconstitute_kwargs = dict(
            tuple(zip(self.from_einops.split(' '), shape)))
        x = rearrange(x, f'{self.from_einops} -> {self.to_einops}')
        x = self.fn(x, **kwargs)
        x = rearrange(
            x, f'{self.to_einops} -> {self.from_einops}', **reconstitute_kwargs)
        return x


class Attention(nn.Module):
    def __init__(
        self,
        dim,
        heads=4,
        dim_head=32,
        rotary_emb=None
    ):
        super().__init__()
        self.scale = dim_head ** -0.5
        self.heads = heads
        hidden_dim = dim_head * heads
        self.rotary_emb = rotary_emb
        self.to_qkv = nn.Linear(dim, hidden_dim * 3, bias=False)
        self.to_out = nn.Linear(hidden_dim, dim, bias=False)

    def forward(
        self,
        x,
        pos_bias=None,
        focus_present_mask=None
    ):
        n, device = x.shape[-2], x.device
        qkv = self.to_qkv(x).chunk(3, dim=-1)
        if exists(focus_present_mask) and focus_present_mask.all():
            values = qkv[-1]
            return self.to_out(values)
        q, k, v = rearrange_many(qkv, '... n (h d) -> ... h n d', h=self.heads)
        q = q * self.scale
        if exists(self.rotary_emb):
            q = self.rotary_emb.rotate_queries_or_keys(q)
            k = self.rotary_emb.rotate_queries_or_keys(k)
        sim = einsum('... h i d, ... h j d -> ... h i j', q, k)
        if exists(pos_bias):
            sim = sim + pos_bias

        if exists(focus_present_mask) and not (~focus_present_mask).all():
            attend_all_mask = torch.ones(
                (n, n), device=device, dtype=torch.bool)
            attend_self_mask = torch.eye(n, device=device, dtype=torch.bool)

            mask = torch.where(
                rearrange(focus_present_mask, 'b -> b 1 1 1 1'),
                rearrange(attend_self_mask, 'i j -> 1 1 1 i j'),
                rearrange(attend_all_mask, 'i j -> 1 1 1 i j'),
            )
            sim = sim.masked_fill(~mask, -torch.finfo(sim.dtype).max)
        sim = sim - sim.amax(dim=-1, keepdim=True).detach()
        attn = sim.softmax(dim=-1)
        out = einsum('... h i j, ... h j d -> ... h i d', attn, v)
        out = rearrange(out, '... h n d -> ... n (h d)')
        return self.to_out(out)


class Unet3D(nn.Module):
    def __init__(
        self,
        dim,
        cond_dim=None,
        out_dim=None,
        dim_mults=(1, 2, 4, 8),
        channels=3,
        attn_heads=8,
        attn_dim_head=32,
        use_bert_text_cond=False,
        init_dim=None,
        init_kernel_size=7,
        use_sparse_linear_attn=True,
        resnet_groups=8
    ):
        super().__init__()
        self.channels = channels
        rotary_emb = RotaryEmbedding(min(32, attn_dim_head))
        def temporal_attn(dim): return EinopsToAndFrom('b c f h w', 'b (h w) f c', Attention(
            dim, heads=attn_heads, dim_head=attn_dim_head, rotary_emb=rotary_emb))
        self.time_rel_pos_bias = RelativePositionBias(
            heads=attn_heads, max_distance=32)
        init_dim = default(init_dim, dim)
        assert is_odd(init_kernel_size)
        init_padding = init_kernel_size // 2
        self.init_conv = nn.Conv3d(channels, init_dim, (1, init_kernel_size,
                                   init_kernel_size), padding=(0, init_padding, init_padding))
        self.init_temporal_attn = Residual(
            PreNorm(init_dim, temporal_attn(init_dim)))
        dims = [init_dim, *map(lambda m: dim * m, dim_mults)]
        in_out = list(zip(dims[:-1], dims[1:]))
        time_dim = dim * 4
        self.time_mlp = nn.Sequential(
            SinusoidalPosEmb(dim),
            nn.Linear(dim, time_dim),
            nn.GELU(),
            nn.Linear(time_dim, time_dim)
        )
        self.has_cond = exists(cond_dim) or use_bert_text_cond
        cond_dim = BERT_MODEL_DIM if use_bert_text_cond else cond_dim
        self.null_cond_emb = nn.Parameter(
            torch.randn(1, cond_dim)) if self.has_cond else None
        cond_dim = time_dim + int(cond_dim or 0)
        self.downs = nn.ModuleList([])
        self.ups = nn.ModuleList([])
        num_resolutions = len(in_out)
        block_klass = partial(ResnetBlock, groups=resnet_groups)
        block_klass_cond = partial(block_klass, time_emb_dim=cond_dim)
        for ind, (dim_in, dim_out) in enumerate(in_out):
            is_last = ind >= (num_resolutions - 1)
            self.downs.append(nn.ModuleList([
                block_klass_cond(dim_in, dim_out),
                block_klass_cond(dim_out, dim_out),
                Residual(PreNorm(dim_out, SpatialLinearAttention(
                    dim_out, heads=attn_heads))) if use_sparse_linear_attn else nn.Identity(),
                Residual(PreNorm(dim_out, temporal_attn(dim_out))),
                Downsample(dim_out) if not is_last else nn.Identity()
            ]))
        mid_dim = dims[-1]
        self.mid_block1 = block_klass_cond(mid_dim, mid_dim)
        spatial_attn = EinopsToAndFrom(
            'b c f h w', 'b f (h w) c', Attention(mid_dim, heads=attn_heads))
        self.mid_spatial_attn = Residual(PreNorm(mid_dim, spatial_attn))
        self.mid_temporal_attn = Residual(
            PreNorm(mid_dim, temporal_attn(mid_dim)))
        self.mid_block2 = block_klass_cond(mid_dim, mid_dim)
        for ind, (dim_in, dim_out) in enumerate(reversed(in_out)):
            is_last = ind >= (num_resolutions - 1)
            self.ups.append(nn.ModuleList([
                block_klass_cond(dim_out * 2, dim_in),
                block_klass_cond(dim_in, dim_in),
                Residual(PreNorm(dim_in, SpatialLinearAttention(
                    dim_in, heads=attn_heads))) if use_sparse_linear_attn else nn.Identity(),
                Residual(PreNorm(dim_in, temporal_attn(dim_in))),
                Upsample(dim_in) if not is_last else nn.Identity()
            ]))
        out_dim = default(out_dim, channels)
        self.final_conv = nn.Sequential(
            block_klass(dim * 2, dim),
            nn.Conv3d(dim, out_dim, 1)
        )

    def forward_with_cond_scale(
        self,
        *args,
        cond_scale=2.,
        **kwargs
    ): 
        logits = self.forward(*args, null_cond_prob=0., **kwargs)
        if cond_scale == 1 or not self.has_cond:
            return logits
        null_logits = self.forward(*args, null_cond_prob=1., **kwargs)
        return null_logits + (logits - null_logits) * cond_scale

    def forward(
        self,
        x,
        time,
        cond=None,
        null_cond_prob=0.,
        focus_present_mask=None,
        prob_focus_present=0.
    ):
        if cond is None:                    
            cond = torch.zeros((1, 16))
            cond[0, -1] = 1.0
        assert not (self.has_cond and not exists(cond)
                    ), 'cond must be passed in if cond_dim specified'
        batch, device = x.shape[0], x.device
        focus_present_mask = default(focus_present_mask, lambda: prob_mask_like(
            (batch,), prob_focus_present, device=device))
        time_rel_pos_bias = self.time_rel_pos_bias(x.shape[2], device=x.device)
        x = self.init_conv(x)
        r = x.clone()
        x = self.init_temporal_attn(x, pos_bias=time_rel_pos_bias)
        t = self.time_mlp(time) if exists(self.time_mlp) else None
        if self.has_cond:
            batch, device = x.shape[0], x.device
            mask = prob_mask_like((batch,), null_cond_prob, device=device)
            cond = cond.to(device)
            cond = torch.where(rearrange(mask, 'b -> b 1'),
                               self.null_cond_emb, cond)

            t = torch.cat((t, cond), dim=-1)
        h = []
        for block1, block2, spatial_attn, temporal_attn, downsample in self.downs:
            x = block1(x, t)
            x = block2(x, t)
            x = spatial_attn(x)
            x = temporal_attn(x, pos_bias=time_rel_pos_bias,
                              focus_present_mask=focus_present_mask)
            h.append(x)
            x = downsample(x)
        x = self.mid_block1(x, t)
        x = self.mid_spatial_attn(x)
        x = self.mid_temporal_attn(
            x, pos_bias=time_rel_pos_bias, focus_present_mask=focus_present_mask)
        x = self.mid_block2(x, t)
        for block1, block2, spatial_attn, temporal_attn, upsample in self.ups:
            x = torch.cat((x, h.pop()), dim=1)
            x = block1(x, t)
            x = block2(x, t)
            x = spatial_attn(x)
            x = temporal_attn(x, pos_bias=time_rel_pos_bias,
                              focus_present_mask=focus_present_mask)
            x = upsample(x)

        x = torch.cat((x, r), dim=1)
        return self.final_conv(x)



def extract(a, t, x_shape):
    b, *_ = t.shape
    out = a.gather(-1, t)
    return out.reshape(b, *((1,) * (len(x_shape) - 1)))


def cosine_beta_schedule(timesteps, s=0.008):

    steps = timesteps + 1
    x = torch.linspace(0, timesteps, steps, dtype=torch.float64)
    alphas_cumprod = torch.cos(
        ((x / timesteps) + s) / (1 + s) * torch.pi * 0.5) ** 2
    alphas_cumprod = alphas_cumprod / alphas_cumprod[0]
    betas = 1 - (alphas_cumprod[1:] / alphas_cumprod[:-1])
    return torch.clip(betas, 0, 0.9999)


class GaussianDiffusion_Nolatent(nn.Module):
    def __init__(
        self,
        denoise_fn,
        *,
        image_size,
        num_frames,
        text_use_bert_cls=False,
        channels=2,
        timesteps=1000,
        loss_type='l1',
        use_dynamic_thres=False, 
        dynamic_thres_percentile=0.9,
        device=None,
        use_guide=True,
        # vqgan_ckpt=None,
    ):
        super().__init__()
        self.channels = channels
        self.image_size = image_size
        self.num_frames = num_frames
        self.denoise_fn = denoise_fn
        # if vqgan_ckpt:
        #     self.vqgan = VQGAN.load_from_checkpoint(vqgan_ckpt).cuda()
        #     self.vqgan.eval()
        # else:
        #     self.vqgan = None
        self.device=device
        betas = cosine_beta_schedule(timesteps)
        alphas = 1. - betas
        alphas_cumprod = torch.cumprod(alphas, axis=0)
        alphas_cumprod_prev = F.pad(alphas_cumprod[:-1], (1, 0), value=1.)
        timesteps, = betas.shape
        self.num_timesteps = int(timesteps)
        print("timesteps : ", timesteps)
        self.loss_type = loss_type
        self.use_guide = use_guide


        def register_buffer(name, val): return self.register_buffer(
            name, val.to(torch.float32))
        register_buffer('betas', betas)
        register_buffer('alphas_cumprod', alphas_cumprod)
        register_buffer('alphas_cumprod_prev', alphas_cumprod_prev)
        register_buffer('sqrt_alphas_cumprod', torch.sqrt(alphas_cumprod))
        register_buffer('sqrt_one_minus_alphas_cumprod',
                        torch.sqrt(1. - alphas_cumprod))
        register_buffer('log_one_minus_alphas_cumprod',
                        torch.log(1. - alphas_cumprod))
        register_buffer('sqrt_recip_alphas_cumprod',
                        torch.sqrt(1. / alphas_cumprod))
        register_buffer('sqrt_recipm1_alphas_cumprod',
                        torch.sqrt(1. / alphas_cumprod - 1))


        posterior_variance = betas * \
            (1. - alphas_cumprod_prev) / (1. - alphas_cumprod)
        register_buffer('posterior_variance', posterior_variance)

        register_buffer('posterior_log_variance_clipped',
                        torch.log(posterior_variance.clamp(min=1e-20)))
        register_buffer('posterior_mean_coef1', betas *
                        torch.sqrt(alphas_cumprod_prev) / (1. - alphas_cumprod))
        register_buffer('posterior_mean_coef2', (1. - alphas_cumprod_prev)
                        * torch.sqrt(alphas) / (1. - alphas_cumprod))


        self.text_use_bert_cls = text_use_bert_cls


        self.use_dynamic_thres = use_dynamic_thres
        self.dynamic_thres_percentile = dynamic_thres_percentile

    # 计算扩散过程中的均值和方差，用于定义 q(x_t|x_0) 分布
    # x_start：原始数据 x_0 
    def q_mean_variance(self, x_start, t):
        mean = extract(self.sqrt_alphas_cumprod, t, x_start.shape) * x_start
        variance = extract(1. - self.alphas_cumprod, t, x_start.shape)
        log_variance = extract(
            self.log_one_minus_alphas_cumprod, t, x_start.shape)
        return mean, variance, log_variance
    
    # 从带噪声的样本 x_t 和噪声 epsilon 预测 原始数据 x_0
    # 输出：预测的原始数据 x_0
    def predict_start_from_noise(self, x_t, t, noise):
        return (
            extract(self.sqrt_recip_alphas_cumprod, t, x_t.shape) * x_t -
            extract(self.sqrt_recipm1_alphas_cumprod, t, x_t.shape) * noise
        )

    # 计算后验分布 q(x_{t-1}|x_t, x_0) 的均值和方差
    def q_posterior(self, x_start, x_t, t):
        posterior_mean = (
            extract(self.posterior_mean_coef1, t, x_t.shape) * x_start +
            extract(self.posterior_mean_coef2, t, x_t.shape) * x_t
        )
        posterior_variance = extract(self.posterior_variance, t, x_t.shape)
        posterior_log_variance_clipped = extract(
            self.posterior_log_variance_clipped, t, x_t.shape)
        return posterior_mean, posterior_variance, posterior_log_variance_clipped

    # 根据去噪函数的预测，计算后验分布 p(x_{t-1}|x_t)
    def p_mean_variance(self, x, t, clip_denoised: bool, cond=None, cond_scale=1.):
        if isinstance(self.denoise_fn, torch.nn.DataParallel):
            noise = self.denoise_fn.module.forward_with_cond_scale(x, t, cond=cond, cond_scale=cond_scale)
        else:
            noise = self.denoise_fn.forward_with_cond_scale(x, t, cond=cond, cond_scale=cond_scale)
        x_recon = self.predict_start_from_noise(
            x, t=t, noise=noise)
        if clip_denoised:
            s = 1.
            if self.use_dynamic_thres:
                s = torch.quantile(
                    rearrange(x_recon, 'b ... -> b (...)').abs(),
                    self.dynamic_thres_percentile,
                    dim=-1
                )
                s.clamp_(min=1.)
                s = s.view(-1, *((1,) * (x_recon.ndim - 1)))

            x_recon = x_recon.clamp(-s, s) / s
        model_mean, posterior_variance, posterior_log_variance = self.q_posterior(
            x_start=x_recon, x_t=x, t=t)
        return model_mean, posterior_variance, posterior_log_variance


    # 从后验分布 p(x_{t-1}|x_t) 采样 x_{t-1}
    #@torch.inference_mode()
    def p_sample_v2(self, x, t, cond=None, cond_scale=1., clip_denoised=True):
        b, *_ = x.shape
        model_mean, _, model_log_variance = self.p_mean_variance(
            x=x, t=t, clip_denoised=clip_denoised, cond=cond, cond_scale=cond_scale)
        noise = torch.randn_like(x)
        nonzero_mask = (1 - (t == 0).float()).reshape(b,
                                                      *((1,) * (len(x.shape) - 1)))
        return model_mean + nonzero_mask * (0.5 * model_log_variance).exp() * noise
    
    @torch.inference_mode()
    def p_sample(self, x, t, cond=None, cond_scale=1., clip_denoised=True):
        b, *_ = x.shape
        model_mean, _, model_log_variance = self.p_mean_variance(
            x=x, t=t, clip_denoised=clip_denoised, cond=cond, cond_scale=cond_scale)
        noise = torch.randn_like(x)
        nonzero_mask = (1 - (t == 0).float()).reshape(b,
                                                      *((1,) * (len(x.shape) - 1)))
        return model_mean + nonzero_mask * (0.5 * model_log_variance).exp() * noise
    
    # @torch.inference_mode()
    def p_sample_loop_v2(self, shape_image, shape_mask, cond=None, cond_scale=1., device=None, image=None):
        b = shape_image[0]
        img = torch.randn(shape_image, device=device)
        mask = torch.randn(shape_mask, device=device)
        input = torch.cat((img, mask), dim=1)
        real_img = image
        input_guided = input
        N = 2 
        R = 3
        B = 1
        recurrent = [0] * self.num_timesteps
        for i in range(self.num_timesteps):
            if i % R == 0:
                recurrent[i] = R
        i = self.num_timesteps - 1
        while i >= 0:
            # print(i)
            if self.use_guide is not None and i < 250:
            # if self.use_guide is not None:
                input_with_grad = input_guided.clone().detach().requires_grad_(True)
                loss = 0
                t = torch.full((b,), i, dtype=torch.long, device=device)
                real_noisy_image = self.q_sample(x_start=real_img, t=t)
                for _ in range(N):
                    input_sampled = input_with_grad
                    input_sampled = self.p_sample_v2(input_sampled, torch.full(
                        (b,), i, device=device, dtype=torch.long), cond=cond, cond_scale=cond_scale)
                    # print(torch.split(input_sampled, 1, dim=1).shape)
                    loss+=F.mse_loss(torch.split(input_sampled, 1, dim=1)[0], real_noisy_image)
                loss /= N
                loss.backward()
                update = torch.clamp(input_with_grad.grad * 10000.0, -1.5, 1.5)
                # input_guided= input_guided- update
                # print(update[:, 0, :, :, :])
                input_guided[:, 0, :, :, :] = input_guided[:, 0, :, :, :] - update[:, 0, :, :, :]
                # input_guided[:, 1:6, :, :, :] = input_guided[:, 1:6, :, :, :] - 0.01*update[:, 0, :, :, :]
                input_with_grad.grad.zero_()
            
            # else:
            #     input_guided = input

            with torch.no_grad():
                    # input = self.p_sample_v2(input, torch.full(
                    # (b,), i, device=device, dtype=torch.long), cond=cond, cond_scale=cond_scale)
                    input_guided = self.p_sample_v2(input_guided, torch.full(
                    (b,), i, device=device, dtype=torch.long), cond=cond, cond_scale=cond_scale)

            # if i % R == 0 and recurrent[i]!=0 :
            #     recurrent[i] -= 1
            #     with torch.no_grad():
            #         for _ in range(B):
            #             input_guided=self.q_sample_one_step(input_guided, torch.full((b,), i, device=device, dtype=torch.long))
            #             i += 1
            
            i -= 1
        
        return input_guided 
    
    @torch.inference_mode()
    def p_sample_loop(self, shape_image, shape_mask, cond=None, cond_scale=1., device=None, image=None):
        b = shape_image[0]
        img = torch.randn(shape_image, device=device)
        mask = torch.randn(shape_mask, device=device)
        input = torch.cat((img, mask), dim=1)
        real_img = image
        R = 2
        recurrent = [0] * self.num_timesteps
        for i in range(self.num_timesteps):
            if i % R == 0:
                recurrent[i] = R
        
        i = self.num_timesteps - 1
        while i >= 0:
            # print(i)
            # if self.use_guide is not None and i < 250:
            # if self.use_guide is not None and i > 200:
            if self.use_guide is not None:
                t = torch.full((b,), i, dtype=torch.long, device=device)
                real_noisy_image = self.q_sample(x_start=real_img, t=t)
                input[:, 0, :, :, :] = real_noisy_image[:, 0, :, :, :].clone()
            # with torch.no_grad():
                input = self.p_sample(input, torch.full(
                (b,), i, device=device, dtype=torch.long), cond=cond, cond_scale=cond_scale)

            # if i % 5 == 0 and recurrent[i]!=0 :
            #     recurrent[i] -= 1
            #     with torch.no_grad():
            #         for _ in range(5):
            #             input=self.q_sample_one_step(input, torch.full((b,), i, device=device, dtype=torch.long))
            #             i += 1
            
            i -= 1
        
        return input

    @torch.inference_mode()
    def p_sample_loop_v4(self, shape_image, shape_mask, cond=None, cond_scale=1., device=None, image=None):
        b = shape_image[0]
        img = torch.randn(shape_image, device=device)
        mask = torch.randn(shape_mask, device=device)
        input = torch.cat((img, mask), dim=1)
        real_img = image
        R = 2
        recurrent = [0] * self.num_timesteps
        for i in range(self.num_timesteps):
            if i % R == 0:
                recurrent[i] = R
        
        i = self.num_timesteps - 1
        while i >= 0:
            print(i)
            # if self.use_guide is not None and i < 250:
            if self.use_guide is not None and i > 100:
            # if self.use_guide is not None:
                t = torch.full((b,), i, dtype=torch.long, device=device)
                real_noisy_image = self.q_sample(x_start=real_img, t=t)
                input[:, 0, :, :, :] = real_noisy_image[:, 0, :, :, :].clone()
            # with torch.no_grad():
                input = self.p_sample(input, torch.full(
                (b,), i, device=device, dtype=torch.long), cond=cond, cond_scale=cond_scale)
            else:
                input = self.p_sample(input, torch.full(
                (b,), i, device=device, dtype=torch.long), cond=cond, cond_scale=cond_scale)

            # if i % 5 == 0 and recurrent[i]!=0 :
            #     recurrent[i] -= 1
            #     with torch.no_grad():
            #         for _ in range(5):
            #             input=self.q_sample_one_step(input, torch.full((b,), i, device=device, dtype=torch.long))
            #             i += 1
            
            i -= 1
        
        return input
    

    @torch.inference_mode()
    def p_sample_loop_v3(self, shape_image, shape_mask, cond=None, cond_scale=1., device=None, image=None):
        b = shape_image[0]
        img = torch.randn(shape_image, device=device)
        mask = torch.randn(shape_mask, device=device)
        input = torch.cat((img, mask), dim=1)

        i = self.num_timesteps - 1
        while i >= 0:
            input = self.p_sample(input, torch.full(
            (b,), i, device=device, dtype=torch.long), cond=cond, cond_scale=cond_scale)
            i -= 1
        
        return input
    
    @torch.inference_mode()
    def p_sample_loop_v3_image_only(self, shape_image, shape_mask, cond=None, cond_scale=1., device=None, image=None):
        b = shape_image[0]
        img = torch.randn(shape_image, device=device)
        input = img

        i = self.num_timesteps - 1
        while i >= 0:
            input = self.p_sample(input, torch.full(
            (b,), i, device=device, dtype=torch.long), cond=cond, cond_scale=cond_scale)
            i -= 1
        
        return input
        # for i in reversed(range(0, self.num_timesteps)):
            
        #     t = torch.full((b,), i, dtype=torch.long, device=device)
        #     real_noisy_image = self.q_sample(x_start=real_img, t=t)
        #     input[:, 0, :, :, :] = real_noisy_image[:, 0, :, :, :].clone()


        #     with torch.no_grad():
        #         input = self.p_sample_v2(input, torch.full(
        #         (b,), i, device=device, dtype=torch.long), cond=cond, cond_scale=cond_scale)
            
        # return input


    # @torch.inference_mode()
    # def p_sample_loop(self, shape, cond=None, cond_scale=1., device=None):
    #     b = shape[0]
    #     img = torch.randn(shape, device=device)
    #     mask = torch.randn(shape, device=device)
    #     input = torch.cat((img, mask), dim=1)
    #     for i in tqdm(reversed(range(0, self.num_timesteps)), desc='sampling loop time step', total=self.num_timesteps):
    #         input = self.p_sample(input, torch.full(
    #             (b,), i, device=device, dtype=torch.long), cond=cond, cond_scale=cond_scale)
    #     return input
    
    # 向原始数据 x_0 添加噪声，生成 x_t 
    def q_sample(self, x_start, t, noise=None):
        noise = default(noise, lambda: torch.randn_like(x_start))
        return (
            extract(self.sqrt_alphas_cumprod, t, x_start.shape) * x_start +
            extract(self.sqrt_one_minus_alphas_cumprod,
                    t, x_start.shape) * noise
        )

    # 对当前样本 x_{t-1} 添加一步噪声，生成 x_t
    # t 是目标时间步
    def q_sample_one_step(self, x_prev, t):
        beta_t = extract(self.betas, t, x_prev.shape)
        alpha_t = 1.0 - beta_t
        sqrt_alpha_t = torch.sqrt(alpha_t)
        sqrt_beta_t = torch.sqrt(beta_t)
        noise = torch.randn_like(x_prev)
        x_t = sqrt_alpha_t * x_prev + sqrt_beta_t * noise
        return x_t
    
    def p_losses(self, x_start, t, mask_start, cond=None, noise_x=None, noise_m=None, **kwargs):
        device = x_start.device
        x_start = x_start.to(device=device, dtype=torch.float32)

        mask_start = mask_start.to(device=device, dtype=torch.float32)

        noise_x = default(noise_x, lambda: torch.randn_like(x_start))
        noise_m = default(noise_m, lambda: torch.randn_like(mask_start))

        x_noisy = self.q_sample(x_start=x_start, t=t, noise=noise_x)
        m_noisy = self.q_sample(x_start=mask_start, t=t, noise=noise_m)
        
        input = torch.cat((x_noisy, m_noisy), dim=1)

        if is_list_str(cond):
            cond = bert_embed(
                tokenize(cond), return_cls_repr=self.text_use_bert_cls)
            cond = cond.to(device)

        recon = self.denoise_fn(**dict(x=input, time=t, cond=cond, **kwargs))
        # print(recon.size())


        
        x_recon = recon[:,0,:,:,:]
        x_recon = x_recon.unsqueeze(1)
        #x_recon = x_recon.squeeze(1)
        m_recon = recon[:,1:(recon.size()[1]),:,:,:]
        #x_recon, m_recon = torch.split(recon, 1, dim=1)
        m_recon = m_recon.squeeze(1)
        # noise_x = noise_x.squeeze(1)
        noise_m = noise_m.squeeze(1)
        # print(noise_x.size())
        # print(x_recon.size())
        # print(noise_m.size())
        # print(m_recon.size())
        # print(m_recon.shape)
        # print(noise_m.shape)
        if self.loss_type == 'l1':
            loss = F.l1_loss(noise_x, x_recon) + F.l1_loss(noise_m, m_recon)
        elif self.loss_type == 'l2':
            loss = F.mse_loss(noise_x, x_recon) + F.mse_loss(noise_m, m_recon)
        else:
            raise NotImplementedError()
        return loss
    
    def p_losses_image_only(self, x_start, t, cond=None, noise_x=None,**kwargs):
        device = x_start.device
        x_start = x_start.to(device=device, dtype=torch.float32)

        noise_x = default(noise_x, lambda: torch.randn_like(x_start))

        x_noisy = self.q_sample(x_start=x_start, t=t, noise=noise_x)
        
        input = x_noisy

        if is_list_str(cond):
            cond = bert_embed(
                tokenize(cond), return_cls_repr=self.text_use_bert_cls)
            cond = cond.to(device)

        recon = self.denoise_fn(**dict(x=input, time=t, cond=cond, **kwargs))

        x_recon = recon
        # x_recon = recon[:,0,:,:,:]
        #x_recon = x_recon.squeeze(1)
        #x_recon, m_recon = torch.split(recon, 1, dim=1)
        # noise_x = noise_x.squeeze(1)
        # print(m_recon.shape)
        # print(noise_m.shape)
        if self.loss_type == 'l1':
            loss = F.l1_loss(noise_x, x_recon)
        elif self.loss_type == 'l2':
            loss = F.mse_loss(noise_x, x_recon)
        else:
            raise NotImplementedError()
        return loss

    def forward(self, x, mask, *args, **kwargs):
        b, device, img_size, = x.shape[0], x.device, self.image_size
        # check_shape(x, 'b c f h w', c=self.channels,
        #             f=self.num_frames, h=img_size, w=img_size)
        t = torch.randint(0, self.num_timesteps, (b,), device=device).long().to(self.device)
        return self.p_losses(**dict(x_start=x, t=t, mask_start=mask, *args, **kwargs))
    
    # def forward(self, x, mask, *args, **kwargs):
    #     b, device, img_size, = x.shape[0], x.device, self.image_size
    #     # check_shape(x, 'b c f h w', c=self.channels,
    #     #             f=self.num_frames, h=img_size, w=img_size)
    #     t = torch.randint(0, self.num_timesteps, (b,), device=device).long().to(self.device)
    #     return self.p_losses_image_only(**dict(x_start=x, t=t, *args, **kwargs))

    # @torch.inference_mode()
    def p_sample_loop_guidance(self, shape_image, shape_mask, cond=None, cond_scale=1., device=None, image=None, degrade_mask=None, delta=1.5):
        if degrade_mask is None: # default is all 1
            degrade_mask = torch.ones(shape_image, device=device)
        degrade_mask = degrade_mask.to(device=device, dtype=torch.float32)
        device = self.betas.device
        b = shape_image[0]
        init_noise = torch.randn_like(image)
        step_noise_list = []
        for step in range(self.num_timesteps):
            t = torch.full((image.shape[0],), step, device=device, dtype=torch.long)
            step_noise = self.q_sample(image, t, noise=init_noise)
            step_noise_list.append(step_noise)
        img_noisy = torch.stack(step_noise_list)  # [T, B, C, D, H, W]
        
        img = torch.randn(shape_image, device=device)
        mask = torch.randn(shape_mask, device=device)
        pair = torch.cat((img, mask), dim=1)

        TCOUNT = 2 # 2
        RSTEP = 1  # 10
        GRAD_STEP = 3 # 7
        print(f'TCOUNT: {TCOUNT}, RSTEP: {RSTEP}, GRAD_STEP: {GRAD_STEP}')
        recurrent = [0] * self.num_timesteps
        for i in range(self.num_timesteps):
            if i % RSTEP == 0:
                recurrent[i] = TCOUNT
        i = self.num_timesteps - 1

        print('degrade_mask_sum_check:', degrade_mask.sum().item())
        while i >= 0:
            # real_noisy_image = self.q_sample(x_start=image, t=t)
            pair[:, :1] = img_noisy[i] * degrade_mask + pair[:, :1] * (1 - degrade_mask)
            # pair[:, :1] = img_noisy[i]
            pair = pair.clone().detach()
            for g in range(GRAD_STEP):
                # break
                if i > 150:
                    break
                with torch.enable_grad():
                    pair_with_grad = pair.detach().clone().requires_grad_(True)
                    t = torch.full((b,), i, device=device, dtype=torch.long)
                    self.loss_type = 'l1'
                    loss = self.p_losses_guidance(pair_with_grad, t, init_noise, degrade_mask=degrade_mask)
                    print('t:', i, 'g', g, 'loss:', loss.item())
                    grad = torch.autograd.grad(loss, pair_with_grad)[0]
                    grad[:, :1] = grad[:, :1] * (1 - degrade_mask) 
                    grad_norm = grad.flatten(start_dim=1).norm( dim=1, keepdim=True).unsqueeze(-1).unsqueeze(-1).unsqueeze(-1)
                    grad = grad / (grad_norm + 1e-8)
                    pair = pair - grad * delta

            t = torch.full((b,), i, device=device, dtype=torch.long)
            pair = self.p_sample(pair, t, cond=cond, cond_scale=cond_scale).clone()

            # if recurrent[i] > 0 and i % RSTEP == 0:
            #     recurrent[i] -= 1
            #     for _ in range(RSTEP):
            #         with torch.no_grad():
            #             t = torch.full((b,), i, device=device, dtype=torch.long)
            #             pair = self.q_sample_one_step(pair, t)
            #         i += 1
            #         if i >= self.num_timesteps:
            #             break
            
            
            
            i -= 1

        return pair


    def p_losses_guidance(self, pair_noisy, t, noise, cond=None, degrade_mask=None, **kwargs):
        device = pair_noisy.device

        if is_list_str(cond):
            cond = bert_embed(
                tokenize(cond), return_cls_repr=self.text_use_bert_cls)
            cond = cond.to(device)

        x_recon = self.denoise_fn(pair_noisy, t, cond=cond, **kwargs)[:, :1]

        if degrade_mask is not None:
            x_recon = x_recon * degrade_mask
            noise = noise * degrade_mask
        
        if self.loss_type == 'l1':
            loss = F.l1_loss(noise, x_recon, reduction='sum')
        elif self.loss_type == 'l2':
            loss = F.mse_loss(noise, x_recon, reduction='sum')
        else:
            raise NotImplementedError()

        if degrade_mask is not None:
            loss = loss / degrade_mask.sum()
        else:
            loss = loss / noise.numel()

        return loss


    def p_sample_loop_universal_guidance(
        self,
        shape_image,
        shape_mask,
        cond=None,
        cond_scale=1.,
        device=None,
        image=None,
        degrade_mask=None,
        num_guidance_steps=3,
        guidance_scale=1.5,
        guidance_start_t=-1,
        recurrent_steps=1,
        loss_type='l1',
        use_ddim=True,
        ddim_steps=50,
        ddim_eta=0.0,
        guidance_strategy='equal_distance',
        proc=True,
    ):
        """
        Universal guidance for continuous diffusion model supporting both DDPM and DDIM.
        
        This function performs gradient-based guidance to match the degraded region of the
        predicted clean image with the real clean image.
        
        Args:
            shape_image: Shape of image to generate
            shape_mask: Shape of mask to generate
            cond: Optional conditioning
            cond_scale: Conditioning scale
            device: Device to use
            image: Real clean image (ground truth for degraded region)
            degrade_mask: Binary mask indicating degraded region (1=degraded, 0=clean)
            num_guidance_steps: Number of gradient descent iterations per guided timestep
            guidance_scale: Step size for gradient descent (delta)
            guidance_start_t: Number of timesteps/steps to apply guidance
            recurrent_steps: Number of denoise-renoise cycles per timestep (DDPM and DDIM)
            loss_type: 'l1' or 'l2' for guidance loss
            use_ddim: Whether to use DDIM sampling instead of DDPM
            ddim_steps: Number of steps for DDIM sampling
            ddim_eta: Stochasticity parameter for DDIM (0=deterministic, 1=DDPM-like)
            guidance_strategy: 'last_n' or 'equal_distance' - how to distribute guidance steps
            proc: Whether to show progress bar
            
        Returns:
            Generated pair (image + mask concatenated)
        """
        if degrade_mask is None:
            degrade_mask = torch.ones(shape_image, device=device)
        degrade_mask = degrade_mask.to(device=device, dtype=torch.float32)
        device = self.betas.device
        b = shape_image[0]
        
        # Pre-compute noisy versions of input image at all timesteps (for replacement strategy)
        init_noise = torch.randn_like(image)
        step_noise_list = []
        for step in range(self.num_timesteps):
            t = torch.full((image.shape[0],), step, device=device, dtype=torch.long)
            step_noise = self.q_sample(image, t, noise=init_noise)
            step_noise_list.append(step_noise)
        img_noisy = torch.stack(step_noise_list)  # [T, B, C, D, H, W]
        
        # Initialize random samples
        img = torch.randn(shape_image, device=device)
        mask = torch.randn(shape_mask, device=device)
        pair = torch.cat((img, mask), dim=1)
        
        if use_ddim:
            # DDIM sampling with universal guidance
            return self._ddim_sample_universal_guidance(
                pair=pair,
                img_noisy=img_noisy,
                real_image=image,
                degrade_mask=degrade_mask,
                cond=cond,
                cond_scale=cond_scale,
                num_guidance_steps=num_guidance_steps,
                guidance_scale=guidance_scale,
                guidance_start_t=guidance_start_t,
                recurrent_steps=recurrent_steps,
                loss_type=loss_type,
                ddim_steps=ddim_steps,
                ddim_eta=ddim_eta,
                guidance_strategy=guidance_strategy,
                proc=proc,
            )
        else:
            # DDPM sampling with universal guidance
            return self._ddpm_sample_universal_guidance(
                pair=pair,
                img_noisy=img_noisy,
                real_image=image,
                degrade_mask=degrade_mask,
                cond=cond,
                cond_scale=cond_scale,
                num_guidance_steps=num_guidance_steps,
                guidance_scale=guidance_scale,
                guidance_start_t=guidance_start_t,
                recurrent_steps=recurrent_steps,
                loss_type=loss_type,
                guidance_strategy=guidance_strategy,
                proc=proc,
            )


    def _ddpm_sample_universal_guidance(
        self,
        pair,
        img_noisy,
        real_image,
        degrade_mask,
        cond,
        cond_scale,
        num_guidance_steps,
        guidance_scale,
        guidance_start_t,
        recurrent_steps,
        loss_type,
        guidance_strategy,
        proc,
    ):
        """DDPM sampling with universal guidance."""
        device = pair.device
        b = pair.shape[0]
        
        # Build guidance schedule
        guidance_schedule = self._build_guidance_schedule(
            total_steps=self.num_timesteps,
            num_guidance=guidance_start_t,
            strategy=guidance_strategy,
        )
        
        print(f'DDPM Universal Guidance Config:')
        print(f'  num_guidance_steps: {num_guidance_steps}')
        print(f'  recurrent_steps: {recurrent_steps}')
        print(f'  guidance_scale: {guidance_scale}')
        print(f'  guidance_start_t: {guidance_start_t}')
        print(f'  guidance_strategy: {guidance_strategy}')
        print(f'  loss_type: {loss_type}')
        print(f'  degrade_mask sum: {degrade_mask.sum().item()}')
        print(f'  guidance at {len(guidance_schedule)} timesteps: {sorted(list(guidance_schedule))[:10]}{"..." if len(guidance_schedule) > 10 else ""}')
        
        iterator = range(self.num_timesteps - 1, -1, -1)
        if proc:
            from tqdm import tqdm
            iterator = tqdm(iterator, desc='DDPM + Universal Guidance', leave=False)
        
        for i in iterator:
            t = torch.full((b,), i, device=device, dtype=torch.long)
            
            # Replace degraded region with noisy ground truth
            pair[:, :1] = img_noisy[i] * degrade_mask + pair[:, :1] * (1 - degrade_mask)
            
            # Apply guidance if this timestep is in the schedule
            if i in guidance_schedule:
                pair = pair.clone().detach()
                
                for recurrent_idx in range(recurrent_steps):
                    # Gradient descent iterations
                    for g in range(num_guidance_steps):
                        with torch.enable_grad():
                            pair_with_grad = pair.detach().clone().requires_grad_(True)
                            
                            # Compute guidance loss
                            loss = self._compute_guidance_loss(
                                pair_with_grad,
                                t,
                                real_image,
                                degrade_mask,
                                loss_type,
                                cond,
                            )
                            
                            if (i % 10 == 0 or i < 3) and g == 0 and recurrent_idx == 0:
                                print(f'  t={i}: loss={loss.item():.6f}')
                            
                            # Compute gradient
                            grad = torch.autograd.grad(loss, pair_with_grad)[0]
                            
                            # Only apply gradient to non-degraded region of image channel
                            grad[:, :1] = grad[:, :1] * (1 - degrade_mask)
                            
                            # Normalize gradient
                            grad_norm = grad.flatten(start_dim=1).norm(dim=1, keepdim=True)
                            grad_norm = grad_norm.unsqueeze(-1).unsqueeze(-1).unsqueeze(-1)
                            grad = grad / (grad_norm + 1e-8)
                            
                            # Update pair
                            pair = pair - grad * guidance_scale
                    
                    # Recurrent refinement: denoise one step and add noise back
                    # (Only if not the last recurrent step)
                    if recurrent_idx < recurrent_steps - 1 and i > 0:
                        with torch.no_grad():
                            # Denoise one step
                            pair = self.p_sample(pair, t, cond=cond, cond_scale=cond_scale)
                            
                            # Add noise back: x_{t-1} → x_t
                            pair = self.q_sample_one_step(pair, t)
            
            # Standard denoising step
            with torch.no_grad():
                pair = self.p_sample(pair, t, cond=cond, cond_scale=cond_scale).clone()
        
        return pair


    def _ddim_sample_universal_guidance(
        self,
        pair,
        img_noisy,
        real_image,
        degrade_mask,
        cond,
        cond_scale,
        num_guidance_steps,
        guidance_scale,
        guidance_start_t,
        recurrent_steps,
        loss_type,
        ddim_steps,
        ddim_eta,
        guidance_strategy,
        proc,
    ):
        """DDIM sampling with universal guidance."""
        device = pair.device
        b = pair.shape[0]
        
        # Build DDIM timestep schedule
        step = self.num_timesteps // ddim_steps
        timesteps = torch.arange(0, self.num_timesteps, step, device=device).long()
        timesteps = torch.flip(timesteps, dims=[0])  # Reverse for denoising
        
        # Build guidance schedule based on DDIM steps
        guidance_schedule = self._build_guidance_schedule(
            total_steps=len(timesteps),
            num_guidance=guidance_start_t,
            strategy=guidance_strategy,
        )
        
        print(f'DDIM Universal Guidance Config:')
        print(f'  ddim_steps: {ddim_steps}')
        print(f'  num_guidance_steps: {num_guidance_steps}')
        print(f'  recurrent_steps: {recurrent_steps}')
        print(f'  guidance_scale: {guidance_scale}')
        print(f'  guidance_start_t: {guidance_start_t}')
        print(f'  guidance_strategy: {guidance_strategy}')
        print(f'  ddim_eta: {ddim_eta}')
        print(f'  loss_type: {loss_type}')
        print(f'  degrade_mask sum: {degrade_mask.sum().item()}')
        print(f'  guidance at {len(guidance_schedule)} DDIM steps (indices): {sorted(list(guidance_schedule))[:10]}{"..." if len(guidance_schedule) > 10 else ""}')
        
        iterator = enumerate(timesteps.tolist())
        if proc:
            from tqdm import tqdm
            iterator = enumerate(tqdm(timesteps.tolist(), desc='DDIM + Universal Guidance', leave=False))
        
        for idx, t_val in iterator:
            t = torch.full((b,), t_val, device=device, dtype=torch.long)
            
            # Determine next timestep
            if idx + 1 < len(timesteps):
                t_next = timesteps[idx + 1]
            else:
                t_next = torch.tensor(-1, device=device)
            
            # Replace degraded region with noisy ground truth before guidance
            pair[:, :1] = img_noisy[t_val] * degrade_mask + pair[:, :1] * (1 - degrade_mask)
            
            # Apply guidance if this DDIM step index is in the schedule
            if idx in guidance_schedule:
                pair = pair.clone().detach()
                
                for recurrent_idx in range(recurrent_steps):
                    # Gradient descent iterations
                    for g in range(num_guidance_steps):
                        with torch.enable_grad():
                            pair_with_grad = pair.detach().clone().requires_grad_(True)
                            
                            # Compute guidance loss
                            loss = self._compute_guidance_loss(
                                pair_with_grad,
                                t,
                                real_image,
                                degrade_mask,
                                loss_type,
                                cond,
                            )
                            
                            if (idx % 5 == 0 or idx < 3) and g == 0 and recurrent_idx == 0:
                                print(f'  DDIM step {idx} (t={t_val}): loss={loss.item():.6f}')
                            
                            # Compute gradient
                            grad = torch.autograd.grad(loss, pair_with_grad)[0]
                            
                            # Only apply gradient to non-degraded region of image channel
                            grad[:, :1] = grad[:, :1] * (1 - degrade_mask)
                            
                            # Normalize gradient
                            grad_norm = grad.flatten(start_dim=1).norm(dim=1, keepdim=True)
                            grad_norm = grad_norm.unsqueeze(-1).unsqueeze(-1).unsqueeze(-1)
                            grad = grad / (grad_norm + 1e-8)
                            
                            # Update pair
                            pair = pair - grad * guidance_scale
                    
                    # Recurrent refinement: DDIM step and add noise back
                    # (Only if not the last recurrent step and not the final timestep)
                    if recurrent_idx < recurrent_steps - 1 and t_next >= 0:
                        with torch.no_grad():
                            # Apply one DDIM denoising step
                            pair_denoised = self._ddim_step(
                                pair,
                                t,
                                t_next,
                                cond=cond,
                                cond_scale=cond_scale,
                                eta=ddim_eta,
                            )
                            
                            # Re-noise back to current timestep t using DDIM forward process
                            # q(x_t | x_{t-1}) for DDIM: deterministically add noise back
                            alpha_t = extract(self.alphas_cumprod, t, pair.shape)
                            alpha_t_next = extract(self.alphas_cumprod, t_next.expand(pair.shape[0]), pair.shape)
                            
                            # Predict x0 from denoised sample at t_next
                            noise_pred = self.denoise_fn(pair_denoised, t_next.expand(b), cond=cond)[:, :pair.shape[1]]
                            x0_from_denoised = (pair_denoised - torch.sqrt(1 - alpha_t_next) * noise_pred) / torch.sqrt(alpha_t_next)
                            
                            # Re-noise to timestep t: x_t = sqrt(alpha_t) * x0 + sqrt(1-alpha_t) * noise
                            noise = torch.randn_like(pair)
                            pair = torch.sqrt(alpha_t) * x0_from_denoised + torch.sqrt(1 - alpha_t) * noise
            
            # Replace degraded region with noisy ground truth after guidance
            pair[:, :1] = img_noisy[t_val] * degrade_mask + pair[:, :1] * (1 - degrade_mask)
            
            # DDIM denoising step
            with torch.no_grad():
                pair = self._ddim_step(
                    pair,
                    t,
                    t_next,
                    cond=cond,
                    cond_scale=cond_scale,
                    eta=ddim_eta,
                )
        
        return pair


    def _compute_guidance_loss(
        self,
        pair_noisy,
        t,
        real_image,
        degrade_mask,
        loss_type,
        cond,
    ):
        """
        Compute guidance loss for universal guidance.
        
        The loss is the L1/L2 distance between:
        - degrade_mask * predicted clean image
        - degrade_mask * real clean image
        """
        device = pair_noisy.device
        
        # Predict noise from the noisy pair
        noise_pred = self.denoise_fn(pair_noisy, t, cond=cond)[:, :1]
        
        # Predict clean image (x_0) from noise prediction
        # x_0 = (x_t - sqrt(1-alpha_t) * noise) / sqrt(alpha_t)
        x0_pred = self.predict_start_from_noise(pair_noisy[:, :1], t, noise_pred)
        
        # Apply mask to both predicted and real clean images
        if degrade_mask is not None:
            x0_pred_masked = x0_pred * degrade_mask
            real_image_masked = real_image * degrade_mask
        else:
            x0_pred_masked = x0_pred
            real_image_masked = real_image
        
        # Compute loss between masked regions
        if loss_type == 'l1':
            loss = F.l1_loss(x0_pred_masked, real_image_masked, reduction='sum')
        elif loss_type == 'l2':
            loss = F.mse_loss(x0_pred_masked, real_image_masked, reduction='sum')
        else:
            raise NotImplementedError(f'Unknown loss type: {loss_type}')
        
        # Normalize by mask size
        if degrade_mask is not None:
            loss = loss / degrade_mask.sum().clamp(min=1.0)
        else:
            loss = loss / real_image_masked.numel()
        
        return loss


    def _ddim_step(self, x, t, t_next, cond=None, cond_scale=1., eta=0.0):
        """
        Single DDIM denoising step.
        
        Args:
            x: Current noisy sample
            t: Current timestep tensor
            t_next: Next timestep (scalar tensor or -1 for final step)
            cond: Optional conditioning
            cond_scale: Conditioning scale
            eta: Stochasticity parameter (0=deterministic, 1=DDPM-like)
        """
        # Predict noise
        noise_pred = self.denoise_fn(x, t, cond=cond)
        
        # Apply classifier-free guidance if cond_scale != 1
        if cond is not None and cond_scale != 1.:
            noise_pred_uncond = self.denoise_fn(x, t, cond=None)
            noise_pred = noise_pred_uncond + cond_scale * (noise_pred - noise_pred_uncond)
        
        # Extract coefficients
        alpha_t = extract(self.alphas_cumprod, t, x.shape)
        
        if t_next >= 0:
            alpha_t_next = extract(self.alphas_cumprod, t_next.expand(x.shape[0]), x.shape)
        else:
            alpha_t_next = torch.ones_like(alpha_t)
        
        # Predict x0
        pred_x0 = (x - torch.sqrt(1 - alpha_t) * noise_pred) / torch.sqrt(alpha_t)
        
        # Compute direction pointing to x_t
        sigma_t = eta * torch.sqrt((1 - alpha_t_next) / (1 - alpha_t) * (1 - alpha_t / alpha_t_next))
        
        # Compute x_{t-1}
        dir_xt = torch.sqrt(1 - alpha_t_next - sigma_t ** 2) * noise_pred
        
        if t_next >= 0:
            noise = torch.randn_like(x)
            x_next = torch.sqrt(alpha_t_next) * pred_x0 + dir_xt + sigma_t * noise
        else:
            x_next = torch.sqrt(alpha_t_next) * pred_x0 + dir_xt
        
        return x_next


    def _build_guidance_schedule(self, total_steps, num_guidance, strategy='last_n'):
        """
        Build a set of step indices where guidance should be applied.
        
        Args:
            total_steps: Total number of denoising steps
            num_guidance: Number of steps to apply guidance
            strategy: 'last_n' or 'equal_distance'
                - 'last_n': Apply guidance at the last N steps (smallest timesteps)
                - 'equal_distance': Distribute N guidance steps evenly across all steps
        
        Returns:
            Set of step indices where guidance should be applied
        """
        num_guidance = min(num_guidance, total_steps)
        
        if strategy == 'last_n':
            # For DDPM iterating t from (total_steps-1) down to 0:
            # Last N steps means the smallest timestep values: {0, 1, ..., N-1}
            return set(range(num_guidance))
        
        elif strategy == 'equal_distance':
            # Distribute guidance steps evenly across the timeline
            if num_guidance == 0:
                return set()
            if num_guidance >= total_steps:
                return set(range(total_steps))
            
            # Calculate spacing
            spacing = total_steps / num_guidance
            indices = []
            for i in range(num_guidance):
                idx = int(i * spacing)
                indices.append(idx)
            
            return set(indices)
        
        else:
            raise ValueError(f"Unknown guidance strategy: {strategy}. Use 'last_n' or 'equal_distance'")


    def p_sample_loop_gen(self, shape_image, shape_mask, cond=None, cond_scale=1., device=None, mask=None, degrade_mask=None):
        if degrade_mask is None: # default is all 1
            degrade_mask = torch.ones(shape_image, device=device)
        degrade_mask = degrade_mask.to(device=device, dtype=torch.float32)
        device = self.betas.device
        b = shape_image[0]
        init_noise = torch.randn_like(mask)
        step_noise_list = []
        for step in range(self.num_timesteps):
            t = torch.full((mask.shape[0],), step, device=device, dtype=torch.long)
            step_noise = self.q_sample(mask, t, noise=init_noise)
            step_noise_list.append(step_noise)
        mask_noisy = torch.stack(step_noise_list)  # [T, B, C, D, H, W]
        
        img = torch.randn(shape_image, device=device)
        mask = torch.randn(shape_mask, device=device)
        pair = torch.cat((img, mask), dim=1)
        # print(shape_mask)

        TCOUNT = 2 # 2
        RSTEP = 1  # 10
        GRAD_STEP = 0 # 7
        print(f'TCOUNT: {TCOUNT}, RSTEP: {RSTEP}, GRAD_STEP: {GRAD_STEP}')
        recurrent = [0] * self.num_timesteps
        for i in range(self.num_timesteps):
            if i % RSTEP == 0:
                recurrent[i] = TCOUNT
        i = self.num_timesteps - 1

        while i >= 0:
            # real_noisy_mask = self.q_sample(x_start=mask, t=t)
            pair[:, 1:] = mask_noisy[i] * degrade_mask + pair[:, 1:] * (1 - degrade_mask)
            pair = pair.clone().detach()
            for g in range(GRAD_STEP):
                if i > 10:
                    break
                with torch.enable_grad():
                    pair_with_grad = pair.detach().clone().requires_grad_(True)
                    t = torch.full((b,), i, device=device, dtype=torch.long)
                    self.loss_type = 'l1'
                    loss = self.p_losses_guidance_gen(pair_with_grad, t, init_noise, degrade_mask=degrade_mask)
                    print('t:', i, 'g', g, 'loss:', loss.item())
                    grad = torch.autograd.grad(loss, pair_with_grad)[0][:, :1]
                    grad_norm = grad.flatten(start_dim=1).norm( dim=1, keepdim=True).unsqueeze(-1).unsqueeze(-1).unsqueeze(-1)
                    grad = grad / (grad_norm + 1e-8)
                    pair[:, :1]  = pair[:, :1] - grad * 0.5

            t = torch.full((b,), i, device=device, dtype=torch.long)
            pair = self.p_sample(pair, t, cond=cond, cond_scale=cond_scale).clone()

            # if recurrent[i] > 0 and i % RSTEP == 0:
            #     recurrent[i] -= 1
            #     for _ in range(RSTEP):
            #         with torch.no_grad():
            #             t = torch.full((b,), i, device=device, dtype=torch.long)
            #             pair = self.q_sample_one_step(pair, t)
            #         i += 1
            #         if i >= self.num_timesteps:
            #             break
            
            
            
            i -= 1

        return pair

    def p_losses_guidance_gen(self, pair_noisy, t, noise, cond=None, degrade_mask=None, **kwargs):
        device = pair_noisy.device

        if is_list_str(cond):
            cond = bert_embed(
                tokenize(cond), return_cls_repr=self.text_use_bert_cls)
            cond = cond.to(device)

        x_recon = self.denoise_fn(pair_noisy, t, cond=cond, **kwargs)[:, 1:]
        
        if self.loss_type == 'l1':
            loss = F.l1_loss(noise, x_recon, reduction='sum')
        elif self.loss_type == 'l2':
            loss = F.mse_loss(noise, x_recon, reduction='sum')
        else:
            raise NotImplementedError()

        if degrade_mask is not None:
            loss = loss / degrade_mask.sum()
        else:
            loss = loss / noise.numel()

        return loss




class Trainer(object):
    def __init__(
        self,
        diffusion_model,
        cfg,
        dataset=None,
        *,
        ema_decay=0.995,
        train_batch_size=32,
        train_lr=1e-4,
        train_num_steps=100000,
        gradient_accumulate_every=2,
        amp=False,
        step_start_ema=2000,
        update_ema_every=10,
        save_and_sample_every=1000,
        results_folder='./results',
        max_grad_norm=None,
        num_workers=4,
        device=None,
    ):
        super().__init__()
        self.model = diffusion_model
        self.ema = EMA(ema_decay)
        self.ema_model = copy.deepcopy(self.model)
        self.update_ema_every = update_ema_every

        self.step_start_ema = step_start_ema
        self.save_and_sample_every = save_and_sample_every

        self.batch_size = train_batch_size
        self.image_size = diffusion_model.image_size
        self.gradient_accumulate_every = gradient_accumulate_every
        self.train_num_steps = train_num_steps
        self.device = device

        self.cfg = cfg

        self.ds = dataset
        dl = DataLoader(self.ds, batch_size=train_batch_size,
                        shuffle=True, pin_memory=True, num_workers=num_workers)

        self.len_dataloader = len(dl)
        print("len_dl ", len(dl))
        self.dl = cycle(dl)

        print(f'found {len(self.ds)} videos as gif files')
        assert len(
            self.ds) > 0, 'need to have at least 1 video to start training (although 1 is not great, try 100k)'

        self.opt = Adam(diffusion_model.parameters(), lr=train_lr)

        self.step = 0

        self.amp = amp
        self.scaler = GradScaler(enabled=amp)
        self.max_grad_norm = max_grad_norm

        self.results_folder = Path(results_folder)
        self.results_folder.mkdir(exist_ok=True, parents=True)

        self.reset_parameters()

    def reset_parameters(self):
        self.ema_model.load_state_dict(self.model.state_dict())

    def step_ema(self):
        if self.step < self.step_start_ema:
            self.reset_parameters()
            return
        self.ema.update_model_average(self.ema_model, self.model)

    def save(self, milestone):
        data = {
            'step': self.step,
            'model': self.model.state_dict(),
            'ema': self.ema_model.state_dict(),
            'scaler': self.scaler.state_dict(),
            'optimizer': self.opt.state_dict()  # 保存优化器状态
        }
        torch.save(data, str(self.results_folder / f'model-{milestone}.pt'))

    def load(self, milestone, map_location=None, **kwargs):
        if milestone == -1:
            all_milestones = [int(p.stem.split('-')[-1])
                              for p in Path(self.results_folder).glob('**/*.pt')]
            assert len(
                all_milestones) > 0, 'need to have at least one milestone to load from latest checkpoint (milestone == -1)'
            milestone = max(all_milestones)
        
        if map_location:
            data = torch.load(milestone, map_location=map_location)
        else:
            import os
            data = torch.load(os.path.join(self.results_folder, f'model-{milestone}.pt'))

        self.step = data['step']
        self.model.load_state_dict(data['model'], **kwargs)
        self.ema_model.load_state_dict(data['ema'], **kwargs)
        self.scaler.load_state_dict(data['scaler'])
        self.opt.load_state_dict(data['optimizer'])

    def train(
        self,
        prob_focus_present=0.,
        focus_present_mask=None,
        log_fn=noop
    ):
        assert callable(log_fn)

        while self.step < self.train_num_steps:
            for i in range(self.gradient_accumulate_every):

                data_frame = next(self.dl)
                data = data_frame['img'].to(self.device)
                mask_sdf = data_frame['mask_sdf'].to(self.device)
                # print("Mask Sum: ", mask.sum())
                # print(data_frame['name'])

                with autocast(enabled=self.amp):

                    loss = self.model(**dict(
                        x=data,
                        mask=mask_sdf,
                        prob_focus_present=prob_focus_present,
                        focus_present_mask=focus_present_mask)
                    )

                    self.scaler.scale(
                            loss / self.gradient_accumulate_every).backward()

                print(f'{self.step}: {loss.item()}')

            log = {'loss': loss.item()}

            if exists(self.max_grad_norm):
                self.scaler.unscale_(self.opt)
                nn.utils.clip_grad_norm_(
                    self.model.parameters(), self.max_grad_norm)

            self.scaler.step(self.opt)
            self.scaler.update()
            self.opt.zero_grad()

            if self.step % self.update_ema_every == 0:
                self.step_ema()

            if self.step != 0 and self.step % self.save_and_sample_every == 0:
                self.ema_model.eval()
                with torch.no_grad():
                    milestone = self.step // self.save_and_sample_every
                self.save(milestone)

            log_fn(log)
            self.step += 1
            
            

        print('training completed')


# _extract_into_tensor 函数的作用是从一个给定的数组（arr）中提取与时间步（timesteps）相对应的值，
# 并将这些值广播成指定的形状（broadcast_shape）。
# 该函数主要用于处理扩散模型中的参数提取和广播操作，确保不同时间步的参数能够与图像数据进行匹配
def _extract_into_tensor(arr, timesteps, broadcast_shape):
 
    res = arr[timesteps].float()

    while len(res.shape) < len(broadcast_shape):
        res = res[..., None]
    return res.expand(broadcast_shape)