Apply suggestions from code review

Author: yiyixuxu

src/diffusers/schedulers/scheduling_ddim.py

@@ -349,8 +349,6 @@ def step(
         generator=None,
         variance_noise: Optional[torch.Tensor] = None,
         return_dict: bool = True,
-        _model_output_uncond: Optional[torch.Tensor] = None,
-        _use_cfgpp: bool = True,
     ) -> Union[DDIMSchedulerOutput, Tuple]:
         """
         Predict the sample from the previous timestep by reversing the SDE. This function propagates the diffusion
@@ -388,11 +386,6 @@ def step(
             raise ValueError(
                 "Number of inference steps is 'None', you need to run 'set_timesteps' after creating the scheduler"
             )
-        
-        if _use_cfgpp and self.config.prediction_type != "epsilon":
-            raise ValueError(
-                f"CFG++ is only supported for prediction type `epsilon`, but got {self.config.prediction_type}."
-            )
 
         # See formulas (12) and (16) of DDIM paper https://arxiv.org/pdf/2010.02502.pdf
         # Ideally, read DDIM paper in-detail understanding
@@ -418,7 +411,6 @@ def step(
         # "predicted x_0" of formula (12) from https://arxiv.org/pdf/2010.02502.pdf
         if self.config.prediction_type == "epsilon":
             pred_original_sample = (sample - beta_prod_t ** (0.5) * model_output) / alpha_prod_t ** (0.5)
-            pred_epsilon = model_output if not _use_cfgpp else _model_output_uncond
         elif self.config.prediction_type == "sample":
             pred_original_sample = model_output
             pred_epsilon = (sample - alpha_prod_t ** (0.5) * pred_original_sample) / beta_prod_t ** (0.5)

src/diffusers/schedulers/scheduling_euler_discrete.py

@@ -584,8 +584,6 @@ def step(
         s_noise: float = 1.0,
         generator: Optional[torch.Generator] = None,
         return_dict: bool = True,
-        _model_output_uncond: Optional[torch.Tensor] = None,
-        _use_cfgpp: bool = False,
     ) -> Union[EulerDiscreteSchedulerOutput, Tuple]:
         """
         Predict the sample from the previous timestep by reversing the SDE. This function propagates the diffusion
@@ -629,11 +627,6 @@ def step(
                 "The `scale_model_input` function should be called before `step` to ensure correct denoising. "
                 "See `StableDiffusionPipeline` for a usage example."
             )
-        
-        if _use_cfgpp and self.config.prediction_type != "epsilon":
-            raise ValueError(
-                f"CFG++ is only supported for prediction type `epsilon`, but got {self.config.prediction_type}."
-            )
 
         if self.step_index is None:
             self._init_step_index(timestep)
@@ -675,38 +668,6 @@ def step(
         dt = self.sigmas[self.step_index + 1] - sigma_hat
 
         prev_sample = sample + derivative * dt
-        if _use_cfgpp:
-            prev_sample = prev_sample + (_model_output_uncond - model_output) * self.sigmas[self.step_index + 1]
-        
-        # denoised = sample - model_output * sigmas[i]
-        # d = (sample - denoised) / sigmas[i]
-        # new_sample = denoised + d * sigmas[i + 1]
-
-        # new_sample = denoised + (sample - denoised) * sigmas[i + 1] / sigmas[i]
-        # new_sample = sample - model_output * sigmas[i] + model_output * sigmas[i + 1]
-        # new_sample = sample + model_output * (sigmas[i + 1] - sigmas[i])
-        # new_sample = sample - model_output * sigmas[i] + model_output * sigmas[i + 1] --- (1)
-
-        # CFG++ =====
-        # denoised = sample - model_output * sigmas[i]
-        # uncond_denoised = sample - model_output_uncond * sigmas[i]
-        # d = (sample - uncond_denoised) / sigmas[i]
-        # new_sample = denoised + d * sigmas[i + 1]
-
-        # new_sample = denoised + (sample - uncond_denoised) * sigmas[i + 1] / sigmas[i]
-        # new_sample = sample - model_output * sigmas[i] + model_output_uncond * sigmas[i + 1] --- (2)
-
-        # To go from (1) to (2):
-        # new_sample_2 = new_sample_1 - model_output * sigmas[i + 1] + model_output_uncond * sigmas[i + 1]
-        # new_sample_2 = new_sample_1 + (model_output_uncond - model_output) * sigmas[i + 1]
-        # new_sample_2 = new_sample_1 + diff * sigmas[i + 1]
-
-        # diff = model_output_uncond - model_output
-        # diff = model_output_uncond - (model_output_uncond + g * (model_output_cond - model_output_uncond))
-        # diff = model_output_uncond - (g * model_output_cond + (1 - g) * model_output_uncond)
-        # diff = model_output_uncond - g * model_output_cond + (g - 1) * model_output_uncond
-        # diff = g * (model_output_uncond - model_output_cond)
-        
         # Cast sample back to model compatible dtype
         prev_sample = prev_sample.to(model_output.dtype)