1{
2  "op": "replace",
3  "filename": "CFGpp-main/latent_diffusion.py",
4  "start_line": 621,
5  "end_line": 679,
6  "content": "@register_solver(\"ddim_cfg++\")\nclass BaseDDIMCFGpp(StableDiffusion):\n    \"\"\"\n    Rescaled CFG with Asymmetric Leaky Renoising (RCFG-AL).\n    \n    Novel contribution: Combines three synergistic modifications:\n    1. Rescaled CFG (std-normalization) for the Tweedie denoising step to get\n       strong text alignment without oversaturation artifacts.\n    2. CFG++ asymmetric renoising with a small \"guidance leak\" - uses mostly\n       noise_uc for manifold-staying but bleeds in a fraction of the guidance\n       direction to maintain text-conditional trajectory coherence.\n    3. Timestep-adaptive rescaling: stronger rescaling at high noise levels\n       where oversaturation is most problematic, weaker at low noise levels\n       where fine details need full guidance signal.\n    \"\"\"\n    def __init__(self,\n                 solver_config: Dict,\n                 model_key:str=\"runwayml/stable-diffusion-v1-5\",\n                 device: Optional[torch.device]=None,\n                 **kwargs):\n        super().__init__(solver_config, model_key, device, **kwargs)\n\n    @torch.autocast(device_type='cuda', dtype=torch.float16)\n    def sample(self,\n               cfg_guidance=7.5,\n               prompt=[\"\",\"\"],\n               callback_fn=None,\n               **kwargs):\n\n        # Text embedding\n        uc, c = self.get_text_embed(null_prompt=prompt[0], prompt=prompt[1])\n\n        # Initialize zT\n        zt = self.initialize_latent()\n        zt = zt.requires_grad_()\n\n        # Hyperparameters for RCFG-AL\n        rescale_phi = 0.7       # Base rescaling interpolation factor\n        renoise_leak = 0.05     # Guidance leak into renoising step\n\n        total_steps = len(self.scheduler.timesteps)\n\n        # Sampling\n        pbar = tqdm(self.scheduler.timesteps, desc=\"SD\")\n        for step, t in enumerate(pbar):\n            at = self.alpha(t)\n            at_prev = self.alpha(t - self.skip)\n\n            with torch.no_grad():\n                noise_uc, noise_c = self.predict_noise(zt, t, uc, c)\n\n                # Guidance direction\n                noise_delta = noise_c - noise_uc\n\n                # Standard CFG guided prediction\n                noise_guided = noise_uc + cfg_guidance * noise_delta\n\n                # Rescaled CFG: normalize std to match conditional prediction\n                # This prevents oversaturation at high guidance scales\n                std_guided = noise_guided.std(dim=[1, 2, 3], keepdim=True)\n                std_cond = noise_c.std(dim=[1, 2, 3], keepdim=True)\n                noise_rescaled = noise_guided * (std_cond / (std_guided + 1e-8))\n\n                # Timestep-adaptive rescaling: stronger at high t, weaker at low t\n                progress = step / max(total_steps - 1, 1)  # 0 -> 1\n                adaptive_phi = rescale_phi * (1.0 - 0.5 * progress)\n                noise_pred = adaptive_phi * noise_rescaled + (1 - adaptive_phi) * noise_guided\n\n            # Tweedie denoising\n            z0t = (zt - (1 - at).sqrt() * noise_pred) / at.sqrt()\n\n            # Asymmetric renoising: CFG++ with small guidance leak\n            noise_renoise = noise_uc + renoise_leak * noise_delta\n            zt = at_prev.sqrt() * z0t + (1 - at_prev).sqrt() * noise_renoise\n\n            if callback_fn is not None:\n                callback_kwargs = {'z0t': z0t.detach(),\n                                   'zt': zt.detach(),\n                                   'decode': self.decode}\n                callback_kwargs = callback_fn(step, t, callback_kwargs)\n                z0t = callback_kwargs[\"z0t\"]\n                zt = callback_kwargs[\"zt\"]\n\n        # for the last step, do not add noise\n"
7}

1{
2  "op": "replace",
3  "filename": "CFGpp-main/latent_diffusion.py",
4  "start_line": 624,
5  "end_line": 682,
6  "content": "    # Rescaled CFG with Asymmetric Leaky Renoising (RCFG-AL).\n    #\n    # Novel contribution: Combines three synergistic modifications:\n    # 1. Rescaled CFG (std-normalization) for the Tweedie denoising step\n    # 2. CFG++ asymmetric renoising with a small \"guidance leak\"\n    # 3. Timestep-adaptive rescaling factor\n\n    def __init__(self,\n                 solver_config: Dict,\n                 model_key:str=\"runwayml/stable-diffusion-v1-5\",\n                 device: Optional[torch.device]=None,\n                 **kwargs):\n        super().__init__(solver_config, model_key, device, **kwargs)\n\n    @torch.autocast(device_type='cuda', dtype=torch.float16)\n    def sample(self,\n               cfg_guidance=7.5,\n               prompt=[\"\",\"\"],\n               callback_fn=None,\n               **kwargs):\n\n        # Text embedding\n        uc, c = self.get_text_embed(null_prompt=prompt[0], prompt=prompt[1])\n\n        # Initialize zT\n        zt = self.initialize_latent()\n        zt = zt.requires_grad_()\n\n        # Hyperparameters for RCFG-AL\n        rescale_phi = 0.7       # Base rescaling interpolation factor\n        renoise_leak = 0.05     # Guidance leak into renoising step\n\n        total_steps = len(self.scheduler.timesteps)\n\n        # Sampling\n        pbar = tqdm(self.scheduler.timesteps, desc=\"SD\")\n        for step, t in enumerate(pbar):\n            at = self.alpha(t)\n            at_prev = self.alpha(t - self.skip)\n\n            with torch.no_grad():\n                noise_uc, noise_c = self.predict_noise(zt, t, uc, c)\n\n                # Guidance direction\n                noise_delta = noise_c - noise_uc\n\n                # Standard CFG guided prediction\n                noise_guided = noise_uc + cfg_guidance * noise_delta\n\n                # Rescaled CFG: normalize std to match conditional prediction\n                std_guided = noise_guided.std(dim=[1, 2, 3], keepdim=True)\n                std_cond = noise_c.std(dim=[1, 2, 3], keepdim=True)\n                noise_rescaled = noise_guided * (std_cond / (std_guided + 1e-8))\n\n                # Timestep-adaptive rescaling: stronger at high t, weaker at low t\n                progress = step / max(total_steps - 1, 1)  # 0 -> 1\n                adaptive_phi = rescale_phi * (1.0 - 0.5 * progress)\n                noise_pred = adaptive_phi * noise_rescaled + (1 - adaptive_phi) * noise_guided\n\n            # Tweedie denoising\n            z0t = (zt - (1 - at).sqrt() * noise_pred) / at.sqrt()\n\n            # Asymmetric renoising: CFG++ with small guidance leak\n            noise_renoise = noise_uc + renoise_leak * noise_delta\n            zt = at_prev.sqrt() * z0t + (1 - at_prev).sqrt() * noise_renoise\n\n            if callback_fn is not None:\n                callback_kwargs = {'z0t': z0t.detach(),\n                                   'zt': zt.detach(),\n                                   'decode': self.decode}\n                callback_kwargs = callback_fn(step, t, callback_kwargs)\n                z0t = callback_kwargs[\"z0t\"]\n                zt = callback_kwargs[\"zt\"]\n\n        # for the last step, do not add noise\n        img = self.decode(z0t)\n        img = (img / 2 + 0.5).clamp(0, 1)\n        return img.detach().cpu()\n"
7}

1{
2  "content": "class BaseDDIMCFGpp(SDXL):\n    # Rescaled CFG with Asymmetric Leaky Renoising (RCFG-AL) for SDXL.\n\n    def reverse_process(self,\n                        null_prompt_embeds,\n                        prompt_embeds,\n                        cfg_guidance,\n                        add_cond_kwargs,\n                        shape=(1024, 1024),\n                        callback_fn=None,\n                        **kwargs):\n\n        zt = self.initialize_latent(size=(1, 4, shape[1] // self.vae_scale_factor, shape[0] // self.vae_scale_factor))\n\n        # Hyperparameters for RCFG-AL\n        rescale_phi = 0.7       # Base rescaling interpolation factor\n        renoise_leak = 0.05     # Guidance leak into renoising step\n\n        total_steps = len(self.scheduler.timesteps)\n\n        pbar = tqdm(self.scheduler.timesteps.int(), desc='SDXL')\n        for step, t in enumerate(pbar):\n            next_t = t - self.skip\n            at = self.scheduler.alphas_cumprod[t]\n            at_next = self.scheduler.alphas_cumprod[next_t]\n\n            with torch.no_grad():\n                noise_uc, noise_c = self.predict_noise(zt, t, null_prompt_embeds, prompt_embeds, add_cond_kwargs)\n\n                # Guidance direction\n                noise_delta = noise_c - noise_uc\n\n                # Standard CFG guided prediction\n                noise_guided = noise_uc + cfg_guidance * noise_delta\n\n                # Rescaled CFG: normalize std to match conditional prediction\n                std_guided = noise_guided.std(dim=[1, 2, 3], keepdim=True)\n                std_cond = noise_c.std(dim=[1, 2, 3], keepdim=True)\n                noise_rescaled = noise_guided * (std_cond / (std_guided + 1e-8))\n\n                # Timestep-adaptive rescaling: stronger at high t, weaker at low t\n                progress = step / max(total_steps - 1, 1)\n                adaptive_phi = rescale_phi * (1.0 - 0.5 * progress)\n                noise_pred = adaptive_phi * noise_rescaled + (1 - adaptive_phi) * noise_guided\n\n            # Tweedie denoising\n            z0t = (zt - (1 - at).sqrt() * noise_pred) / at.sqrt()\n\n            # Asymmetric renoising: CFG++ with small guidance leak\n            noise_renoise = noise_uc + renoise_leak * noise_delta\n            zt = at_next.sqrt() * z0t + (1 - at_next).sqrt() * noise_renoise\n\n            if callback_fn is not None:\n                callback_kwargs = {'z0t': z0t.detach(),\n                                   'zt': zt.detach(),\n                                   'decode': self.decode}\n                callback_kwargs = callback_fn(step, t, callback_kwargs)\n                z0t = callback_kwargs[\"z0t\"]\n                zt = callback_kwargs[\"zt\"]\n\n        return z0t\n\n",
3  "end_line": 756,
4  "filename": "CFGpp-main/latent_sdxl.py",
5  "op": "replace",
6  "start_line": 714
7}

1{
2  "content": "@register_solver(\"ddim_cfg++\")\nclass BaseDDIMCFGpp(SDXL):\n    # Rescaled CFG with Asymmetric Leaky Renoising (RCFG-AL) for SDXL.\n\n    def reverse_process(self,\n                        null_prompt_embeds,\n                        prompt_embeds,\n                        cfg_guidance,\n                        add_cond_kwargs,\n                        shape=(1024, 1024),\n                        callback_fn=None,\n                        **kwargs):\n\n        zt = self.initialize_latent(size=(1, 4, shape[1] // self.vae_scale_factor, shape[0] // self.vae_scale_factor))\n\n        # Hyperparameters for RCFG-AL\n        rescale_phi = 0.7       # Base rescaling interpolation factor\n        renoise_leak = 0.05     # Guidance leak into renoising step\n\n        total_steps = len(self.scheduler.timesteps)\n\n        pbar = tqdm(self.scheduler.timesteps.int(), desc='SDXL')\n        for step, t in enumerate(pbar):\n            next_t = t - self.skip\n            at = self.scheduler.alphas_cumprod[t]\n            at_next = self.scheduler.alphas_cumprod[next_t]\n\n            with torch.no_grad():\n                noise_uc, noise_c = self.predict_noise(zt, t, null_prompt_embeds, prompt_embeds, add_cond_kwargs)\n\n                # Guidance direction\n                noise_delta = noise_c - noise_uc\n\n                # Standard CFG guided prediction\n                noise_guided = noise_uc + cfg_guidance * noise_delta\n\n                # Rescaled CFG: normalize std to match conditional prediction\n                std_guided = noise_guided.std(dim=[1, 2, 3], keepdim=True)\n                std_cond = noise_c.std(dim=[1, 2, 3], keepdim=True)\n                noise_rescaled = noise_guided * (std_cond / (std_guided + 1e-8))\n\n                # Timestep-adaptive rescaling: stronger at high t, weaker at low t\n                progress = step / max(total_steps - 1, 1)\n                adaptive_phi = rescale_phi * (1.0 - 0.5 * progress)\n                noise_pred = adaptive_phi * noise_rescaled + (1 - adaptive_phi) * noise_guided\n\n            # Tweedie denoising\n            z0t = (zt - (1 - at).sqrt() * noise_pred) / at.sqrt()\n\n            # Asymmetric renoising: CFG++ with small guidance leak\n            noise_renoise = noise_uc + renoise_leak * noise_delta\n            zt = at_next.sqrt() * z0t + (1 - at_next).sqrt() * noise_renoise\n\n            if callback_fn is not None:\n                callback_kwargs = {'z0t': z0t.detach(),\n                                   'zt': zt.detach(),\n                                   'decode': self.decode}\n                callback_kwargs = callback_fn(step, t, callback_kwargs)\n                z0t = callback_kwargs[\"z0t\"]\n                zt = callback_kwargs[\"zt\"]\n\n        return z0t\n\n",
3  "end_line": 755,
4  "filename": "CFGpp-main/latent_sdxl.py",
5  "op": "replace",
6  "start_line": 713
7}

1{
2  "op": "replace",
3  "filename": "CFGpp-main/latent_diffusion.py",
4  "start_line": 621,
5  "end_line": 679,
6  "content": "@register_solver(\"ddim_cfg++\")\nclass BaseDDIMCFGpp(StableDiffusion):\n    \"\"\"\n    Rescaled CFG++ with Adaptive Variance-Preserving Guidance.\n    \n    Key ideas:\n    1. Rescaled CFG: After standard CFG combination, rescale noise_pred to match\n       the channel-wise std of noise_c. This prevents the well-known oversaturation\n       artifact of high guidance scales, which inflates variance and hurts FID.\n    2. CFG++ renoising: Use noise_uc (unconditional) for the renoising step to keep\n       the sampling trajectory closer to the data manifold.\n    3. Adaptive rescale strength: Use a timestep-dependent rescale factor phi(t).\n       At high noise levels (early steps), apply stronger rescaling (phi~0.8) since\n       oversaturation is most damaging to global structure. At low noise levels\n       (late steps), reduce rescaling (phi~0.5) to preserve fine-grained guidance.\n    \"\"\"\n    def __init__(self,\n                 solver_config: Dict,\n                 model_key: str = \"runwayml/stable-diffusion-v1-5\",\n                 device: Optional[torch.device] = None,\n                 **kwargs):\n        super().__init__(solver_config, model_key, device, **kwargs)\n        # Rescale interpolation bounds\n        self.phi_max = 0.7   # rescale strength at early (high noise) steps\n        self.phi_min = 0.3   # rescale strength at late (low noise) steps\n\n    @torch.autocast(device_type='cuda', dtype=torch.float16)\n    def sample(self,\n               cfg_guidance=7.5,\n               prompt=[\"\", \"\"],\n               callback_fn=None,\n               **kwargs):\n        uc, c = self.get_text_embed(null_prompt=prompt[0], prompt=prompt[1])\n        zt = self.initialize_latent()\n        zt = zt.requires_grad_()\n\n        num_steps = len(self.scheduler.timesteps)\n\n        pbar = tqdm(self.scheduler.timesteps, desc=\"SD\")\n        for step, t in enumerate(pbar):\n            at = self.alpha(t)\n            at_prev = self.alpha(t - self.skip)\n            # Progress: 0 at start (high noise) -> 1 at end (low noise)\n            progress = step / max(num_steps - 1, 1)\n\n            with torch.no_grad():\n                noise_uc, noise_c = self.predict_noise(zt, t, uc, c)\n\n                # Standard CFG combination\n                noise_pred = noise_uc + cfg_guidance * (noise_c - noise_uc)\n\n                # Adaptive rescaled CFG: match std of conditional prediction\n                # to prevent oversaturation while preserving direction\n                std_pred = noise_pred.std(dim=[1, 2, 3], keepdim=True)\n                std_c = noise_c.std(dim=[1, 2, 3], keepdim=True)\n                noise_pred_rescaled = noise_pred * (std_c / (std_pred + 1e-8))\n\n                # Timestep-adaptive interpolation: stronger rescaling early\n                phi = self.phi_max + (self.phi_min - self.phi_max) * progress\n                noise_pred = phi * noise_pred_rescaled + (1.0 - phi) * noise_pred\n\n            # Tweedie denoising\n            z0t = (zt - (1 - at).sqrt() * noise_pred) / at.sqrt()\n\n            # CFG++ renoising: use noise_uc to stay on data manifold\n            zt = at_prev.sqrt() * z0t + (1 - at_prev).sqrt() * noise_uc\n\n            if callback_fn is not None:\n                callback_kwargs = {'z0t': z0t.detach(),\n                                   'zt': zt.detach(),\n                                   'decode': self.decode}\n                callback_kwargs = callback_fn(step, t, callback_kwargs)\n                z0t = callback_kwargs[\"z0t\"]\n                zt = callback_kwargs[\"zt\"]\n\n"
7}

1{
2  "op": "replace",
3  "filename": "CFGpp-main/latent_diffusion.py",
4  "start_line": 624,
5  "end_line": 682,
6  "content": "    \"\"\"\n    Rescaled CFG++ with Adaptive Variance-Preserving Guidance.\n    \n    Key ideas:\n    1. Rescaled CFG: After standard CFG combination, rescale noise_pred to match\n       the channel-wise std of noise_c. This prevents oversaturation from high\n       guidance scales, which inflates variance and hurts FID.\n    2. CFG++ renoising: Use noise_uc for the renoising step to keep the sampling\n       trajectory closer to the data manifold.\n    3. Adaptive rescale strength: phi(t) varies with timestep - stronger rescaling\n       at high noise (early steps) to prevent oversaturation of global structure,\n       weaker at low noise (late steps) to preserve fine-grained guidance.\n    \"\"\"\n\n    def __init__(self,\n                 solver_config: Dict,\n                 model_key: str = \"runwayml/stable-diffusion-v1-5\",\n                 device: Optional[torch.device] = None,\n                 **kwargs):\n        super().__init__(solver_config, model_key, device, **kwargs)\n        self.phi_max = 0.7   # rescale strength at early (high noise) steps\n        self.phi_min = 0.3   # rescale strength at late (low noise) steps\n\n    @torch.autocast(device_type='cuda', dtype=torch.float16)\n    def sample(self,\n               cfg_guidance=7.5,\n               prompt=[\"\", \"\"],\n               callback_fn=None,\n               **kwargs):\n        uc, c = self.get_text_embed(null_prompt=prompt[0], prompt=prompt[1])\n        zt = self.initialize_latent()\n        zt = zt.requires_grad_()\n\n        num_steps = len(self.scheduler.timesteps)\n\n        pbar = tqdm(self.scheduler.timesteps, desc=\"SD\")\n        for step, t in enumerate(pbar):\n            at = self.alpha(t)\n            at_prev = self.alpha(t - self.skip)\n            progress = step / max(num_steps - 1, 1)\n\n            with torch.no_grad():\n                noise_uc, noise_c = self.predict_noise(zt, t, uc, c)\n\n                # Standard CFG combination\n                noise_pred = noise_uc + cfg_guidance * (noise_c - noise_uc)\n\n                # Rescaled CFG: match std of conditional prediction\n                std_pred = noise_pred.std(dim=[1, 2, 3], keepdim=True)\n                std_c = noise_c.std(dim=[1, 2, 3], keepdim=True)\n                noise_pred_rescaled = noise_pred * (std_c / (std_pred + 1e-8))\n\n                # Adaptive interpolation: stronger rescaling early\n                phi = self.phi_max + (self.phi_min - self.phi_max) * progress\n                noise_pred = phi * noise_pred_rescaled + (1.0 - phi) * noise_pred\n\n            # Tweedie denoising\n            z0t = (zt - (1 - at).sqrt() * noise_pred) / at.sqrt()\n\n            # CFG++ renoising: use noise_uc to stay on data manifold\n            zt = at_prev.sqrt() * z0t + (1 - at_prev).sqrt() * noise_uc\n\n            if callback_fn is not None:\n                callback_kwargs = {'z0t': z0t.detach(),\n                                   'zt': zt.detach(),\n                                   'decode': self.decode}\n                callback_kwargs = callback_fn(step, t, callback_kwargs)\n                z0t = callback_kwargs[\"z0t\"]\n                zt = callback_kwargs[\"zt\"]\n\n        img = self.decode(z0t)\n        img = (img / 2 + 0.5).clamp(0, 1)\n        return img.detach().cpu()\n"
7}

1{
2  "content": "    \"\"\"\n    Rescaled CFG++ with Adaptive Variance-Preserving Guidance for SDXL.\n    Same algorithmic approach as SD 1.5 version.\n    \"\"\"\n    def reverse_process(self,\n                        null_prompt_embeds,\n                        prompt_embeds,\n                        cfg_guidance,\n                        add_cond_kwargs,\n                        shape=(1024, 1024),\n                        callback_fn=None,\n                        **kwargs):\n        zt = self.initialize_latent(size=(1, 4, shape[1] // self.vae_scale_factor, shape[0] // self.vae_scale_factor))\n\n        num_steps = len(self.scheduler.timesteps)\n        phi_max = 0.7\n        phi_min = 0.3\n\n        pbar = tqdm(self.scheduler.timesteps.int(), desc='SDXL')\n        for step, t in enumerate(pbar):\n            next_t = t - self.skip\n            at = self.scheduler.alphas_cumprod[t]\n            at_next = self.scheduler.alphas_cumprod[next_t]\n            progress = step / max(num_steps - 1, 1)\n\n            with torch.no_grad():\n                noise_uc, noise_c = self.predict_noise(zt, t, null_prompt_embeds, prompt_embeds, add_cond_kwargs)\n\n                # Standard CFG combination\n                noise_pred = noise_uc + cfg_guidance * (noise_c - noise_uc)\n\n                # Rescaled CFG: match std of conditional prediction\n                std_pred = noise_pred.std(dim=[1, 2, 3], keepdim=True)\n                std_c = noise_c.std(dim=[1, 2, 3], keepdim=True)\n                noise_pred_rescaled = noise_pred * (std_c / (std_pred + 1e-8))\n\n                # Adaptive interpolation: stronger rescaling early\n                phi = phi_max + (phi_min - phi_max) * progress\n                noise_pred = phi * noise_pred_rescaled + (1.0 - phi) * noise_pred\n\n            z0t = (zt - (1 - at).sqrt() * noise_pred) / at.sqrt()\n\n            # CFG++ renoising: use noise_uc to stay on data manifold\n            zt = at_next.sqrt() * z0t + (1 - at_next).sqrt() * noise_uc\n\n            if callback_fn is not None:\n                callback_kwargs = {'z0t': z0t.detach(),\n                                   'zt': zt.detach(),\n                                   'decode': self.decode}\n                callback_kwargs = callback_fn(step, t, callback_kwargs)\n                z0t = callback_kwargs[\"z0t\"]\n                zt = callback_kwargs[\"zt\"]\n\n        return z0t\n\n",
3  "end_line": 755,
4  "filename": "CFGpp-main/latent_sdxl.py",
5  "op": "replace",
6  "start_line": 715
7}

1{
2  "op": "replace",
3  "filename": "CFGpp-main/latent_diffusion.py",
4  "start_line": 621,
5  "end_line": 679,
6  "content": "@register_solver(\"ddim_cfg++\")\nclass BaseDDIMCFGpp(StableDiffusion):\n    \"\"\"\n    Rescaled Asymmetric CFG++ (RA-CFG++):\n    Combines CFG++ manifold-constrained renoising with rescaled CFG\n    to prevent oversaturation, plus a linear warmup schedule.\n    \n    Key ideas:\n    1. CFG++ renoising: use noise_uc (not noise_pred) for the renoise step,\n       keeping the sampling trajectory on the data manifold.\n    2. Rescaled CFG: after computing the guided noise prediction, rescale its\n       per-sample std to match the conditional prediction's std. This prevents\n       the guidance from inflating the noise magnitude (which causes color\n       saturation and artifacts that hurt FID).\n    3. Linear warmup: ramp guidance from 0 over the first K steps to avoid\n       early-step instability when noise levels are highest.\n    \"\"\"\n\n    def __init__(self,\n                 solver_config: Dict,\n                 model_key:str=\"runwayml/stable-diffusion-v1-5\",\n                 device: Optional[torch.device]=None,\n                 **kwargs):\n        super().__init__(solver_config, model_key, device, **kwargs)\n\n    @torch.autocast(device_type='cuda', dtype=torch.float16)\n    def sample(self,\n               cfg_guidance=7.5,\n               prompt=[\"\",\"\"],\n               callback_fn=None,\n               **kwargs):\n        # Method design parameters (hardcoded as part of algorithm)\n        cfg_guidance = 2.0      # Moderate guidance scale for CFG++ style\n        phi = 0.7               # Rescaling interpolation factor\n        K_warmup = 2            # Number of warmup steps (linear ramp from 0)\n\n        # Text embedding\n        uc, c = self.get_text_embed(null_prompt=prompt[0], prompt=prompt[1])\n\n        # Initialize zT\n        zt = self.initialize_latent()\n        zt = zt.requires_grad_()\n\n        num_steps = len(self.scheduler.timesteps)\n\n        # Sampling\n        pbar = tqdm(self.scheduler.timesteps, desc=\"SD\")\n        for step, t in enumerate(pbar):\n            at = self.alpha(t)\n            at_prev = self.alpha(t - self.skip)\n\n            with torch.no_grad():\n                noise_uc, noise_c = self.predict_noise(zt, t, uc, c)\n\n                # Linear warmup: ramp guidance from 0 to cfg_guidance over K_warmup steps\n                if step < K_warmup:\n                    w = cfg_guidance * (step / K_warmup)\n                else:\n                    w = cfg_guidance\n\n                # Guided noise prediction\n                noise_pred = noise_uc + w * (noise_c - noise_uc)\n\n                # Rescaled CFG: normalize std to match noise_c's std\n                # This prevents oversaturation from inflated noise magnitude\n                if w > 0:\n                    std_pred = noise_pred.std(dim=[1, 2, 3], keepdim=True)\n                    std_c = noise_c.std(dim=[1, 2, 3], keepdim=True)\n                    noise_pred = noise_pred * (std_c / (std_pred + 1e-8)) * phi + noise_pred * (1 - phi)\n\n            # Tweedie denoising with guided prediction\n            z0t = (zt - (1-at).sqrt() * noise_pred) / at.sqrt()\n\n            # CFG++ renoising: use noise_uc to stay on data manifold\n            zt = at_prev.sqrt() * z0t + (1-at_prev).sqrt() * noise_uc\n\n            if callback_fn is not None:\n                callback_kwargs = {'z0t': z0t.detach(),\n                                    'zt': zt.detach(),\n                                    'decode': self.decode}\n                callback_kwargs = callback_fn(step, t, callback_kwargs)\n                z0t = callback_kwargs[\"z0t\"]\n                zt = callback_kwargs[\"zt\"]\n\n        # for the last step, do not add noise"
7}