


"""simple docstring"""






def 				A_       ( snake_case__       ,					snake_case__		)					->  int:
			return number | (1 << position)





def 				A_       ( snake_case__       ,					snake_case__		)					->  int:
			return number & ~(1 << position)





def 				A_       ( snake_case__       ,					snake_case__		)					->  int:
			return number ^ (1 << position)





def 				A_       ( snake_case__       ,					snake_case__		)					->  bool:
			return ((number >> position) & 1) == 1





def 				A_       ( snake_case__       ,					snake_case__		)					->  int:
			return int((number & (1 << position)) != 0		)


if __name__ == "__main__":
					import doctest

					doctest.testmod()



import torch

from diffusers import KDPMaDiscreteScheduler
from diffusers.utils import torch_device

from .test_schedulers import SchedulerCommonTest







class 							lowerCAmelCase__   ( __lowercase						):
						UpperCamelCase_				:			int						=		(KDPMaDiscreteScheduler,)
						UpperCamelCase_				:			Optional[int]						=		10

						def 			A_					(      self							,				**a					)       ->   int:


								'''simple docstring'''

								_UpperCamelCase         =						{
								    """num_train_timesteps""": 11_00,
								    """beta_start""": 0.0001,
								    """beta_end""": 0.02,
								    """beta_schedule""": """linear""",
								}

								config.update(**a					)
								return config

						def 			A_					(      self					)       ->   List[str]:


								'''simple docstring'''

								for timesteps in [10, 50, 1_00, 10_00]:
										self.check_over_configs(num_train_timesteps=a					)

						def 			A_					(      self					)       ->   List[Any]:


								'''simple docstring'''

								for beta_start, beta_end in zip([0.0_0001, 0.0001, 0.001]							,				[0.0002, 0.002, 0.02]					):
										self.check_over_configs(beta_start=a							,				beta_end=a					)

						def 			A_					(      self					)       ->   Any:


								'''simple docstring'''

								for schedule in ["linear", "scaled_linear"]:
										self.check_over_configs(beta_schedule=a					)

						def 			A_					(      self					)       ->   Optional[int]:


								'''simple docstring'''

								for prediction_type in ["epsilon", "v_prediction"]:
										self.check_over_configs(prediction_type=a					)

						def 			A_					(      self					)       ->   List[Any]:


								'''simple docstring'''

								_UpperCamelCase         =						self.scheduler_classes[0]
								_UpperCamelCase         =						self.get_scheduler_config(prediction_type="""v_prediction"""					)
								_UpperCamelCase         =						scheduler_class(**a					)

								scheduler.set_timesteps(self.num_inference_steps					)

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

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

										_UpperCamelCase         =						model(a							,				a					)

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

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

								if torch_device in ["cpu", "mps"]:
										assert abs(result_sum.item() - 4.6934e-07					) < 1e-2
										assert abs(result_mean.item() - 6.1112e-10					) < 1e-3
								else:
										# CUDA
										assert abs(result_sum.item() - 4.693_4286_5017_0972e-07					) < 1e-2
										assert abs(result_mean.item() - 0.0002					) < 1e-3

						def 			A_					(      self					)       ->   str:


								'''simple docstring'''

								if torch_device == "mps":
										return
								_UpperCamelCase         =						self.scheduler_classes[0]
								_UpperCamelCase         =						self.get_scheduler_config()
								_UpperCamelCase         =						scheduler_class(**a					)

								scheduler.set_timesteps(self.num_inference_steps					)

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

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

										_UpperCamelCase         =						model(a							,				a					)

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

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

								if torch_device in ["cpu", "mps"]:
										assert abs(result_sum.item() - 20.4125					) < 1e-2
										assert abs(result_mean.item() - 0.0266					) < 1e-3
								else:
										# CUDA
										assert abs(result_sum.item() - 20.4125					) < 1e-2
										assert abs(result_mean.item() - 0.0266					) < 1e-3







						def 			A_					(      self					)       ->   str:


								'''simple docstring'''

								if torch_device == "mps":
										return
								_UpperCamelCase         =						self.scheduler_classes[0]
								_UpperCamelCase         =						self.get_scheduler_config()
								_UpperCamelCase         =						scheduler_class(**a					)

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

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

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

										_UpperCamelCase         =						model(a							,				a					)

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

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

								if str(a					).startswith("""cpu"""					):
										# The following sum varies between 148 and 156 on mps. Why?
										assert abs(result_sum.item() - 20.4125					) < 1e-2
										assert abs(result_mean.item() - 0.0266					) < 1e-3
								else:
										# CUDA
										assert abs(result_sum.item() - 20.4125					) < 1e-2
										assert abs(result_mean.item() - 0.0266					) < 1e-3



