DiffAtlas-2shot/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 = 5
        T = 5
        recurrent = [0] * self.num_timesteps
        for i in range(self.num_timesteps):
            if i % R == 0:
                recurrent[i] = T
        
        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 % R == 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 p_sample_loop_guidance(self, shape_image, shape_mask, cond=None, cond_scale=1., device=None, image=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(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 = 10 # 7
        WEIGHT = 0.2
        GUIDANCE_STEP = 300
        print(f'TCOUNT: {TCOUNT}, RSTEP: {RSTEP}, GRAD_STEP: {GRAD_STEP}, WEIGHT: {WEIGHT}, GUIDACE_SETP: {GUIDANCE_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_image = self.q_sample(x_start=image, t=t)
            pair[:, :1] = img_noisy[i] * degrade_mask + pair[:, :1] * (1 - degrade_mask)
            pair = pair.clone().detach()
            for g in range(GRAD_STEP):
                if i > GUIDANCE_STEP:
                    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][:, 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 * WEIGHT

            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 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 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))


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)