

import torch

from diffusers import KDPMaAncestralDiscreteScheduler
from diffusers.utils import torch_device

from .test_schedulers import SchedulerCommonTest


class _lowercase					(       _UpperCAmelCase						):





							"""simple docstring"""




							lowerCAmelCase__       =					(KDPMaAncestralDiscreteScheduler,)
							lowerCAmelCase__       =					10



							def     _UpperCAmelCase       (    self     ,   **UpperCAmelCase  ):







														'''simple docstring'''






														_lowercase				=	{
														    """num_train_timesteps""": 1100,
														    """beta_start""": 0.0_001,
														    """beta_end""": 0.02,
														    """beta_schedule""": """linear""",
														}

														config.update(**UpperCAmelCase  )
														return config



							def     _UpperCAmelCase       (    self  ):







														'''simple docstring'''






														for timesteps in [10, 50, 100, 1000]:
																					self.check_over_configs(num_train_timesteps=UpperCAmelCase  )



							def     _UpperCAmelCase       (    self  ):







														'''simple docstring'''






														for beta_start, beta_end in zip([0.00_001, 0.0_001, 0.001]     ,   [0.0_002, 0.002, 0.02]  ):
																					self.check_over_configs(beta_start=UpperCAmelCase     ,   beta_end=UpperCAmelCase  )



							def     _UpperCAmelCase       (    self  ):







														'''simple docstring'''






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



							def     _UpperCAmelCase       (    self  ):







														'''simple docstring'''






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

														scheduler.set_timesteps(self.num_inference_steps  )

														_lowercase				=	torch.manual_seed(0  )

														_lowercase				=	self.dummy_model()
														_lowercase				=	self.dummy_sample_deter * scheduler.init_noise_sigma
														_lowercase				=	sample.to(UpperCAmelCase  )

														for i, t in enumerate(scheduler.timesteps  ):
																					_lowercase				=	scheduler.scale_model_input(UpperCAmelCase     ,   UpperCAmelCase  )

																					_lowercase				=	model(UpperCAmelCase     ,   UpperCAmelCase  )

																					_lowercase				=	scheduler.step(UpperCAmelCase     ,   UpperCAmelCase     ,   UpperCAmelCase     ,   generator=UpperCAmelCase  )
																					_lowercase				=	output.prev_sample

														_lowercase				=	torch.sum(torch.abs(UpperCAmelCase  )  )
														_lowercase				=	torch.mean(torch.abs(UpperCAmelCase  )  )

														assert abs(result_sum.item() - 13849.3877  ) < 1e-2
														assert abs(result_mean.item() - 18.0_331  ) < 5e-3



							def     _UpperCAmelCase       (    self  ):







														'''simple docstring'''






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



							def     _UpperCAmelCase       (    self  ):







														'''simple docstring'''






														if torch_device == "mps":
																					return
														_lowercase				=	self.scheduler_classes[0]
														_lowercase				=	self.get_scheduler_config(prediction_type="""v_prediction"""  )
														_lowercase				=	scheduler_class(**UpperCAmelCase  )

														scheduler.set_timesteps(self.num_inference_steps  )

														_lowercase				=	self.dummy_model()
														_lowercase				=	self.dummy_sample_deter * scheduler.init_noise_sigma
														_lowercase				=	sample.to(UpperCAmelCase  )

														_lowercase				=	torch.manual_seed(0  )

														for i, t in enumerate(scheduler.timesteps  ):
																					_lowercase				=	scheduler.scale_model_input(UpperCAmelCase     ,   UpperCAmelCase  )

																					_lowercase				=	model(UpperCAmelCase     ,   UpperCAmelCase  )

																					_lowercase				=	scheduler.step(UpperCAmelCase     ,   UpperCAmelCase     ,   UpperCAmelCase     ,   generator=UpperCAmelCase  )
																					_lowercase				=	output.prev_sample

														_lowercase				=	torch.sum(torch.abs(UpperCAmelCase  )  )
														_lowercase				=	torch.mean(torch.abs(UpperCAmelCase  )  )

														assert abs(result_sum.item() - 328.9_970  ) < 1e-2
														assert abs(result_mean.item() - 0.4_284  ) < 1e-3



							def     _UpperCAmelCase       (    self  ):







														'''simple docstring'''






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

														scheduler.set_timesteps(self.num_inference_steps     ,   device=UpperCAmelCase  )
														_lowercase				=	torch.manual_seed(0  )

														_lowercase				=	self.dummy_model()
														_lowercase				=	self.dummy_sample_deter.to(UpperCAmelCase  ) * scheduler.init_noise_sigma

														for t in scheduler.timesteps:
																					_lowercase				=	scheduler.scale_model_input(UpperCAmelCase     ,   UpperCAmelCase  )

																					_lowercase				=	model(UpperCAmelCase     ,   UpperCAmelCase  )

																					_lowercase				=	scheduler.step(UpperCAmelCase     ,   UpperCAmelCase     ,   UpperCAmelCase     ,   generator=UpperCAmelCase  )
																					_lowercase				=	output.prev_sample

														_lowercase				=	torch.sum(torch.abs(UpperCAmelCase  )  )
														_lowercase				=	torch.mean(torch.abs(UpperCAmelCase  )  )

														assert abs(result_sum.item() - 13849.3818  ) < 1e-1
														assert abs(result_mean.item() - 18.0_331  ) < 1e-3



def 					__lowerCAmelCase			(  _A = 998_001					):



							"""simple docstring"""


							_lowercase				=	0
							for i in range(999 ,99 ,-1					):  # 3 digit numbers range from 999 down to 100
														for j in range(999 ,99 ,-1					):
																					_lowercase				=	str(i * j					)
																					if product_string == product_string[::-1] and i * j < n:
																												_lowercase				=	max(_A ,i * j					)
							return answer


if __name__ == "__main__":
				print(F'''{solution() = }''')


