





# This model implementation is heavily based on:

import gc
import random
import tempfile
import unittest

import numpy as np
import torch
from PIL import Image
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer

from diffusers import (
    AutoencoderKL,
    ControlNetModel,
    DDIMScheduler,
    StableDiffusionControlNetInpaintPipeline,
    UNetaDConditionModel,
)
from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion_controlnet import MultiControlNetModel
from diffusers.utils import floats_tensor, load_image, load_numpy, randn_tensor, slow, torch_device
from diffusers.utils.import_utils import is_xformers_available
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..pipeline_params import (
    TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS,
    TEXT_GUIDED_IMAGE_INPAINTING_PARAMS,
    TEXT_TO_IMAGE_IMAGE_PARAMS,
)
from ..test_pipelines_common import (
    PipelineKarrasSchedulerTesterMixin,
    PipelineLatentTesterMixin,
    PipelineTesterMixin,
)


enable_full_determinism()





class A_   (     _lowerCamelCase					, _lowerCamelCase					, _lowerCamelCase					, unittest.TestCase  ):
   lowerCAmelCase__  	=					StableDiffusionControlNetInpaintPipeline
   lowerCAmelCase__  	=					TEXT_GUIDED_IMAGE_INPAINTING_PARAMS
   lowerCAmelCase__  	=					TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS
   lowerCAmelCase__  	=					frozenset({"""control_image"""}  )  # skip `image` and `mask` for now, only test for control_image
   lowerCAmelCase__  	=					TEXT_TO_IMAGE_IMAGE_PARAMS




   def _lowerCAmelCase (self      :Any					)->   Dict:
         torch.manual_seed(0					)
         __A			  =							UNetaDConditionModel(
             block_out_channels=(32, 64)       ,  layers_per_block=2       ,  sample_size=32       ,  in_channels=9       ,  out_channels=4       ,  down_block_types=('''DownBlock2D''', '''CrossAttnDownBlock2D''')       ,  up_block_types=('''CrossAttnUpBlock2D''', '''UpBlock2D''')       ,  cross_attention_dim=32       ,  )
         torch.manual_seed(0					)
         __A			  =							ControlNetModel(
             block_out_channels=(32, 64)       ,  layers_per_block=2       ,  in_channels=4       ,  down_block_types=('''DownBlock2D''', '''CrossAttnDownBlock2D''')       ,  cross_attention_dim=32       ,  conditioning_embedding_out_channels=(16, 32)       ,  )
         torch.manual_seed(0					)
         __A			  =							DDIMScheduler(
             beta_start=0.0_0_0_8_5       ,  beta_end=0.0_1_2       ,  beta_schedule='''scaled_linear'''       ,  clip_sample=_UpperCamelCase       ,  set_alpha_to_one=_UpperCamelCase       ,  )
         torch.manual_seed(0					)
         __A			  =							AutoencoderKL(
             block_out_channels=[32, 64]       ,  in_channels=3       ,  out_channels=3       ,  down_block_types=['''DownEncoderBlock2D''', '''DownEncoderBlock2D''']       ,  up_block_types=['''UpDecoderBlock2D''', '''UpDecoderBlock2D''']       ,  latent_channels=4       ,  )
         torch.manual_seed(0					)
         __A			  =							CLIPTextConfig(
             bos_token_id=0       ,  eos_token_id=2       ,  hidden_size=32       ,  intermediate_size=37       ,  layer_norm_eps=1e-05       ,  num_attention_heads=4       ,  num_hidden_layers=5       ,  pad_token_id=1       ,  vocab_size=1000       ,  )
         __A			  =							CLIPTextModel(_UpperCamelCase					)
         __A			  =							CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''					)

         __A			  =							{
             '''unet''': unet,
             '''controlnet''': controlnet,
             '''scheduler''': scheduler,
             '''vae''': vae,
             '''text_encoder''': text_encoder,
             '''tokenizer''': tokenizer,
             '''safety_checker''': None,
             '''feature_extractor''': None,
         }
         return components




   def _lowerCAmelCase (self      :List[Any]       ,  _UpperCamelCase      :Tuple       ,  _UpperCamelCase      :int=0					)->   Tuple:
         if str(_UpperCamelCase					).startswith('''mps'''					):
               __A			  =							torch.manual_seed(_UpperCamelCase					)
         else:
               __A			  =							torch.Generator(device=_UpperCamelCase					).manual_seed(_UpperCamelCase					)

         __A			  =							2
         __A			  =							randn_tensor(
             (1, 3, 32 * controlnet_embedder_scale_factor, 32 * controlnet_embedder_scale_factor)       ,  generator=_UpperCamelCase       ,  device=torch.device(_UpperCamelCase					)       ,  )
         __A			  =							floats_tensor((1, 3, 32, 32)       ,  rng=random.Random(_UpperCamelCase					)					).to(_UpperCamelCase					)
         __A			  =							init_image.cpu().permute(0       ,  2       ,  3       ,  1					)[0]

         __A			  =							Image.fromarray(np.uinta(_UpperCamelCase					)					).convert('''RGB'''					).resize((64, 64)					)
         __A			  =							Image.fromarray(np.uinta(init_image + 4					)					).convert('''RGB'''					).resize((64, 64)					)

         __A			  =							{
             '''prompt''': '''A painting of a squirrel eating a burger''',
             '''generator''': generator,
             '''num_inference_steps''': 2,
             '''guidance_scale''': 6.0,
             '''output_type''': '''numpy''',
             '''image''': image,
             '''mask_image''': mask_image,
             '''control_image''': control_image,
         }

         return inputs




   def _lowerCAmelCase (self      :List[Any]					)->   List[Any]:
         return self._test_attention_slicing_forward_pass(expected_max_diff=2e-3					)




   @unittest.skipIf(
       torch_device != '''cuda''' or not is_xformers_available()       ,  reason='''XFormers attention is only available with CUDA and `xformers` installed'''       ,  )
   def _lowerCAmelCase (self      :Optional[int]					)->   int:
         self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=2e-3					)






   def _lowerCAmelCase (self      :Dict					)->   int:
         self._test_inference_batch_single_identical(expected_max_diff=2e-3					)





class A_   (     _lowerCamelCase  ):
   lowerCAmelCase__  	=					StableDiffusionControlNetInpaintPipeline
   lowerCAmelCase__  	=					TEXT_GUIDED_IMAGE_INPAINTING_PARAMS
   lowerCAmelCase__  	=					TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS
   lowerCAmelCase__  	=					frozenset([]  )




   def _lowerCAmelCase (self      :Optional[Any]					)->   Any:
         torch.manual_seed(0					)
         __A			  =							UNetaDConditionModel(
             block_out_channels=(32, 64)       ,  layers_per_block=2       ,  sample_size=32       ,  in_channels=4       ,  out_channels=4       ,  down_block_types=('''DownBlock2D''', '''CrossAttnDownBlock2D''')       ,  up_block_types=('''CrossAttnUpBlock2D''', '''UpBlock2D''')       ,  cross_attention_dim=32       ,  )
         torch.manual_seed(0					)
         __A			  =							ControlNetModel(
             block_out_channels=(32, 64)       ,  layers_per_block=2       ,  in_channels=4       ,  down_block_types=('''DownBlock2D''', '''CrossAttnDownBlock2D''')       ,  cross_attention_dim=32       ,  conditioning_embedding_out_channels=(16, 32)       ,  )
         torch.manual_seed(0					)
         __A			  =							DDIMScheduler(
             beta_start=0.0_0_0_8_5       ,  beta_end=0.0_1_2       ,  beta_schedule='''scaled_linear'''       ,  clip_sample=_UpperCamelCase       ,  set_alpha_to_one=_UpperCamelCase       ,  )
         torch.manual_seed(0					)
         __A			  =							AutoencoderKL(
             block_out_channels=[32, 64]       ,  in_channels=3       ,  out_channels=3       ,  down_block_types=['''DownEncoderBlock2D''', '''DownEncoderBlock2D''']       ,  up_block_types=['''UpDecoderBlock2D''', '''UpDecoderBlock2D''']       ,  latent_channels=4       ,  )
         torch.manual_seed(0					)
         __A			  =							CLIPTextConfig(
             bos_token_id=0       ,  eos_token_id=2       ,  hidden_size=32       ,  intermediate_size=37       ,  layer_norm_eps=1e-05       ,  num_attention_heads=4       ,  num_hidden_layers=5       ,  pad_token_id=1       ,  vocab_size=1000       ,  )
         __A			  =							CLIPTextModel(_UpperCamelCase					)
         __A			  =							CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''					)

         __A			  =							{
             '''unet''': unet,
             '''controlnet''': controlnet,
             '''scheduler''': scheduler,
             '''vae''': vae,
             '''text_encoder''': text_encoder,
             '''tokenizer''': tokenizer,
             '''safety_checker''': None,
             '''feature_extractor''': None,
         }
         return components





class A_   (     _lowerCamelCase					, _lowerCamelCase					, unittest.TestCase  ):
   lowerCAmelCase__  	=					StableDiffusionControlNetInpaintPipeline
   lowerCAmelCase__  	=					TEXT_GUIDED_IMAGE_INPAINTING_PARAMS
   lowerCAmelCase__  	=					TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS




   def _lowerCAmelCase (self      :Any					)->   Tuple:
         torch.manual_seed(0					)
         __A			  =							UNetaDConditionModel(
             block_out_channels=(32, 64)       ,  layers_per_block=2       ,  sample_size=32       ,  in_channels=9       ,  out_channels=4       ,  down_block_types=('''DownBlock2D''', '''CrossAttnDownBlock2D''')       ,  up_block_types=('''CrossAttnUpBlock2D''', '''UpBlock2D''')       ,  cross_attention_dim=32       ,  )
         torch.manual_seed(0					)

         def init_weights(_UpperCamelCase      :Optional[int]					):
               if isinstance(_UpperCamelCase       ,  torch.nn.Convad					):
                     torch.nn.init.normal(m.weight					)
                     m.bias.data.fill_(1.0					)

         __A			  =							ControlNetModel(
             block_out_channels=(32, 64)       ,  layers_per_block=2       ,  in_channels=4       ,  down_block_types=('''DownBlock2D''', '''CrossAttnDownBlock2D''')       ,  cross_attention_dim=32       ,  conditioning_embedding_out_channels=(16, 32)       ,  )
         controlneta.controlnet_down_blocks.apply(_UpperCamelCase					)

         torch.manual_seed(0					)
         __A			  =							ControlNetModel(
             block_out_channels=(32, 64)       ,  layers_per_block=2       ,  in_channels=4       ,  down_block_types=('''DownBlock2D''', '''CrossAttnDownBlock2D''')       ,  cross_attention_dim=32       ,  conditioning_embedding_out_channels=(16, 32)       ,  )
         controlneta.controlnet_down_blocks.apply(_UpperCamelCase					)

         torch.manual_seed(0					)
         __A			  =							DDIMScheduler(
             beta_start=0.0_0_0_8_5       ,  beta_end=0.0_1_2       ,  beta_schedule='''scaled_linear'''       ,  clip_sample=_UpperCamelCase       ,  set_alpha_to_one=_UpperCamelCase       ,  )
         torch.manual_seed(0					)
         __A			  =							AutoencoderKL(
             block_out_channels=[32, 64]       ,  in_channels=3       ,  out_channels=3       ,  down_block_types=['''DownEncoderBlock2D''', '''DownEncoderBlock2D''']       ,  up_block_types=['''UpDecoderBlock2D''', '''UpDecoderBlock2D''']       ,  latent_channels=4       ,  )
         torch.manual_seed(0					)
         __A			  =							CLIPTextConfig(
             bos_token_id=0       ,  eos_token_id=2       ,  hidden_size=32       ,  intermediate_size=37       ,  layer_norm_eps=1e-05       ,  num_attention_heads=4       ,  num_hidden_layers=5       ,  pad_token_id=1       ,  vocab_size=1000       ,  )
         __A			  =							CLIPTextModel(_UpperCamelCase					)
         __A			  =							CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''					)

         __A			  =							MultiControlNetModel([controlneta, controlneta]					)

         __A			  =							{
             '''unet''': unet,
             '''controlnet''': controlnet,
             '''scheduler''': scheduler,
             '''vae''': vae,
             '''text_encoder''': text_encoder,
             '''tokenizer''': tokenizer,
             '''safety_checker''': None,
             '''feature_extractor''': None,
         }
         return components




   def _lowerCAmelCase (self      :Tuple       ,  _UpperCamelCase      :str       ,  _UpperCamelCase      :List[str]=0					)->   Optional[Any]:
         if str(_UpperCamelCase					).startswith('''mps'''					):
               __A			  =							torch.manual_seed(_UpperCamelCase					)
         else:
               __A			  =							torch.Generator(device=_UpperCamelCase					).manual_seed(_UpperCamelCase					)

         __A			  =							2

         __A			  =							[
             randn_tensor(
                 (1, 3, 32 * controlnet_embedder_scale_factor, 32 * controlnet_embedder_scale_factor)       ,  generator=_UpperCamelCase       ,  device=torch.device(_UpperCamelCase					)       ,  ),
             randn_tensor(
                 (1, 3, 32 * controlnet_embedder_scale_factor, 32 * controlnet_embedder_scale_factor)       ,  generator=_UpperCamelCase       ,  device=torch.device(_UpperCamelCase					)       ,  ),
         ]
         __A			  =							floats_tensor((1, 3, 32, 32)       ,  rng=random.Random(_UpperCamelCase					)					).to(_UpperCamelCase					)
         __A			  =							init_image.cpu().permute(0       ,  2       ,  3       ,  1					)[0]

         __A			  =							Image.fromarray(np.uinta(_UpperCamelCase					)					).convert('''RGB'''					).resize((64, 64)					)
         __A			  =							Image.fromarray(np.uinta(init_image + 4					)					).convert('''RGB'''					).resize((64, 64)					)

         __A			  =							{
             '''prompt''': '''A painting of a squirrel eating a burger''',
             '''generator''': generator,
             '''num_inference_steps''': 2,
             '''guidance_scale''': 6.0,
             '''output_type''': '''numpy''',
             '''image''': image,
             '''mask_image''': mask_image,
             '''control_image''': control_image,
         }

         return inputs




   def _lowerCAmelCase (self      :str					)->   List[Any]:
         __A			  =							self.get_dummy_components()
         __A			  =							self.pipeline_class(**_UpperCamelCase					)
         pipe.to(_UpperCamelCase					)

         __A			  =							1_0.0
         __A			  =							4

         __A			  =							self.get_dummy_inputs(_UpperCamelCase					)
         __A			  =							steps
         __A			  =							scale
         __A			  =							pipe(**_UpperCamelCase					)[0]

         __A			  =							self.get_dummy_inputs(_UpperCamelCase					)
         __A			  =							steps
         __A			  =							scale
         __A			  =							pipe(**_UpperCamelCase       ,  control_guidance_start=0.1       ,  control_guidance_end=0.2					)[0]

         __A			  =							self.get_dummy_inputs(_UpperCamelCase					)
         __A			  =							steps
         __A			  =							scale
         __A			  =							pipe(**_UpperCamelCase       ,  control_guidance_start=[0.1, 0.3]       ,  control_guidance_end=[0.2, 0.7]					)[0]

         __A			  =							self.get_dummy_inputs(_UpperCamelCase					)
         __A			  =							steps
         __A			  =							scale
         __A			  =							pipe(**_UpperCamelCase       ,  control_guidance_start=0.4       ,  control_guidance_end=[0.5, 0.8]					)[0]

         # make sure that all outputs are different
         assert np.sum(np.abs(output_a - output_a					)					) > 1e-3
         assert np.sum(np.abs(output_a - output_a					)					) > 1e-3
         assert np.sum(np.abs(output_a - output_a					)					) > 1e-3




   def _lowerCAmelCase (self      :Optional[int]					)->   Dict:
         return self._test_attention_slicing_forward_pass(expected_max_diff=2e-3					)




   @unittest.skipIf(
       torch_device != '''cuda''' or not is_xformers_available()       ,  reason='''XFormers attention is only available with CUDA and `xformers` installed'''       ,  )
   def _lowerCAmelCase (self      :List[str]					)->   Optional[Any]:
         self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=2e-3					)




   def _lowerCAmelCase (self      :List[Any]					)->   Optional[Any]:
         self._test_inference_batch_single_identical(expected_max_diff=2e-3					)






   def _lowerCAmelCase (self      :Any					)->   List[Any]:
         __A			  =							self.get_dummy_components()
         __A			  =							self.pipeline_class(**_UpperCamelCase					)
         pipe.to(_UpperCamelCase					)
         pipe.set_progress_bar_config(disable=_UpperCamelCase					)
         with tempfile.TemporaryDirectory() as tmpdir:
               try:
                     # save_pretrained is not implemented for Multi-ControlNet
                     pipe.save_pretrained(_UpperCamelCase					)
               except NotImplementedError:
                     pass





@slow
@require_torch_gpu
class A_   (     unittest.TestCase  ):




   def _lowerCAmelCase (self      :List[Any]					)->   Optional[int]:
         super().tearDown()
         gc.collect()
         torch.cuda.empty_cache()




   def _lowerCAmelCase (self      :Union[str, Any]					)->   Optional[int]:
         __A			  =							ControlNetModel.from_pretrained('''lllyasviel/sd-controlnet-canny'''					)

         __A			  =							StableDiffusionControlNetInpaintPipeline.from_pretrained(
             '''runwayml/stable-diffusion-inpainting'''       ,  safety_checker=_UpperCamelCase       ,  controlnet=_UpperCamelCase					)
         pipe.enable_model_cpu_offload()
         pipe.set_progress_bar_config(disable=_UpperCamelCase					)

         __A			  =							torch.Generator(device='''cpu'''					).manual_seed(0					)
         __A			  =							load_image(
             '''https://huggingface.co/lllyasviel/sd-controlnet-canny/resolve/main/images/bird.png'''					).resize((512, 512)					)

         __A			  =							load_image(
             '''https://huggingface.co/datasets/diffusers/test-arrays/resolve/main'''
             '''/stable_diffusion_inpaint/input_bench_mask.png'''					).resize((512, 512)					)

         __A			  =							'''pitch black hole'''

         __A			  =							load_image(
             '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd_controlnet/bird_canny.png'''					).resize((512, 512)					)

         __A			  =							pipe(
             _UpperCamelCase       ,  image=_UpperCamelCase       ,  mask_image=_UpperCamelCase       ,  control_image=_UpperCamelCase       ,  generator=_UpperCamelCase       ,  output_type='''np'''       ,  num_inference_steps=3       ,  )

         __A			  =							output.images[0]

         assert image.shape == (512, 512, 3)

         __A			  =							load_numpy(
             '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd_controlnet/inpaint.npy'''					)

         assert np.abs(expected_image - image					).max() < 9e-2






   def _lowerCAmelCase (self      :Union[str, Any]					)->   int:
         __A			  =							ControlNetModel.from_pretrained('''lllyasviel/control_v11p_sd15_inpaint'''					)

         __A			  =							StableDiffusionControlNetInpaintPipeline.from_pretrained(
             '''runwayml/stable-diffusion-v1-5'''       ,  safety_checker=_UpperCamelCase       ,  controlnet=_UpperCamelCase					)
         __A			  =							DDIMScheduler.from_config(pipe.scheduler.config					)
         pipe.enable_model_cpu_offload()
         pipe.set_progress_bar_config(disable=_UpperCamelCase					)

         __A			  =							torch.Generator(device='''cpu'''					).manual_seed(33					)

         __A			  =							load_image(
             '''https://huggingface.co/datasets/diffusers/test-arrays/resolve/main/stable_diffusion_inpaint/boy.png'''					)
         __A			  =							init_image.resize((512, 512)					)

         __A			  =							load_image(
             '''https://huggingface.co/datasets/diffusers/test-arrays/resolve/main/stable_diffusion_inpaint/boy_mask.png'''					)
         __A			  =							mask_image.resize((512, 512)					)

         __A			  =							'''a handsome man with ray-ban sunglasses'''

         def make_inpaint_condition(_UpperCamelCase      :int       ,  _UpperCamelCase      :str					):
               __A			  =							np.array(image.convert('''RGB'''					)					).astype(np.floataa					) / 2_5_5.0
               __A			  =							np.array(image_mask.convert('''L'''					)					).astype(np.floataa					) / 2_5_5.0

               assert image.shape[0:1] == image_mask.shape[0:1], "image and image_mask must have the same image size"
               __A			  =							-1.0  # set as masked pixel
               __A			  =							np.expand_dims(_UpperCamelCase       ,  0					).transpose(0       ,  3       ,  1       ,  2					)
               __A			  =							torch.from_numpy(_UpperCamelCase					)
               return image

         __A			  =							make_inpaint_condition(_UpperCamelCase       ,  _UpperCamelCase					)

         __A			  =							pipe(
             _UpperCamelCase       ,  image=_UpperCamelCase       ,  mask_image=_UpperCamelCase       ,  control_image=_UpperCamelCase       ,  guidance_scale=9.0       ,  eta=1.0       ,  generator=_UpperCamelCase       ,  num_inference_steps=20       ,  output_type='''np'''       ,  )
         __A			  =							output.images[0]

         assert image.shape == (512, 512, 3)

         __A			  =							load_numpy(
             '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd_controlnet/boy_ray_ban.npy'''					)

         assert np.abs(expected_image - image					).max() < 9e-2












import torch

from diffusers import LMSDiscreteScheduler
from diffusers.utils import torch_device

from .test_schedulers import SchedulerCommonTest





class A_   (     _lowerCamelCase  ):
   lowerCAmelCase__  	=					(LMSDiscreteScheduler,)
   lowerCAmelCase__  	=					10




   def _lowerCAmelCase (self      :List[str]       ,  **_UpperCamelCase      :Optional[int]					)->   List[str]:
         __A			  =							{
             '''num_train_timesteps''': 1100,
             '''beta_start''': 0.0_0_0_1,
             '''beta_end''': 0.0_2,
             '''beta_schedule''': '''linear''',
         }

         config.update(**_UpperCamelCase					)
         return config




   def _lowerCAmelCase (self      :List[str]					)->   Tuple:
         for timesteps in [10, 50, 100, 1000]:
               self.check_over_configs(num_train_timesteps=_UpperCamelCase					)




   def _lowerCAmelCase (self      :Dict					)->   Optional[int]:
         for beta_start, beta_end in zip([0.0_0_0_0_1, 0.0_0_0_1, 0.0_0_1]       ,  [0.0_0_0_2, 0.0_0_2, 0.0_2]					):
               self.check_over_configs(beta_start=_UpperCamelCase       ,  beta_end=_UpperCamelCase					)




   def _lowerCAmelCase (self      :Optional[int]					)->   Any:
         for schedule in ["linear", "scaled_linear"]:
               self.check_over_configs(beta_schedule=_UpperCamelCase					)




   def _lowerCAmelCase (self      :List[str]					)->   str:
         for prediction_type in ["epsilon", "v_prediction"]:
               self.check_over_configs(prediction_type=_UpperCamelCase					)




   def _lowerCAmelCase (self      :str					)->   List[str]:
         for t in [0, 500, 800]:
               self.check_over_forward(time_step=_UpperCamelCase					)




   def _lowerCAmelCase (self      :Optional[Any]					)->   Tuple:
         __A			  =							self.scheduler_classes[0]
         __A			  =							self.get_scheduler_config()
         __A			  =							scheduler_class(**_UpperCamelCase					)

         scheduler.set_timesteps(self.num_inference_steps					)

         __A			  =							self.dummy_model()
         __A			  =							self.dummy_sample_deter * scheduler.init_noise_sigma

         for i, t in enumerate(scheduler.timesteps					):
               __A			  =							scheduler.scale_model_input(_UpperCamelCase       ,  _UpperCamelCase					)

               __A			  =							model(_UpperCamelCase       ,  _UpperCamelCase					)

               __A			  =							scheduler.step(_UpperCamelCase       ,  _UpperCamelCase       ,  _UpperCamelCase					)
               __A			  =							output.prev_sample

         __A			  =							torch.sum(torch.abs(_UpperCamelCase					)					)
         __A			  =							torch.mean(torch.abs(_UpperCamelCase					)					)

         assert abs(result_sum.item() - 1_0_0_6.3_8_8					) < 1e-2
         assert abs(result_mean.item() - 1.3_1					) < 1e-3




   def _lowerCAmelCase (self      :Optional[Any]					)->   Optional[int]:
         __A			  =							self.scheduler_classes[0]
         __A			  =							self.get_scheduler_config(prediction_type='''v_prediction'''					)
         __A			  =							scheduler_class(**_UpperCamelCase					)

         scheduler.set_timesteps(self.num_inference_steps					)

         __A			  =							self.dummy_model()
         __A			  =							self.dummy_sample_deter * scheduler.init_noise_sigma

         for i, t in enumerate(scheduler.timesteps					):
               __A			  =							scheduler.scale_model_input(_UpperCamelCase       ,  _UpperCamelCase					)

               __A			  =							model(_UpperCamelCase       ,  _UpperCamelCase					)

               __A			  =							scheduler.step(_UpperCamelCase       ,  _UpperCamelCase       ,  _UpperCamelCase					)
               __A			  =							output.prev_sample

         __A			  =							torch.sum(torch.abs(_UpperCamelCase					)					)
         __A			  =							torch.mean(torch.abs(_UpperCamelCase					)					)

         assert abs(result_sum.item() - 0.0_0_1_7					) < 1e-2
         assert abs(result_mean.item() - 2.2_676e-06					) < 1e-3




   def _lowerCAmelCase (self      :List[Any]					)->   List[Any]:
         __A			  =							self.scheduler_classes[0]
         __A			  =							self.get_scheduler_config()
         __A			  =							scheduler_class(**_UpperCamelCase					)

         scheduler.set_timesteps(self.num_inference_steps       ,  device=_UpperCamelCase					)

         __A			  =							self.dummy_model()
         __A			  =							self.dummy_sample_deter * scheduler.init_noise_sigma.cpu()
         __A			  =							sample.to(_UpperCamelCase					)

         for i, t in enumerate(scheduler.timesteps					):
               __A			  =							scheduler.scale_model_input(_UpperCamelCase       ,  _UpperCamelCase					)

               __A			  =							model(_UpperCamelCase       ,  _UpperCamelCase					)

               __A			  =							scheduler.step(_UpperCamelCase       ,  _UpperCamelCase       ,  _UpperCamelCase					)
               __A			  =							output.prev_sample

         __A			  =							torch.sum(torch.abs(_UpperCamelCase					)					)
         __A			  =							torch.mean(torch.abs(_UpperCamelCase					)					)

         assert abs(result_sum.item() - 1_0_0_6.3_8_8					) < 1e-2
         assert abs(result_mean.item() - 1.3_1					) < 1e-3






   def _lowerCAmelCase (self      :List[str]					)->   int:
         __A			  =							self.scheduler_classes[0]
         __A			  =							self.get_scheduler_config()
         __A			  =							scheduler_class(**_UpperCamelCase       ,  use_karras_sigmas=_UpperCamelCase					)

         scheduler.set_timesteps(self.num_inference_steps       ,  device=_UpperCamelCase					)

         __A			  =							self.dummy_model()
         __A			  =							self.dummy_sample_deter.to(_UpperCamelCase					) * scheduler.init_noise_sigma
         __A			  =							sample.to(_UpperCamelCase					)

         for t in scheduler.timesteps:
               __A			  =							scheduler.scale_model_input(_UpperCamelCase       ,  _UpperCamelCase					)

               __A			  =							model(_UpperCamelCase       ,  _UpperCamelCase					)

               __A			  =							scheduler.step(_UpperCamelCase       ,  _UpperCamelCase       ,  _UpperCamelCase					)
               __A			  =							output.prev_sample

         __A			  =							torch.sum(torch.abs(_UpperCamelCase					)					)
         __A			  =							torch.mean(torch.abs(_UpperCamelCase					)					)

         assert abs(result_sum.item() - 3_8_1_2.9_9_2_7					) < 2e-2
         assert abs(result_mean.item() - 4.9_6_4_8					) < 1e-3





