code: 
  
  
  
  
  """simple docstring"""
  
  import torch
  
  from diffusers import DDIMScheduler
  
  from .test_schedulers import SchedulerCommonTest
  class 			lowerCamelCase__    (  lowerCamelCase_			):
  			a__ :      Dict								=     (DDIMScheduler,)
  			a__ :      Tuple								=     (("""eta""", 0.0), ("""num_inference_steps""", 50))
  
  
  			def 							lowerCamelCase_				(     self				, **SCREAMING_SNAKE_CASE							):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					snake_case		:						Dict								=				{
  					    "num_train_timesteps": 1_000,
  					    "beta_start": 0.00_01,
  					    "beta_end": 0.02,
  					    "beta_schedule": "linear",
  					    "clip_sample": True,
  					}
  
  					config.update(**SCREAMING_SNAKE_CASE							)
  					return config
  
  
  			def 							lowerCamelCase_				(     self				, **SCREAMING_SNAKE_CASE							):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					snake_case		:						Any								=				self.scheduler_classes[0]
  					snake_case		:						str								=				self.get_scheduler_config(**SCREAMING_SNAKE_CASE							)
  					snake_case		:						int								=				scheduler_class(**SCREAMING_SNAKE_CASE							)
  
  					snake_case			,				snake_case		:						int								=				10, 0.0
  
  					snake_case		:						int								=				self.dummy_model()
  					snake_case		:						Optional[Any]								=				self.dummy_sample_deter
  
  					scheduler.set_timesteps(SCREAMING_SNAKE_CASE							)
  
  					for t in scheduler.timesteps:
  							snake_case		:						str								=				model(SCREAMING_SNAKE_CASE				, SCREAMING_SNAKE_CASE							)
  							snake_case		:						Union[str, Any]								=				scheduler.step(SCREAMING_SNAKE_CASE				, SCREAMING_SNAKE_CASE				, SCREAMING_SNAKE_CASE				, SCREAMING_SNAKE_CASE							).prev_sample
  
  					return sample
  
  
  			def 							lowerCamelCase_				(     self							):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					for timesteps in [100, 500, 1_000]:
  							self.check_over_configs(num_train_timesteps=SCREAMING_SNAKE_CASE							)
  
  
  			def 							lowerCamelCase_				(     self							):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					for steps_offset in [0, 1]:
  							self.check_over_configs(steps_offset=SCREAMING_SNAKE_CASE							)
  
  					snake_case		:						str								=				self.scheduler_classes[0]
  					snake_case		:						str								=				self.get_scheduler_config(steps_offset=1							)
  					snake_case		:						List[str]								=				scheduler_class(**SCREAMING_SNAKE_CASE							)
  					scheduler.set_timesteps(5							)
  					assert torch.equal(scheduler.timesteps				, torch.LongTensor([801, 601, 401, 201, 1]							)							)
  
  
  			def 							lowerCamelCase_				(     self							):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					for beta_start, beta_end in zip([0.00_01, 0.0_01, 0.01, 0.1]				, [0.0_02, 0.02, 0.2, 2]							):
  							self.check_over_configs(beta_start=SCREAMING_SNAKE_CASE				, beta_end=SCREAMING_SNAKE_CASE							)
  
  
  			def 							lowerCamelCase_				(     self							):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					for schedule in ["linear", "squaredcos_cap_v2"]:
  							self.check_over_configs(beta_schedule=SCREAMING_SNAKE_CASE							)
  
  
  			def 							lowerCamelCase_				(     self							):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					for prediction_type in ["epsilon", "v_prediction"]:
  							self.check_over_configs(prediction_type=SCREAMING_SNAKE_CASE							)
  
  
  			def 							lowerCamelCase_				(     self							):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					for clip_sample in [True, False]:
  							self.check_over_configs(clip_sample=SCREAMING_SNAKE_CASE							)
  
  
  			def 							lowerCamelCase_				(     self							):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					for timestep_spacing in ["trailing", "leading"]:
  							self.check_over_configs(timestep_spacing=SCREAMING_SNAKE_CASE							)
  
  
  			def 							lowerCamelCase_				(     self							):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					for rescale_betas_zero_snr in [True, False]:
  							self.check_over_configs(rescale_betas_zero_snr=SCREAMING_SNAKE_CASE							)
  
  
  			def 							lowerCamelCase_				(     self							):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					self.check_over_configs(thresholding=SCREAMING_SNAKE_CASE							)
  					for threshold in [0.5, 1.0, 2.0]:
  							for prediction_type in ["epsilon", "v_prediction"]:
  									self.check_over_configs(
  									    thresholding=SCREAMING_SNAKE_CASE				, prediction_type=SCREAMING_SNAKE_CASE				, sample_max_value=SCREAMING_SNAKE_CASE				, )
  
  
  			def 							lowerCamelCase_				(     self							):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					for t in [1, 10, 49]:
  							self.check_over_forward(time_step=SCREAMING_SNAKE_CASE							)
  
  
  			def 							lowerCamelCase_				(     self							):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					for t, num_inference_steps in zip([1, 10, 50]				, [10, 50, 500]							):
  							self.check_over_forward(time_step=SCREAMING_SNAKE_CASE				, num_inference_steps=SCREAMING_SNAKE_CASE							)
  
  
  			def 							lowerCamelCase_				(     self							):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					for t, eta in zip([1, 10, 49]				, [0.0, 0.5, 1.0]							):
  							self.check_over_forward(time_step=SCREAMING_SNAKE_CASE				, eta=SCREAMING_SNAKE_CASE							)
  
  
  			def 							lowerCamelCase_				(     self							):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					snake_case		:						Dict								=				self.scheduler_classes[0]
  					snake_case		:						Dict								=				self.get_scheduler_config()
  					snake_case		:						Union[str, Any]								=				scheduler_class(**SCREAMING_SNAKE_CASE							)
  
  					assert torch.sum(torch.abs(scheduler._get_variance(0				, 0							) - 0.0							)							) < 1E-5
  					assert torch.sum(torch.abs(scheduler._get_variance(420				, 400							) - 0.1_47_71							)							) < 1E-5
  					assert torch.sum(torch.abs(scheduler._get_variance(980				, 960							) - 0.3_24_60							)							) < 1E-5
  					assert torch.sum(torch.abs(scheduler._get_variance(0				, 0							) - 0.0							)							) < 1E-5
  					assert torch.sum(torch.abs(scheduler._get_variance(487				, 486							) - 0.0_09_79							)							) < 1E-5
  					assert torch.sum(torch.abs(scheduler._get_variance(999				, 998							) - 0.02							)							) < 1E-5
  
  
  			def 							lowerCamelCase_				(     self							):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					snake_case		:						Tuple								=				self.full_loop()
  
  					snake_case		:						Any								=				torch.sum(torch.abs(SCREAMING_SNAKE_CASE							)							)
  					snake_case		:						Dict								=				torch.mean(torch.abs(SCREAMING_SNAKE_CASE							)							)
  
  					assert abs(result_sum.item() - 1_72.00_67							) < 1E-2
  					assert abs(result_mean.item() - 0.22_39_67							) < 1E-3
  
  
  			def 							lowerCamelCase_				(     self							):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					snake_case		:						Optional[int]								=				self.full_loop(prediction_type="v_prediction"							)
  
  					snake_case		:						Tuple								=				torch.sum(torch.abs(SCREAMING_SNAKE_CASE							)							)
  					snake_case		:						List[str]								=				torch.mean(torch.abs(SCREAMING_SNAKE_CASE							)							)
  
  					assert abs(result_sum.item() - 52.53_02							) < 1E-2
  					assert abs(result_mean.item() - 0.06_84							) < 1E-3
  
  
  			def 							lowerCamelCase_				(     self							):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					snake_case		:						Any								=				self.full_loop(set_alpha_to_one=SCREAMING_SNAKE_CASE				, beta_start=0.01							)
  					snake_case		:						Any								=				torch.sum(torch.abs(SCREAMING_SNAKE_CASE							)							)
  					snake_case		:						List[str]								=				torch.mean(torch.abs(SCREAMING_SNAKE_CASE							)							)
  
  					assert abs(result_sum.item() - 1_49.82_95							) < 1E-2
  					assert abs(result_mean.item() - 0.19_51							) < 1E-3
  
  
  
  			def 							lowerCamelCase_				(     self							):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					snake_case		:						List[str]								=				self.full_loop(set_alpha_to_one=SCREAMING_SNAKE_CASE				, beta_start=0.01							)
  					snake_case		:						List[Any]								=				torch.sum(torch.abs(SCREAMING_SNAKE_CASE							)							)
  					snake_case		:						int								=				torch.mean(torch.abs(SCREAMING_SNAKE_CASE							)							)
  
  					assert abs(result_sum.item() - 1_49.07_84							) < 1E-2
  					assert abs(result_mean.item() - 0.19_41							) < 1E-3
  
  
style_context: 
  
  
  
  
  """simple docstring"""
  
  import gc
  import unittest
  
  import numpy as np
  import torch
  
  from diffusers import RePaintPipeline, RePaintScheduler, UNetaDModel
  from diffusers.utils.testing_utils import (
      enable_full_determinism,
      load_image,
      load_numpy,
      nightly,
      require_torch_gpu,
      skip_mps,
      torch_device,
  )
  
  from ..pipeline_params import IMAGE_INPAINTING_BATCH_PARAMS, IMAGE_INPAINTING_PARAMS
  from ..test_pipelines_common import PipelineTesterMixin
  
  
  enable_full_determinism()
  class 			lowerCamelCase__    (  lowerCamelCase_				,  unittest.TestCase			):
  			a__ :      Optional[Any]								=     RePaintPipeline
  			a__ :      List[Any]								=     IMAGE_INPAINTING_PARAMS - {"""width""", """height""", """guidance_scale"""}
  			a__ :      List[Any]								=     PipelineTesterMixin.required_optional_params - {
  			    """latents""",
  			    """num_images_per_prompt""",
  			    """callback""",
  			    """callback_steps""",
  			}
  			a__ :      List[Any]								=     IMAGE_INPAINTING_BATCH_PARAMS
  			a__ :      List[str]								=     False
  
  
  			def 							lowerCamelCase_				(     self							):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					torch.manual_seed(0							)
  					torch.manual_seed(0							)
  					snake_case		:						Union[str, Any]								=				UNetaDModel(
  					    block_out_channels=(32, 64)				, layers_per_block=2				, sample_size=32				, in_channels=3				, out_channels=3				, down_block_types=("DownBlock2D", "AttnDownBlock2D")				, up_block_types=("AttnUpBlock2D", "UpBlock2D")				, )
  					snake_case		:						Union[str, Any]								=				RePaintScheduler()
  					snake_case		:						Optional[Any]								=				{"unet": unet, "scheduler": scheduler}
  					return components
  
  
  			def 							lowerCamelCase_				(     self				, SCREAMING_SNAKE_CASE				, SCREAMING_SNAKE_CASE=0							):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					if str(SCREAMING_SNAKE_CASE							).startswith("mps"							):
  							snake_case		:						str								=				torch.manual_seed(SCREAMING_SNAKE_CASE							)
  					else:
  							snake_case		:						List[Any]								=				torch.Generator(device=SCREAMING_SNAKE_CASE							).manual_seed(SCREAMING_SNAKE_CASE							)
  					snake_case		:						Any								=				np.random.RandomState(SCREAMING_SNAKE_CASE							).standard_normal((1, 3, 32, 32)							)
  					snake_case		:						Any								=				torch.from_numpy(SCREAMING_SNAKE_CASE							).to(device=SCREAMING_SNAKE_CASE				, dtype=torch.floataa							)
  					snake_case		:						List[str]								=				(image > 0).to(device=SCREAMING_SNAKE_CASE				, dtype=torch.floataa							)
  					snake_case		:						int								=				{
  					    "image": image,
  					    "mask_image": mask,
  					    "generator": generator,
  					    "num_inference_steps": 5,
  					    "eta": 0.0,
  					    "jump_length": 2,
  					    "jump_n_sample": 2,
  					    "output_type": "numpy",
  					}
  					return inputs
  
  
  			def 							lowerCamelCase_				(     self							):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					snake_case		:						List[Any]								=				"cpu"  # ensure determinism for the device-dependent torch.Generator
  					snake_case		:						Any								=				self.get_dummy_components()
  					snake_case		:						Optional[int]								=				RePaintPipeline(**SCREAMING_SNAKE_CASE							)
  					snake_case		:						Optional[Any]								=				sd_pipe.to(SCREAMING_SNAKE_CASE							)
  					sd_pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE							)
  
  					snake_case		:						Any								=				self.get_dummy_inputs(SCREAMING_SNAKE_CASE							)
  					snake_case		:						Dict								=				sd_pipe(**SCREAMING_SNAKE_CASE							).images
  					snake_case		:						Optional[int]								=				image[0, -3:, -3:, -1]
  
  					assert image.shape == (1, 32, 32, 3)
  					snake_case		:						List[str]								=				np.array([1.00_00, 0.54_26, 0.54_97, 0.22_00, 1.00_00, 1.00_00, 0.56_23, 1.00_00, 0.62_74]							)
  
  					assert np.abs(image_slice.flatten() - expected_slice							).max() < 1E-3
  
  
  			@skip_mps
  			def 							lowerCamelCase_				(     self							):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					return super().test_save_load_local()
  
  
  			@unittest.skip("non-deterministic pipeline"							)
  			def 							lowerCamelCase_				(     self							):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					return super().test_inference_batch_single_identical()
  
  
  			@skip_mps
  			def 							lowerCamelCase_				(     self							):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					return super().test_dict_tuple_outputs_equivalent()
  
  
  			@skip_mps
  			def 							lowerCamelCase_				(     self							):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					return super().test_save_load_optional_components()
  
  
  
  			@skip_mps
  			def 							lowerCamelCase_				(     self							):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					return super().test_attention_slicing_forward_pass()
  
  
  
  
  
  
  
  @nightly
  @require_torch_gpu
  class 			lowerCamelCase__    (  unittest.TestCase			):
  
  
  			def 							lowerCamelCase_				(     self							):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					super().tearDown()
  					gc.collect()
  					torch.cuda.empty_cache()
  
  
  
  			def 							lowerCamelCase_				(     self							):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					snake_case		:						Optional[int]								=				load_image(
  					    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/"
  					    "repaint/celeba_hq_256.png"							)
  					snake_case		:						Any								=				load_image(
  					    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/repaint/mask_256.png"							)
  					snake_case		:						List[Any]								=				load_numpy(
  					    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/"
  					    "repaint/celeba_hq_256_result.npy"							)
  
  					snake_case		:						str								=				"google/ddpm-ema-celebahq-256"
  					snake_case		:						Optional[Any]								=				UNetaDModel.from_pretrained(SCREAMING_SNAKE_CASE							)
  					snake_case		:						Optional[int]								=				RePaintScheduler.from_pretrained(SCREAMING_SNAKE_CASE							)
  
  					snake_case		:						str								=				RePaintPipeline(unet=SCREAMING_SNAKE_CASE				, scheduler=SCREAMING_SNAKE_CASE							).to(SCREAMING_SNAKE_CASE							)
  					repaint.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE							)
  					repaint.enable_attention_slicing()
  
  					snake_case		:						Union[str, Any]								=				torch.manual_seed(0							)
  					snake_case		:						int								=				repaint(
  					    SCREAMING_SNAKE_CASE				, SCREAMING_SNAKE_CASE				, num_inference_steps=250				, eta=0.0				, jump_length=10				, jump_n_sample=10				, generator=SCREAMING_SNAKE_CASE				, output_type="np"				, )
  					snake_case		:						List[Any]								=				output.images[0]
  
  					assert image.shape == (256, 256, 3)
  					assert np.abs(expected_image - image							).mean() < 1E-2
  
  