Separate Sigma Schedule

examples/community/adaptive_mask_inpainting.py

@@ -1148,7 +1148,7 @@ def __call__(
                 # run segmentation
                 if use_adaptive_mask:
                     if enforce_full_mask_ratio > 0.0:
-                        use_default_mask = t < self.scheduler.config.num_train_timesteps * enforce_full_mask_ratio
+                        use_default_mask = t < self.scheduler._schedule.num_train_timesteps * enforce_full_mask_ratio
                     elif enforce_full_mask_ratio == 0.0:
                         use_default_mask = False
                     else:

examples/community/edict_pipeline.py

@@ -97,7 +97,7 @@ def noise_step(
         model_output: torch.Tensor,
         timestep: torch.Tensor,
     ):
-        prev_timestep = timestep - self.scheduler.config.num_train_timesteps / self.scheduler.num_inference_steps
+        prev_timestep = timestep - self.scheduler._schedule.num_train_timesteps / self.scheduler.num_inference_steps
 
         alpha_prod_t, beta_prod_t = self._get_alpha_and_beta(timestep)
         alpha_prod_t_prev, beta_prod_t_prev = self._get_alpha_and_beta(prev_timestep)
@@ -116,7 +116,7 @@ def denoise_step(
         model_output: torch.Tensor,
         timestep: torch.Tensor,
     ):
-        prev_timestep = timestep - self.scheduler.config.num_train_timesteps / self.scheduler.num_inference_steps
+        prev_timestep = timestep - self.scheduler._schedule.num_train_timesteps / self.scheduler.num_inference_steps
 
         alpha_prod_t, beta_prod_t = self._get_alpha_and_beta(timestep)
         alpha_prod_t_prev, beta_prod_t_prev = self._get_alpha_and_beta(prev_timestep)

examples/community/lpw_stable_diffusion_xl.py

@@ -1050,8 +1050,8 @@ def get_timesteps(self, num_inference_steps, strength, device, denoising_start=N
         if denoising_start is not None:
             discrete_timestep_cutoff = int(
                 round(
-                    self.scheduler.config.num_train_timesteps
-                    - (denoising_start * self.scheduler.config.num_train_timesteps)
+                    self.scheduler._schedule.num_train_timesteps
+                    - (denoising_start * self.scheduler._schedule.num_train_timesteps)
                 )
             )
 
@@ -1819,8 +1819,8 @@ def denoising_value_valid(dnv):
         elif self.denoising_end is not None and denoising_value_valid(self.denoising_end):
             discrete_timestep_cutoff = int(
                 round(
-                    self.scheduler.config.num_train_timesteps
-                    - (self.denoising_end * self.scheduler.config.num_train_timesteps)
+                    self.scheduler._schedule.num_train_timesteps
+                    - (self.denoising_end * self.scheduler._schedule.num_train_timesteps)
                 )
             )
             num_inference_steps = len(list(filter(lambda ts: ts >= discrete_timestep_cutoff, timesteps)))

examples/community/masked_stable_diffusion_xl_img2img.py

@@ -376,8 +376,8 @@ def denoising_value_valid(dnv):
         elif self.denoising_end is not None and denoising_value_valid(self.denoising_end):
             discrete_timestep_cutoff = int(
                 round(
-                    self.scheduler.config.num_train_timesteps
-                    - (self.denoising_end * self.scheduler.config.num_train_timesteps)
+                    self.scheduler._schedule.num_train_timesteps
+                    - (self.denoising_end * self.scheduler._schedule.num_train_timesteps)
                 )
             )
             num_inference_steps = len(list(filter(lambda ts: ts >= discrete_timestep_cutoff, timesteps)))

examples/community/pipeline_demofusion_sdxl.py

@@ -933,8 +933,8 @@ def __call__(
         if denoising_end is not None and isinstance(denoising_end, float) and denoising_end > 0 and denoising_end < 1:
             discrete_timestep_cutoff = int(
                 round(
-                    self.scheduler.config.num_train_timesteps
-                    - (denoising_end * self.scheduler.config.num_train_timesteps)
+                    self.scheduler._schedule.num_train_timesteps
+                    - (denoising_end * self.scheduler._schedule.num_train_timesteps)
                 )
             )
             num_inference_steps = len(list(filter(lambda ts: ts >= discrete_timestep_cutoff, timesteps)))
@@ -1040,8 +1040,8 @@ def __call__(
                             1
                             + torch.cos(
                                 torch.pi
-                                * (self.scheduler.config.num_train_timesteps - t)
-                                / self.scheduler.config.num_train_timesteps
+                                * (self.scheduler._schedule.num_train_timesteps - t)
+                                / self.scheduler._schedule.num_train_timesteps
                             )
                         ).cpu()
                     )

examples/community/pipeline_flux_differential_img2img.py

@@ -582,7 +582,7 @@ def prepare_latents(
 
         if latents is None:
             noise = randn_tensor(shape, generator=generator, device=device, dtype=dtype)
-            latents = self.scheduler.scale_noise(image_latents, timestep, noise)
+            latents = self.scheduler.add_noise(image_latents, noise, timestep)
         else:
             noise = latents.to(device)
             latents = noise
@@ -876,10 +876,10 @@ def __call__(
         image_seq_len = (int(height) // self.vae_scale_factor) * (int(width) // self.vae_scale_factor)
         mu = calculate_shift(
             image_seq_len,
-            self.scheduler.config.base_image_seq_len,
-            self.scheduler.config.max_image_seq_len,
-            self.scheduler.config.base_shift,
-            self.scheduler.config.max_shift,
+            self.scheduler._schedule.base_image_seq_len,
+            self.scheduler._schedule.max_image_seq_len,
+            self.scheduler._schedule.base_shift,
+            self.scheduler._schedule.max_shift,
         )
         timesteps, num_inference_steps = retrieve_timesteps(
             self.scheduler,
@@ -976,8 +976,8 @@ def __call__(
 
                 if i < len(timesteps) - 1:
                     noise_timestep = timesteps[i + 1]
-                    image_latent = self.scheduler.scale_noise(
-                        original_image_latents, torch.tensor([noise_timestep]), noise
+                    image_latent = self.scheduler.add_noise(
+                        original_image_latents, noise, torch.tensor([noise_timestep])
                     )
 
                     # start diff diff

examples/community/pipeline_flux_rf_inversion.py

@@ -822,10 +822,10 @@ def __call__(
         image_seq_len = (int(height) // self.vae_scale_factor // 2) * (int(width) // self.vae_scale_factor // 2)
         mu = calculate_shift(
             image_seq_len,
-            self.scheduler.config.base_image_seq_len,
-            self.scheduler.config.max_image_seq_len,
-            self.scheduler.config.base_shift,
-            self.scheduler.config.max_shift,
+            self.scheduler._schedule.base_image_seq_len,
+            self.scheduler._schedule.max_image_seq_len,
+            self.scheduler._schedule.base_shift,
+            self.scheduler._schedule.max_shift,
         )
         timesteps, num_inference_steps = retrieve_timesteps(
             self.scheduler,
@@ -992,10 +992,10 @@ def invert(
         image_seq_len = (int(height) // self.vae_scale_factor // 2) * (int(width) // self.vae_scale_factor // 2)
         mu = calculate_shift(
             image_seq_len,
-            self.scheduler.config.base_image_seq_len,
-            self.scheduler.config.max_image_seq_len,
-            self.scheduler.config.base_shift,
-            self.scheduler.config.max_shift,
+            self.scheduler._schedule.base_image_seq_len,
+            self.scheduler._schedule.max_image_seq_len,
+            self.scheduler._schedule.base_shift,
+            self.scheduler._schedule.max_shift,
         )
         timesteps, num_inversion_steps = retrieve_timesteps(
             self.scheduler,

examples/community/pipeline_flux_with_cfg.py

@@ -757,10 +757,10 @@ def __call__(
         image_seq_len = latents.shape[1]
         mu = calculate_shift(
             image_seq_len,
-            self.scheduler.config.base_image_seq_len,
-            self.scheduler.config.max_image_seq_len,
-            self.scheduler.config.base_shift,
-            self.scheduler.config.max_shift,
+            self.scheduler._schedule.base_image_seq_len,
+            self.scheduler._schedule.max_image_seq_len,
+            self.scheduler._schedule.base_shift,
+            self.scheduler._schedule.max_shift,
         )
         timesteps, num_inference_steps = retrieve_timesteps(
             self.scheduler,

examples/community/pipeline_kolors_differential_img2img.py

@@ -580,8 +580,8 @@ def get_timesteps(self, num_inference_steps, strength, device, denoising_start=N
         if denoising_start is not None:
             discrete_timestep_cutoff = int(
                 round(
-                    self.scheduler.config.num_train_timesteps
-                    - (denoising_start * self.scheduler.config.num_train_timesteps)
+                    self.scheduler._schedule.num_train_timesteps
+                    - (denoising_start * self.scheduler._schedule.num_train_timesteps)
                 )
             )
 
@@ -1159,8 +1159,8 @@ def denoising_value_valid(dnv):
         elif self.denoising_end is not None and denoising_value_valid(self.denoising_end):
             discrete_timestep_cutoff = int(
                 round(
-                    self.scheduler.config.num_train_timesteps
-                    - (self.denoising_end * self.scheduler.config.num_train_timesteps)
+                    self.scheduler._schedule.num_train_timesteps
+                    - (self.denoising_end * self.scheduler._schedule.num_train_timesteps)
                 )
             )
             num_inference_steps = len(list(filter(lambda ts: ts >= discrete_timestep_cutoff, timesteps)))

examples/community/pipeline_null_text_inversion.py

@@ -87,7 +87,7 @@ def latent2image(self, latents):
         return image
 
     def prev_step(self, model_output, timestep, sample):
-        prev_timestep = timestep - self.scheduler.config.num_train_timesteps // self.scheduler.num_inference_steps
+        prev_timestep = timestep - self.scheduler._schedule.num_train_timesteps // self.scheduler.num_inference_steps
         alpha_prod_t = self.scheduler.alphas_cumprod[timestep]
         alpha_prod_t_prev = (
             self.scheduler.alphas_cumprod[prev_timestep] if prev_timestep >= 0 else self.scheduler.final_alpha_cumprod
@@ -100,7 +100,7 @@ def prev_step(self, model_output, timestep, sample):
 
     def next_step(self, model_output, timestep, sample):
         timestep, next_timestep = (
-            min(timestep - self.scheduler.config.num_train_timesteps // self.num_inference_steps, 999),
+            min(timestep - self.scheduler._schedule.num_train_timesteps // self.num_inference_steps, 999),
             timestep,
         )
         alpha_prod_t = self.scheduler.alphas_cumprod[timestep] if timestep >= 0 else self.scheduler.final_alpha_cumprod

examples/community/pipeline_sdxl_style_aligned.py

@@ -874,8 +874,8 @@ def get_timesteps(self, num_inference_steps, strength, device, denoising_start=N
         if denoising_start is not None:
             discrete_timestep_cutoff = int(
                 round(
-                    self.scheduler.config.num_train_timesteps
-                    - (denoising_start * self.scheduler.config.num_train_timesteps)
+                    self.scheduler._schedule.num_train_timesteps
+                    - (denoising_start * self.scheduler._schedule.num_train_timesteps)
                 )
             )
 
@@ -1785,8 +1785,8 @@ def denoising_value_valid(dnv):
         ):
             discrete_timestep_cutoff = int(
                 round(
-                    self.scheduler.config.num_train_timesteps
-                    - (self.denoising_end * self.scheduler.config.num_train_timesteps)
+                    self.scheduler._schedule.num_train_timesteps
+                    - (self.denoising_end * self.scheduler._schedule.num_train_timesteps)
                 )
             )
             num_inference_steps = len(list(filter(lambda ts: ts >= discrete_timestep_cutoff, timesteps)))

examples/community/pipeline_stable_diffusion_3_differential_img2img.py

@@ -640,7 +640,7 @@ def prepare_latents(
         shape = init_latents.shape
         noise = randn_tensor(shape, generator=generator, device=device, dtype=dtype)
 
-        init_latents = self.scheduler.scale_noise(init_latents, timestep, noise)
+        init_latents = self.scheduler.add_noise(init_latents, noise, timestep)
         latents = init_latents.to(device=device, dtype=dtype)
 
         return latents

examples/community/pipeline_stable_diffusion_xl_controlnet_adapter.py

@@ -1279,8 +1279,8 @@ def __call__(
         if denoising_end is not None and isinstance(denoising_end, float) and denoising_end > 0 and denoising_end < 1:
             discrete_timestep_cutoff = int(
                 round(
-                    self.scheduler.config.num_train_timesteps
-                    - (denoising_end * self.scheduler.config.num_train_timesteps)
+                    self.scheduler._schedule.num_train_timesteps
+                    - (denoising_end * self.scheduler._schedule.num_train_timesteps)
                 )
             )
             num_inference_steps = len(list(filter(lambda ts: ts >= discrete_timestep_cutoff, timesteps)))

examples/community/pipeline_stable_diffusion_xl_controlnet_adapter_inpaint.py

@@ -1057,8 +1057,8 @@ def get_timesteps(self, num_inference_steps, strength, device, denoising_start=N
         if denoising_start is not None:
             discrete_timestep_cutoff = int(
                 round(
-                    self.scheduler.config.num_train_timesteps
-                    - (denoising_start * self.scheduler.config.num_train_timesteps)
+                    self.scheduler._schedule.num_train_timesteps
+                    - (denoising_start * self.scheduler._schedule.num_train_timesteps)
                 )
             )
 
@@ -1691,8 +1691,8 @@ def denoising_value_valid(dnv):
         elif denoising_end is not None and denoising_value_valid(denoising_end):
             discrete_timestep_cutoff = int(
                 round(
-                    self.scheduler.config.num_train_timesteps
-                    - (denoising_end * self.scheduler.config.num_train_timesteps)
+                    self.scheduler._schedule.num_train_timesteps
+                    - (denoising_end * self.scheduler._schedule.num_train_timesteps)
                 )
             )
             num_inference_steps = len(list(filter(lambda ts: ts >= discrete_timestep_cutoff, timesteps)))

examples/community/pipeline_stable_diffusion_xl_differential_img2img.py

@@ -626,8 +626,8 @@ def get_timesteps(self, num_inference_steps, strength, device, denoising_start=N
         if denoising_start is not None:
             discrete_timestep_cutoff = int(
                 round(
-                    self.scheduler.config.num_train_timesteps
-                    - (denoising_start * self.scheduler.config.num_train_timesteps)
+                    self.scheduler._schedule.num_train_timesteps
+                    - (denoising_start * self.scheduler._schedule.num_train_timesteps)
                 )
             )
 
@@ -1306,8 +1306,8 @@ def denoising_value_valid(dnv):
         elif denoising_end is not None and denoising_value_valid(denoising_end):
             discrete_timestep_cutoff = int(
                 round(
-                    self.scheduler.config.num_train_timesteps
-                    - (denoising_end * self.scheduler.config.num_train_timesteps)
+                    self.scheduler._schedule.num_train_timesteps
+                    - (denoising_end * self.scheduler._schedule.num_train_timesteps)
                 )
             )
             num_inference_steps = len(list(filter(lambda ts: ts >= discrete_timestep_cutoff, timesteps)))

examples/community/pipeline_stable_diffusion_xl_ipex.py

@@ -1055,8 +1055,8 @@ def __call__(
         ):
             discrete_timestep_cutoff = int(
                 round(
-                    self.scheduler.config.num_train_timesteps
-                    - (self.denoising_end * self.scheduler.config.num_train_timesteps)
+                    self.scheduler._schedule.num_train_timesteps
+                    - (self.denoising_end * self.scheduler._schedule.num_train_timesteps)
                 )
             )
             num_inference_steps = len(list(filter(lambda ts: ts >= discrete_timestep_cutoff, timesteps)))

examples/community/rerender_a_video.py

@@ -1079,7 +1079,7 @@ def denoising_loop(latents, mask=None, xtrg=None, noise_rescale=None):
                             # get x_t from x_0
                             latents = self.scheduler.add_noise(pred_x0, noise_pred, t).to(latents_dtype)
 
-                        prev_t = t - self.scheduler.config.num_train_timesteps // self.scheduler.num_inference_steps
+                        prev_t = t - self.scheduler._schedule.num_train_timesteps // self.scheduler.num_inference_steps
                         if i == len(timesteps) - 1:
                             alpha_t_prev = 1.0
                         else:

examples/community/sde_drag.py

@@ -295,7 +295,7 @@ def train_lora(self, prompt, image, lora_step=100, lora_rank=16, generator=None)
 
             # Sample a random timestep for each image
             timesteps = torch.randint(
-                0, self.scheduler.config.num_train_timesteps, (bsz,), device=model_input.device, generator=generator
+                0, self.scheduler._schedule.num_train_timesteps, (bsz,), device=model_input.device, generator=generator
             )
             timesteps = timesteps.long()
 

examples/community/stable_diffusion_xl_controlnet_reference.py

@@ -1177,8 +1177,8 @@ def hacked_UpBlock2D_forward(
         ):
             discrete_timestep_cutoff = int(
                 round(
-                    self.scheduler.config.num_train_timesteps
-                    - (self.denoising_end * self.scheduler.config.num_train_timesteps)
+                    self.scheduler._schedule.num_train_timesteps
+                    - (self.denoising_end * self.scheduler._schedule.num_train_timesteps)
                 )
             )
             num_inference_steps = len(list(filter(lambda ts: ts >= discrete_timestep_cutoff, timesteps)))

examples/community/stable_diffusion_xl_reference.py

@@ -1035,8 +1035,8 @@ def hacked_UpBlock2D_forward(
         ):
             discrete_timestep_cutoff = int(
                 round(
-                    self.scheduler.config.num_train_timesteps
-                    - (self.denoising_end * self.scheduler.config.num_train_timesteps)
+                    self.scheduler._schedule.num_train_timesteps
+                    - (self.denoising_end * self.scheduler._schedule.num_train_timesteps)
                 )
             )
             num_inference_steps = len(list(filter(lambda ts: ts >= discrete_timestep_cutoff, timesteps)))