code: 
  
  
  
  
  
  
  import unittest
  
  import torch
  
  from diffusers import UNetaDModel
  from diffusers.utils import floats_tensor, slow, torch_device
  
  from .test_modeling_common import ModelTesterMixin, UNetTesterMixin
  
  
  
  class 							_A (    UpperCamelCase				,				UpperCamelCase				,				unittest.TestCase							):
      """simple docstring"""
  
      lowerCamelCase  :       str   =   UNetaDModel
      lowerCamelCase  :       List[Any]   =   'sample'
  
  
  
      @property
      def _a       (							self			:    int			)			->       int:
             __UpperCAmelCase    							=4
             __UpperCAmelCase    							=14
             __UpperCAmelCase    							=16
  
             __UpperCAmelCase    							=floats_tensor((batch_size, num_features, seq_len)			).to(__SCREAMING_SNAKE_CASE			)
             __UpperCAmelCase    							=torch.tensor([10] * batch_size			).to(__SCREAMING_SNAKE_CASE			)
  
             return {"sample": noise, "timestep": time_step}
  
  
  
      @property
      def _a       (							self			:    int			)			->       str:
             return (4, 14, 16)
  
  
  
      @property
      def _a       (							self			:    Union[str, Any]			)			->       int:
             return (4, 14, 16)
  
  
  
      def _a       (							self			:    Dict			)			->       Optional[Any]:
             pass
  
  
  
      def _a       (							self			:    Union[str, Any]			)			->       Optional[Any]:
             pass
  
  
  
      @unittest.skipIf(torch_device == """mps"""   ,    """mish op not supported in MPS"""			)
      def _a       (							self			:    Optional[Any]			)			->       int:
             super().test_determinism()
  
  
  
      @unittest.skipIf(torch_device == """mps"""   ,    """mish op not supported in MPS"""			)
      def _a       (							self			:    int			)			->       Optional[Any]:
             super().test_outputs_equivalence()
  
  
  
      @unittest.skipIf(torch_device == """mps"""   ,    """mish op not supported in MPS"""			)
      def _a       (							self			:    Optional[Any]			)			->       Optional[int]:
             super().test_from_save_pretrained()
  
  
  
      @unittest.skipIf(torch_device == """mps"""   ,    """mish op not supported in MPS"""			)
      def _a       (							self			:    str			)			->       Optional[int]:
             super().test_from_save_pretrained_variant()
  
  
  
      @unittest.skipIf(torch_device == """mps"""   ,    """mish op not supported in MPS"""			)
      def _a       (							self			:    Any			)			->       Dict:
             super().test_model_from_pretrained()
  
  
  
      @unittest.skipIf(torch_device == """mps"""   ,    """mish op not supported in MPS"""			)
      def _a       (							self			:    Any			)			->       List[str]:
             super().test_output()
  
  
  
      def _a       (							self			:    Optional[Any]			)			->       Optional[int]:
             __UpperCAmelCase    							={
                 """block_out_channels""": (32, 64, 128, 256),
                 """in_channels""": 14,
                 """out_channels""": 14,
                 """time_embedding_type""": """positional""",
                 """use_timestep_embedding""": True,
                 """flip_sin_to_cos""": False,
                 """freq_shift""": 1.0,
                 """out_block_type""": """OutConv1DBlock""",
                 """mid_block_type""": """MidResTemporalBlock1D""",
                 """down_block_types""": ("""DownResnetBlock1D""", """DownResnetBlock1D""", """DownResnetBlock1D""", """DownResnetBlock1D"""),
                 """up_block_types""": ("""UpResnetBlock1D""", """UpResnetBlock1D""", """UpResnetBlock1D"""),
                 """act_fn""": """mish""",
             }
             __UpperCAmelCase    							=self.dummy_input
             return init_dict, inputs_dict
  
  
  
      @unittest.skipIf(torch_device == """mps"""   ,    """mish op not supported in MPS"""			)
      def _a       (							self			:    Tuple			)			->       Any:
             __UpperCAmelCase							,   __UpperCAmelCase    							=UNetaDModel.from_pretrained(
                 """bglick13/hopper-medium-v2-value-function-hor32"""   ,    output_loading_info=__SCREAMING_SNAKE_CASE   ,    subfolder="""unet"""			)
             self.assertIsNotNone(__SCREAMING_SNAKE_CASE			)
             self.assertEqual(len(loading_info["""missing_keys"""]			)   ,    0			)
  
             model.to(__SCREAMING_SNAKE_CASE			)
             __UpperCAmelCase    							=model(**self.dummy_input			)
  
             assert image is not None, "Make sure output is not None"
  
  
  
      @unittest.skipIf(torch_device == """mps"""   ,    """mish op not supported in MPS"""			)
      def _a       (							self			:    str			)			->       Union[str, Any]:
             __UpperCAmelCase    							=UNetaDModel.from_pretrained("""bglick13/hopper-medium-v2-value-function-hor32"""   ,    subfolder="""unet"""			)
             torch.manual_seed(0			)
             if torch.cuda.is_available():
                    torch.cuda.manual_seed_all(0			)
  
             __UpperCAmelCase    							=model.config.in_channels
             __UpperCAmelCase    							=16
             __UpperCAmelCase    							=torch.randn((1, seq_len, num_features)			).permute(
                 0   ,    2   ,    1			)  # match original, we can update values and remove
             __UpperCAmelCase    							=torch.full((num_features,)   ,    0			)
  
             with torch.no_grad():
                    __UpperCAmelCase    							=model(__SCREAMING_SNAKE_CASE   ,    __SCREAMING_SNAKE_CASE			).sample.permute(0   ,    2   ,    1			)
  
             __UpperCAmelCase    							=output[0, -3:, -3:].flatten()
             # fmt: off
             __UpperCAmelCase    							=torch.tensor([-2.137_172, 1.1_426_016, 0.3_688_687, -0.766_922, 0.7_303_146, 0.11_038_864, -0.4_760_633, 0.13_270_172, 0.02_591_348]			)
             # fmt: on
             self.assertTrue(torch.allclose(__SCREAMING_SNAKE_CASE   ,    __SCREAMING_SNAKE_CASE   ,    rtol=1e-3			)			)
  
  
  
      def _a       (							self			:    List[Any]			)			->       List[str]:
             # Not implemented yet for this UNet
             pass
  
  
  
      @slow
      def _a       (							self			:    str			)			->       int:
             __UpperCAmelCase    							="""harmonai/maestro-150k"""
             __UpperCAmelCase    							=UNetaDModel.from_pretrained(__SCREAMING_SNAKE_CASE   ,    subfolder="""unet"""			)
             model.to(__SCREAMING_SNAKE_CASE			)
  
             __UpperCAmelCase    							=65536
             __UpperCAmelCase    							=torch.sin(torch.arange(__SCREAMING_SNAKE_CASE			)[None, None, :].repeat(1   ,    2   ,    1			)			).to(__SCREAMING_SNAKE_CASE			)
             __UpperCAmelCase    							=torch.tensor([1]			).to(__SCREAMING_SNAKE_CASE			)
  
             with torch.no_grad():
                    __UpperCAmelCase    							=model(__SCREAMING_SNAKE_CASE   ,    __SCREAMING_SNAKE_CASE			).sample
  
             __UpperCAmelCase    							=output.abs().sum()
             __UpperCAmelCase    							=output.abs().max()
  
             assert (output_sum - 224.0_896).abs() < 0.5
             assert (output_max - 0.0_607).abs() < 4e-4
  
  
  
  
  class 							_A (    UpperCamelCase				,				UpperCamelCase				,				unittest.TestCase							):
      """simple docstring"""
  
      lowerCamelCase  :       Optional[Any]   =   UNetaDModel
      lowerCamelCase  :       str   =   'sample'
  
  
  
      @property
      def _a       (							self			:    Optional[Any]			)			->       Optional[Any]:
             __UpperCAmelCase    							=4
             __UpperCAmelCase    							=14
             __UpperCAmelCase    							=16
  
             __UpperCAmelCase    							=floats_tensor((batch_size, num_features, seq_len)			).to(__SCREAMING_SNAKE_CASE			)
             __UpperCAmelCase    							=torch.tensor([10] * batch_size			).to(__SCREAMING_SNAKE_CASE			)
  
             return {"sample": noise, "timestep": time_step}
  
  
  
      @property
      def _a       (							self			:    Tuple			)			->       List[Any]:
             return (4, 14, 16)
  
  
  
      @property
      def _a       (							self			:    Optional[Any]			)			->       Union[str, Any]:
             return (4, 14, 1)
  
  
  
      @unittest.skipIf(torch_device == """mps"""   ,    """mish op not supported in MPS"""			)
      def _a       (							self			:    List[str]			)			->       Optional[int]:
             super().test_determinism()
  
  
  
      @unittest.skipIf(torch_device == """mps"""   ,    """mish op not supported in MPS"""			)
      def _a       (							self			:    Optional[int]			)			->       Union[str, Any]:
             super().test_outputs_equivalence()
  
  
  
      @unittest.skipIf(torch_device == """mps"""   ,    """mish op not supported in MPS"""			)
      def _a       (							self			:    Optional[Any]			)			->       Dict:
             super().test_from_save_pretrained()
  
  
  
      @unittest.skipIf(torch_device == """mps"""   ,    """mish op not supported in MPS"""			)
      def _a       (							self			:    List[str]			)			->       str:
             super().test_from_save_pretrained_variant()
  
  
  
      @unittest.skipIf(torch_device == """mps"""   ,    """mish op not supported in MPS"""			)
      def _a       (							self			:    Optional[int]			)			->       Any:
             super().test_model_from_pretrained()
  
  
  
      @unittest.skipIf(torch_device == """mps"""   ,    """mish op not supported in MPS"""			)
      def _a       (							self			:    int			)			->       Optional[Any]:
             # UNetRL is a value-function is different output shape
             __UpperCAmelCase							,   __UpperCAmelCase    							=self.prepare_init_args_and_inputs_for_common()
             __UpperCAmelCase    							=self.model_class(**__SCREAMING_SNAKE_CASE			)
             model.to(__SCREAMING_SNAKE_CASE			)
             model.eval()
  
             with torch.no_grad():
                    __UpperCAmelCase    							=model(**__SCREAMING_SNAKE_CASE			)
  
                    if isinstance(__SCREAMING_SNAKE_CASE   ,    __SCREAMING_SNAKE_CASE			):
                           __UpperCAmelCase    							=output.sample
  
             self.assertIsNotNone(__SCREAMING_SNAKE_CASE			)
             __UpperCAmelCase    							=torch.Size((inputs_dict["""sample"""].shape[0], 1)			)
             self.assertEqual(output.shape   ,    __SCREAMING_SNAKE_CASE   ,    """Input and output shapes do not match"""			)
  
  
  
      def _a       (							self			:    Tuple			)			->       Any:
             pass
  
  
  
      def _a       (							self			:    str			)			->       Union[str, Any]:
             pass
  
  
  
      def _a       (							self			:    Dict			)			->       str:
             __UpperCAmelCase    							={
                 """in_channels""": 14,
                 """out_channels""": 14,
                 """down_block_types""": ["""DownResnetBlock1D""", """DownResnetBlock1D""", """DownResnetBlock1D""", """DownResnetBlock1D"""],
                 """up_block_types""": [],
                 """out_block_type""": """ValueFunction""",
                 """mid_block_type""": """ValueFunctionMidBlock1D""",
                 """block_out_channels""": [32, 64, 128, 256],
                 """layers_per_block""": 1,
                 """downsample_each_block""": True,
                 """use_timestep_embedding""": True,
                 """freq_shift""": 1.0,
                 """flip_sin_to_cos""": False,
                 """time_embedding_type""": """positional""",
                 """act_fn""": """mish""",
             }
             __UpperCAmelCase    							=self.dummy_input
             return init_dict, inputs_dict
  
  
  
      @unittest.skipIf(torch_device == """mps"""   ,    """mish op not supported in MPS"""			)
      def _a       (							self			:    Tuple			)			->       List[Any]:
             __UpperCAmelCase							,   __UpperCAmelCase    							=UNetaDModel.from_pretrained(
                 """bglick13/hopper-medium-v2-value-function-hor32"""   ,    output_loading_info=__SCREAMING_SNAKE_CASE   ,    subfolder="""value_function"""			)
             self.assertIsNotNone(__SCREAMING_SNAKE_CASE			)
             self.assertEqual(len(vf_loading_info["""missing_keys"""]			)   ,    0			)
  
             value_function.to(__SCREAMING_SNAKE_CASE			)
             __UpperCAmelCase    							=value_function(**self.dummy_input			)
  
             assert image is not None, "Make sure output is not None"
  
  
  
      @unittest.skipIf(torch_device == """mps"""   ,    """mish op not supported in MPS"""			)
      def _a       (							self			:    List[Any]			)			->       int:
             __UpperCAmelCase							,   __UpperCAmelCase    							=UNetaDModel.from_pretrained(
                 """bglick13/hopper-medium-v2-value-function-hor32"""   ,    output_loading_info=__SCREAMING_SNAKE_CASE   ,    subfolder="""value_function"""			)
             torch.manual_seed(0			)
             if torch.cuda.is_available():
                    torch.cuda.manual_seed_all(0			)
  
             __UpperCAmelCase    							=value_function.config.in_channels
             __UpperCAmelCase    							=14
             __UpperCAmelCase    							=torch.randn((1, seq_len, num_features)			).permute(
                 0   ,    2   ,    1			)  # match original, we can update values and remove
             __UpperCAmelCase    							=torch.full((num_features,)   ,    0			)
  
             with torch.no_grad():
                    __UpperCAmelCase    							=value_function(__SCREAMING_SNAKE_CASE   ,    __SCREAMING_SNAKE_CASE			).sample
  
             # fmt: off
             __UpperCAmelCase    							=torch.tensor([165.25] * seq_len			)
             # fmt: on
             self.assertTrue(torch.allclose(__SCREAMING_SNAKE_CASE   ,    __SCREAMING_SNAKE_CASE   ,    rtol=1e-3			)			)
  
  
  
      def _a       (							self			:    Dict			)			->       Optional[int]:
             # Not implemented yet for this UNet
             pass
  
  
  
  
  
style_context: 
  
  
  
  
  
  
  import tempfile
  
  import torch
  
  from diffusers import (
      DEISMultistepScheduler,
      DPMSolverMultistepScheduler,
      DPMSolverSinglestepScheduler,
      UniPCMultistepScheduler,
  )
  
  from .test_schedulers import SchedulerCommonTest
  
  
  
  class 							_A (    UpperCamelCase							):
      """simple docstring"""
  
      lowerCamelCase  :       str   =   (DPMSolverMultistepScheduler,)
      lowerCamelCase  :       List[str]   =   (('num_inference_steps', 25),)
  
  
  
      def _a       (							self			:    Dict   ,    **__SCREAMING_SNAKE_CASE			:    Optional[Any]			)			->       Dict:
             __UpperCAmelCase    							={
                 """num_train_timesteps""": 1000,
                 """beta_start""": 0.0_001,
                 """beta_end""": 0.02,
                 """beta_schedule""": """linear""",
                 """solver_order""": 2,
                 """prediction_type""": """epsilon""",
                 """thresholding""": False,
                 """sample_max_value""": 1.0,
                 """algorithm_type""": """dpmsolver++""",
                 """solver_type""": """midpoint""",
                 """lower_order_final""": False,
                 """lambda_min_clipped""": -float("""inf"""			),
                 """variance_type""": None,
             }
  
             config.update(**__SCREAMING_SNAKE_CASE			)
             return config
  
  
  
      def _a       (							self			:    Optional[Any]   ,    __SCREAMING_SNAKE_CASE			:    List[Any]=0   ,    **__SCREAMING_SNAKE_CASE			:    int			)			->       Dict:
             __UpperCAmelCase    							=dict(self.forward_default_kwargs			)
             __UpperCAmelCase    							=kwargs.pop("""num_inference_steps"""   ,    __SCREAMING_SNAKE_CASE			)
             __UpperCAmelCase    							=self.dummy_sample
             __UpperCAmelCase    							=0.1 * sample
             __UpperCAmelCase    							=[residual + 0.2, residual + 0.15, residual + 0.10]
  
             for scheduler_class in self.scheduler_classes:
                    __UpperCAmelCase    							=self.get_scheduler_config(**__SCREAMING_SNAKE_CASE			)
                    __UpperCAmelCase    							=scheduler_class(**__SCREAMING_SNAKE_CASE			)
                    scheduler.set_timesteps(__SCREAMING_SNAKE_CASE			)
                    # copy over dummy past residuals
                    __UpperCAmelCase    							=dummy_past_residuals[: scheduler.config.solver_order]
  
                    with tempfile.TemporaryDirectory() as tmpdirname:
                           scheduler.save_config(__SCREAMING_SNAKE_CASE			)
                           __UpperCAmelCase    							=scheduler_class.from_pretrained(__SCREAMING_SNAKE_CASE			)
                           new_scheduler.set_timesteps(__SCREAMING_SNAKE_CASE			)
                           # copy over dummy past residuals
                           __UpperCAmelCase    							=dummy_past_residuals[: new_scheduler.config.solver_order]
  
                    __UpperCAmelCase							,   __UpperCAmelCase    							=sample, sample
                    for t in range(__SCREAMING_SNAKE_CASE   ,    time_step + scheduler.config.solver_order + 1			):
                           __UpperCAmelCase    							=scheduler.step(__SCREAMING_SNAKE_CASE   ,    __SCREAMING_SNAKE_CASE   ,    __SCREAMING_SNAKE_CASE   ,    **__SCREAMING_SNAKE_CASE			).prev_sample
                           __UpperCAmelCase    							=new_scheduler.step(__SCREAMING_SNAKE_CASE   ,    __SCREAMING_SNAKE_CASE   ,    __SCREAMING_SNAKE_CASE   ,    **__SCREAMING_SNAKE_CASE			).prev_sample
  
                           assert torch.sum(torch.abs(output - new_output			)			) < 1e-5, "Scheduler outputs are not identical"
  
  
  
      def _a       (							self			:    Any			)			->       Union[str, Any]:
             pass
  
  
  
      def _a       (							self			:    Tuple   ,    __SCREAMING_SNAKE_CASE			:    List[str]=0   ,    **__SCREAMING_SNAKE_CASE			:    Dict			)			->       Optional[Any]:
             __UpperCAmelCase    							=dict(self.forward_default_kwargs			)
             __UpperCAmelCase    							=kwargs.pop("""num_inference_steps"""   ,    __SCREAMING_SNAKE_CASE			)
             __UpperCAmelCase    							=self.dummy_sample
             __UpperCAmelCase    							=0.1 * sample
             __UpperCAmelCase    							=[residual + 0.2, residual + 0.15, residual + 0.10]
  
             for scheduler_class in self.scheduler_classes:
                    __UpperCAmelCase    							=self.get_scheduler_config()
                    __UpperCAmelCase    							=scheduler_class(**__SCREAMING_SNAKE_CASE			)
                    scheduler.set_timesteps(__SCREAMING_SNAKE_CASE			)
  
                    # copy over dummy past residuals (must be after setting timesteps)
                    __UpperCAmelCase    							=dummy_past_residuals[: scheduler.config.solver_order]
  
                    with tempfile.TemporaryDirectory() as tmpdirname:
                           scheduler.save_config(__SCREAMING_SNAKE_CASE			)
                           __UpperCAmelCase    							=scheduler_class.from_pretrained(__SCREAMING_SNAKE_CASE			)
                           # copy over dummy past residuals
                           new_scheduler.set_timesteps(__SCREAMING_SNAKE_CASE			)
  
                           # copy over dummy past residual (must be after setting timesteps)
                           __UpperCAmelCase    							=dummy_past_residuals[: new_scheduler.config.solver_order]
  
                    __UpperCAmelCase    							=scheduler.step(__SCREAMING_SNAKE_CASE   ,    __SCREAMING_SNAKE_CASE   ,    __SCREAMING_SNAKE_CASE   ,    **__SCREAMING_SNAKE_CASE			).prev_sample
                    __UpperCAmelCase    							=new_scheduler.step(__SCREAMING_SNAKE_CASE   ,    __SCREAMING_SNAKE_CASE   ,    __SCREAMING_SNAKE_CASE   ,    **__SCREAMING_SNAKE_CASE			).prev_sample
  
                    assert torch.sum(torch.abs(output - new_output			)			) < 1e-5, "Scheduler outputs are not identical"
  
  
  
      def _a       (							self			:    Union[str, Any]   ,    __SCREAMING_SNAKE_CASE			:    Union[str, Any]=None   ,    **__SCREAMING_SNAKE_CASE			:    Optional[int]			)			->       Optional[Any]:
             if scheduler is None:
                    __UpperCAmelCase    							=self.scheduler_classes[0]
                    __UpperCAmelCase    							=self.get_scheduler_config(**__SCREAMING_SNAKE_CASE			)
                    __UpperCAmelCase    							=scheduler_class(**__SCREAMING_SNAKE_CASE			)
  
             __UpperCAmelCase    							=10
             __UpperCAmelCase    							=self.dummy_model()
             __UpperCAmelCase    							=self.dummy_sample_deter
             scheduler.set_timesteps(__SCREAMING_SNAKE_CASE			)
  
             for i, t in enumerate(scheduler.timesteps			):
                    __UpperCAmelCase    							=model(__SCREAMING_SNAKE_CASE   ,    __SCREAMING_SNAKE_CASE			)
                    __UpperCAmelCase    							=scheduler.step(__SCREAMING_SNAKE_CASE   ,    __SCREAMING_SNAKE_CASE   ,    __SCREAMING_SNAKE_CASE			).prev_sample
  
             return sample
  
  
  
      def _a       (							self			:    Dict			)			->       Optional[int]:
             __UpperCAmelCase    							=dict(self.forward_default_kwargs			)
  
             __UpperCAmelCase    							=kwargs.pop("""num_inference_steps"""   ,    __SCREAMING_SNAKE_CASE			)
  
             for scheduler_class in self.scheduler_classes:
                    __UpperCAmelCase    							=self.get_scheduler_config()
                    __UpperCAmelCase    							=scheduler_class(**__SCREAMING_SNAKE_CASE			)
  
                    __UpperCAmelCase    							=self.dummy_sample
                    __UpperCAmelCase    							=0.1 * sample
  
                    if num_inference_steps is not None and hasattr(__SCREAMING_SNAKE_CASE   ,    """set_timesteps"""			):
                           scheduler.set_timesteps(__SCREAMING_SNAKE_CASE			)
                    elif num_inference_steps is not None and not hasattr(__SCREAMING_SNAKE_CASE   ,    """set_timesteps"""			):
                           __UpperCAmelCase    							=num_inference_steps
  
                    # copy over dummy past residuals (must be done after set_timesteps)
                    __UpperCAmelCase    							=[residual + 0.2, residual + 0.15, residual + 0.10]
                    __UpperCAmelCase    							=dummy_past_residuals[: scheduler.config.solver_order]
  
                    __UpperCAmelCase    							=scheduler.timesteps[5]
                    __UpperCAmelCase    							=scheduler.timesteps[6]
  
                    __UpperCAmelCase    							=scheduler.step(__SCREAMING_SNAKE_CASE   ,    __SCREAMING_SNAKE_CASE   ,    __SCREAMING_SNAKE_CASE   ,    **__SCREAMING_SNAKE_CASE			).prev_sample
                    __UpperCAmelCase    							=scheduler.step(__SCREAMING_SNAKE_CASE   ,    __SCREAMING_SNAKE_CASE   ,    __SCREAMING_SNAKE_CASE   ,    **__SCREAMING_SNAKE_CASE			).prev_sample
  
                    self.assertEqual(output_a.shape   ,    sample.shape			)
                    self.assertEqual(output_a.shape   ,    output_a.shape			)
  
  
  
      def _a       (							self			:    List[Any]			)			->       Tuple:
             for timesteps in [25, 50, 100, 999, 1000]:
                    self.check_over_configs(num_train_timesteps=__SCREAMING_SNAKE_CASE			)
  
  
  
      def _a       (							self			:    Union[str, Any]			)			->       int:
             self.check_over_configs(thresholding=__SCREAMING_SNAKE_CASE			)
             for order in [1, 2, 3]:
                    for solver_type in ["midpoint", "heun"]:
                           for threshold in [0.5, 1.0, 2.0]:
                                  for prediction_type in ["epsilon", "sample"]:
                                         self.check_over_configs(
                                             thresholding=__SCREAMING_SNAKE_CASE   ,    prediction_type=__SCREAMING_SNAKE_CASE   ,    sample_max_value=__SCREAMING_SNAKE_CASE   ,    algorithm_type="""dpmsolver++"""   ,    solver_order=__SCREAMING_SNAKE_CASE   ,    solver_type=__SCREAMING_SNAKE_CASE   ,    )
  
  
  
      def _a       (							self			:    Union[str, Any]			)			->       List[str]:
             for prediction_type in ["epsilon", "v_prediction"]:
                    self.check_over_configs(prediction_type=__SCREAMING_SNAKE_CASE			)
  
  
  
      def _a       (							self			:    Union[str, Any]			)			->       Tuple:
             for algorithm_type in ["dpmsolver", "dpmsolver++", "sde-dpmsolver", "sde-dpmsolver++"]:
                    for solver_type in ["midpoint", "heun"]:
                           for order in [1, 2, 3]:
                                  for prediction_type in ["epsilon", "sample"]:
                                         if algorithm_type in ["sde-dpmsolver", "sde-dpmsolver++"]:
                                                if order == 3:
                                                       continue
                                         else:
                                                self.check_over_configs(
                                                    solver_order=__SCREAMING_SNAKE_CASE   ,    solver_type=__SCREAMING_SNAKE_CASE   ,    prediction_type=__SCREAMING_SNAKE_CASE   ,    algorithm_type=__SCREAMING_SNAKE_CASE   ,    )
                                         __UpperCAmelCase    							=self.full_loop(
                                             solver_order=__SCREAMING_SNAKE_CASE   ,    solver_type=__SCREAMING_SNAKE_CASE   ,    prediction_type=__SCREAMING_SNAKE_CASE   ,    algorithm_type=__SCREAMING_SNAKE_CASE   ,    )
                                         assert not torch.isnan(__SCREAMING_SNAKE_CASE			).any(), "Samples have nan numbers"
  
  
  
      def _a       (							self			:    Dict			)			->       str:
             self.check_over_configs(lower_order_final=__SCREAMING_SNAKE_CASE			)
             self.check_over_configs(lower_order_final=__SCREAMING_SNAKE_CASE			)
  
  
  
      def _a       (							self			:    Union[str, Any]			)			->       Optional[Any]:
             self.check_over_configs(lambda_min_clipped=-float("""inf"""			)			)
             self.check_over_configs(lambda_min_clipped=-5.1			)
  
  
  
      def _a       (							self			:    Any			)			->       List[str]:
             self.check_over_configs(variance_type=__SCREAMING_SNAKE_CASE			)
             self.check_over_configs(variance_type="""learned_range"""			)
  
  
  
      def _a       (							self			:    List[Any]			)			->       int:
             for num_inference_steps in [1, 2, 3, 5, 10, 50, 100, 999, 1000]:
                    self.check_over_forward(num_inference_steps=__SCREAMING_SNAKE_CASE   ,    time_step=0			)
  
  
  
      def _a       (							self			:    Optional[int]			)			->       str:
             __UpperCAmelCase    							=self.full_loop()
             __UpperCAmelCase    							=torch.mean(torch.abs(__SCREAMING_SNAKE_CASE			)			)
  
             assert abs(result_mean.item() - 0.3_301			) < 1e-3
  
  
  
      def _a       (							self			:    Union[str, Any]			)			->       str:
             __UpperCAmelCase    							=self.full_loop(thresholding=__SCREAMING_SNAKE_CASE   ,    dynamic_thresholding_ratio=0.87   ,    sample_max_value=0.5			)
             __UpperCAmelCase    							=torch.mean(torch.abs(__SCREAMING_SNAKE_CASE			)			)
  
             assert abs(result_mean.item() - 1.1_364			) < 1e-3
  
  
  
      def _a       (							self			:    List[Any]			)			->       List[Any]:
             __UpperCAmelCase    							=self.full_loop(prediction_type="""v_prediction"""			)
             __UpperCAmelCase    							=torch.mean(torch.abs(__SCREAMING_SNAKE_CASE			)			)
  
             assert abs(result_mean.item() - 0.2_251			) < 1e-3
  
  
  
      def _a       (							self			:    int			)			->       Union[str, Any]:
             __UpperCAmelCase    							=self.full_loop(prediction_type="""v_prediction"""   ,    use_karras_sigmas=__SCREAMING_SNAKE_CASE			)
             __UpperCAmelCase    							=torch.mean(torch.abs(__SCREAMING_SNAKE_CASE			)			)
  
             assert abs(result_mean.item() - 0.2_096			) < 1e-3
  
  
  
      def _a       (							self			:    int			)			->       Optional[Any]:
             # make sure that iterating over schedulers with same config names gives same results
             # for defaults
             __UpperCAmelCase    							=DPMSolverMultistepScheduler(**self.get_scheduler_config()			)
             __UpperCAmelCase    							=self.full_loop(scheduler=__SCREAMING_SNAKE_CASE			)
             __UpperCAmelCase    							=torch.mean(torch.abs(__SCREAMING_SNAKE_CASE			)			)
  
             assert abs(result_mean.item() - 0.3_301			) < 1e-3
  
             __UpperCAmelCase    							=DPMSolverSinglestepScheduler.from_config(scheduler.config			)
             __UpperCAmelCase    							=UniPCMultistepScheduler.from_config(scheduler.config			)
             __UpperCAmelCase    							=DEISMultistepScheduler.from_config(scheduler.config			)
             __UpperCAmelCase    							=DPMSolverMultistepScheduler.from_config(scheduler.config			)
  
             __UpperCAmelCase    							=self.full_loop(scheduler=__SCREAMING_SNAKE_CASE			)
             __UpperCAmelCase    							=torch.mean(torch.abs(__SCREAMING_SNAKE_CASE			)			)
  
             assert abs(result_mean.item() - 0.3_301			) < 1e-3
  
  
  
      def _a       (							self			:    List[Any]			)			->       str:
             __UpperCAmelCase    							=self.scheduler_classes[0]
             __UpperCAmelCase    							=self.get_scheduler_config(thresholding=__SCREAMING_SNAKE_CASE   ,    dynamic_thresholding_ratio=0			)
             __UpperCAmelCase    							=scheduler_class(**__SCREAMING_SNAKE_CASE			)
  
             __UpperCAmelCase    							=10
             __UpperCAmelCase    							=self.dummy_model()
             __UpperCAmelCase    							=self.dummy_sample_deter.half()
             scheduler.set_timesteps(__SCREAMING_SNAKE_CASE			)
  
             for i, t in enumerate(scheduler.timesteps			):
                    __UpperCAmelCase    							=model(__SCREAMING_SNAKE_CASE   ,    __SCREAMING_SNAKE_CASE			)
                    __UpperCAmelCase    							=scheduler.step(__SCREAMING_SNAKE_CASE   ,    __SCREAMING_SNAKE_CASE   ,    __SCREAMING_SNAKE_CASE			).prev_sample
  
             assert sample.dtype == torch.floataa
  
  
  
      def _a       (							self			:    Optional[int]   ,    **__SCREAMING_SNAKE_CASE			:    Tuple			)			->       Optional[int]:
             for scheduler_class in self.scheduler_classes:
                    __UpperCAmelCase    							=self.get_scheduler_config(**__SCREAMING_SNAKE_CASE			)
                    __UpperCAmelCase    							=scheduler_class(**__SCREAMING_SNAKE_CASE			)
  
                    scheduler.set_timesteps(scheduler.config.num_train_timesteps			)
                    assert len(scheduler.timesteps.unique()			) == scheduler.num_inference_steps
  
  
  
  
  