

'''simple docstring'''



import gc
import math
import unittest

import torch

from diffusers import UNetaDModel
from diffusers.utils import floats_tensor, logging, slow, torch_all_close, torch_device
from diffusers.utils.testing_utils import enable_full_determinism

from .test_modeling_common import ModelTesterMixin, UNetTesterMixin


__snake_case			:     Union[str, Any]										=      logging.get_logger(__name__)

enable_full_determinism()



class lowerCamelCase			(  lowercase_	,						lowercase_	,						unittest.TestCase						):



			'''simple docstring'''






			__snake_case        =	UNetaDModel
			__snake_case        =	'sample'


			@property
			def lowercase__						(				self	:						Optional[int]			)      ->		List[str]:





									'''simple docstring'''
									A__					:       Optional[Any]     =4
									A__					:       Dict     =3
									A__					:       str     =(32, 32)

									A__					:       List[str]     =floats_tensor((batch_size, num_channels) + sizes			).to(lowerCAmelCase_			)
									A__					:       List[str]     =torch.tensor([10]			).to(lowerCAmelCase_			)

									return {"sample": noise, "timestep": time_step}


			@property
			def lowercase__						(				self	:						str			)      ->		str:





									'''simple docstring'''
									return (3, 32, 32)


			@property
			def lowercase__						(				self	:						List[str]			)      ->		Union[str, Any]:





									'''simple docstring'''
									return (3, 32, 32)



			def lowercase__						(				self	:						Optional[int]			)      ->		str:





									'''simple docstring'''
									A__					:       Dict     ={
									    """block_out_channels""": (32, 64),
									    """down_block_types""": ("""DownBlock2D""", """AttnDownBlock2D"""),
									    """up_block_types""": ("""AttnUpBlock2D""", """UpBlock2D"""),
									    """attention_head_dim""": 3,
									    """out_channels""": 3,
									    """in_channels""": 3,
									    """layers_per_block""": 2,
									    """sample_size""": 32,
									}
									A__					:       int     =self.dummy_input
									return init_dict, inputs_dict



class lowerCamelCase			(  lowercase_	,						lowercase_	,						unittest.TestCase						):



			'''simple docstring'''






			__snake_case        =	UNetaDModel
			__snake_case        =	'sample'


			@property
			def lowercase__						(				self	:						List[str]			)      ->		Optional[Any]:





									'''simple docstring'''
									A__					:       int     =4
									A__					:       Union[str, Any]     =4
									A__					:       Optional[int]     =(32, 32)

									A__					:       int     =floats_tensor((batch_size, num_channels) + sizes			).to(lowerCAmelCase_			)
									A__					:       Dict     =torch.tensor([10]			).to(lowerCAmelCase_			)

									return {"sample": noise, "timestep": time_step}


			@property
			def lowercase__						(				self	:						Optional[int]			)      ->		str:





									'''simple docstring'''
									return (4, 32, 32)


			@property
			def lowercase__						(				self	:						Union[str, Any]			)      ->		Dict:





									'''simple docstring'''
									return (4, 32, 32)


			def lowercase__						(				self	:						List[str]			)      ->		Optional[Any]:





									'''simple docstring'''
									A__					:       Any     ={
									    """sample_size""": 32,
									    """in_channels""": 4,
									    """out_channels""": 4,
									    """layers_per_block""": 2,
									    """block_out_channels""": (32, 64),
									    """attention_head_dim""": 32,
									    """down_block_types""": ("""DownBlock2D""", """DownBlock2D"""),
									    """up_block_types""": ("""UpBlock2D""", """UpBlock2D"""),
									}
									A__					:       int     =self.dummy_input
									return init_dict, inputs_dict


			def lowercase__						(				self	:						Optional[Any]			)      ->		Any:





									'''simple docstring'''
									A__   ,						A__					:       str     =UNetaDModel.from_pretrained("""fusing/unet-ldm-dummy-update"""		,      output_loading_info=lowerCAmelCase_			)

									self.assertIsNotNone(lowerCAmelCase_			)
									self.assertEqual(len(loading_info["""missing_keys"""]			)		,      0			)

									model.to(lowerCAmelCase_			)
									A__					:       Optional[Any]     =model(**self.dummy_input			).sample

									assert image is not None, "Make sure output is not None"


			@unittest.skipIf(torch_device != """cuda"""		,      """This test is supposed to run on GPU"""			)
			def lowercase__						(				self	:						List[str]			)      ->		Union[str, Any]:





									'''simple docstring'''
									A__   ,						A__					:       int     =UNetaDModel.from_pretrained("""fusing/unet-ldm-dummy-update"""		,      output_loading_info=lowerCAmelCase_			)
									model.to(lowerCAmelCase_			)
									A__					:       Dict     =model(**self.dummy_input			).sample

									assert image is not None, "Make sure output is not None"


			@unittest.skipIf(torch_device != """cuda"""		,      """This test is supposed to run on GPU"""			)
			def lowercase__						(				self	:						Any			)      ->		Optional[int]:





									'''simple docstring'''
									# by defautl model loading will use accelerate as `low_cpu_mem_usage=True`
									A__   ,						A__					:       Optional[int]     =UNetaDModel.from_pretrained("""fusing/unet-ldm-dummy-update"""		,      output_loading_info=lowerCAmelCase_			)
									model_accelerate.to(lowerCAmelCase_			)
									model_accelerate.eval()

									A__					:       int     =torch.randn(
									    1		,      model_accelerate.config.in_channels		,      model_accelerate.config.sample_size		,      model_accelerate.config.sample_size		,      generator=torch.manual_seed(0			)		,      )
									A__					:       int     =noise.to(lowerCAmelCase_			)
									A__					:       Optional[int]     =torch.tensor([10] * noise.shape[0]			).to(lowerCAmelCase_			)

									A__					:       Union[str, Any]     =model_accelerate(lowerCAmelCase_		,      lowerCAmelCase_			)["""sample"""]

									# two models don't need to stay in the device at the same time
									del model_accelerate
									torch.cuda.empty_cache()
									gc.collect()

									A__   ,						A__					:       int     =UNetaDModel.from_pretrained(
									    """fusing/unet-ldm-dummy-update"""		,      output_loading_info=lowerCAmelCase_		,      low_cpu_mem_usage=lowerCAmelCase_			)
									model_normal_load.to(lowerCAmelCase_			)
									model_normal_load.eval()
									A__					:       List[Any]     =model_normal_load(lowerCAmelCase_		,      lowerCAmelCase_			)["""sample"""]

									assert torch_all_close(lowerCAmelCase_		,      lowerCAmelCase_		,      rtol=1e-3			)



			def lowercase__						(				self	:						Tuple			)      ->		Union[str, Any]:





									'''simple docstring'''
									A__					:       Optional[int]     =UNetaDModel.from_pretrained("""fusing/unet-ldm-dummy-update"""			)
									model.eval()
									model.to(lowerCAmelCase_			)

									A__					:       Tuple     =torch.randn(
									    1		,      model.config.in_channels		,      model.config.sample_size		,      model.config.sample_size		,      generator=torch.manual_seed(0			)		,      )
									A__					:       str     =noise.to(lowerCAmelCase_			)
									A__					:       Optional[int]     =torch.tensor([10] * noise.shape[0]			).to(lowerCAmelCase_			)

									with torch.no_grad():
															A__					:       List[Any]     =model(lowerCAmelCase_		,      lowerCAmelCase_			).sample

									A__					:       Optional[int]     =output[0, -1, -3:, -3:].flatten().cpu()
									# fmt: off
									A__					:       Optional[Any]     =torch.tensor([-13.3258, -20.1100, -15.9873, -17.6617, -23.0596, -17.9419, -13.3675, -16.1889, -12.3800]			)
									# fmt: on

									self.assertTrue(torch_all_close(lowerCAmelCase_		,      lowerCAmelCase_		,      rtol=1e-3			)			)



class lowerCamelCase			(  lowercase_	,						lowercase_	,						unittest.TestCase						):



			'''simple docstring'''






			__snake_case        =	UNetaDModel
			__snake_case        =	'sample'


			@property
			def lowercase__						(				self	:						List[Any]		,      lowerCAmelCase_	:						Optional[Any]=(32, 32)			)      ->		Optional[int]:





									'''simple docstring'''
									A__					:       Any     =4
									A__					:       int     =3

									A__					:       List[str]     =floats_tensor((batch_size, num_channels) + sizes			).to(lowerCAmelCase_			)
									A__					:       Tuple     =torch.tensor(batch_size * [10]			).to(dtype=torch.intaa		,      device=lowerCAmelCase_			)

									return {"sample": noise, "timestep": time_step}


			@property
			def lowercase__						(				self	:						List[Any]			)      ->		List[Any]:





									'''simple docstring'''
									return (3, 32, 32)


			@property
			def lowercase__						(				self	:						str			)      ->		List[str]:





									'''simple docstring'''
									return (3, 32, 32)


			def lowercase__						(				self	:						Optional[Any]			)      ->		List[str]:





									'''simple docstring'''
									A__					:       Union[str, Any]     ={
									    """block_out_channels""": [32, 64, 64, 64],
									    """in_channels""": 3,
									    """layers_per_block""": 1,
									    """out_channels""": 3,
									    """time_embedding_type""": """fourier""",
									    """norm_eps""": 1e-6,
									    """mid_block_scale_factor""": math.sqrt(2.0			),
									    """norm_num_groups""": None,
									    """down_block_types""": [
									        """SkipDownBlock2D""",
									        """AttnSkipDownBlock2D""",
									        """SkipDownBlock2D""",
									        """SkipDownBlock2D""",
									    ],
									    """up_block_types""": [
									        """SkipUpBlock2D""",
									        """SkipUpBlock2D""",
									        """AttnSkipUpBlock2D""",
									        """SkipUpBlock2D""",
									    ],
									}
									A__					:       Optional[Any]     =self.dummy_input
									return init_dict, inputs_dict


			@slow
			def lowercase__						(				self	:						List[str]			)      ->		List[str]:





									'''simple docstring'''
									A__   ,						A__					:       Optional[Any]     =UNetaDModel.from_pretrained("""google/ncsnpp-celebahq-256"""		,      output_loading_info=lowerCAmelCase_			)
									self.assertIsNotNone(lowerCAmelCase_			)
									self.assertEqual(len(loading_info["""missing_keys"""]			)		,      0			)

									model.to(lowerCAmelCase_			)
									A__					:       Optional[Any]     =self.dummy_input
									A__					:       Tuple     =floats_tensor((4, 3) + (2_56, 2_56)			).to(lowerCAmelCase_			)
									A__					:       List[str]     =noise
									A__					:       int     =model(**lowerCAmelCase_			)

									assert image is not None, "Make sure output is not None"


			@slow
			def lowercase__						(				self	:						List[str]			)      ->		Tuple:





									'''simple docstring'''
									A__					:       Tuple     =UNetaDModel.from_pretrained("""google/ncsnpp-celebahq-256"""			)
									model.to(lowerCAmelCase_			)

									A__					:       Union[str, Any]     =4
									A__					:       Dict     =3
									A__					:       List[Any]     =(2_56, 2_56)

									A__					:       Dict     =torch.ones((batch_size, num_channels) + sizes			).to(lowerCAmelCase_			)
									A__					:       List[Any]     =torch.tensor(batch_size * [1e-4]			).to(lowerCAmelCase_			)

									with torch.no_grad():
															A__					:       Optional[Any]     =model(lowerCAmelCase_		,      lowerCAmelCase_			).sample

									A__					:       Tuple     =output[0, -3:, -3:, -1].flatten().cpu()
									# fmt: off
									A__					:       str     =torch.tensor([-4842.8691, -6499.6631, -3800.1953, -7978.2686, -10980.7129, -20028.8535, 8148.2822, 2342.2905, 567.7608]			)
									# fmt: on

									self.assertTrue(torch_all_close(lowerCAmelCase_		,      lowerCAmelCase_		,      rtol=1e-2			)			)


			def lowercase__						(				self	:						Any			)      ->		Dict:





									'''simple docstring'''
									A__					:       Any     =UNetaDModel.from_pretrained("""fusing/ncsnpp-ffhq-ve-dummy-update"""			)
									model.to(lowerCAmelCase_			)

									A__					:       List[str]     =4
									A__					:       List[Any]     =3
									A__					:       Dict     =(32, 32)

									A__					:       Optional[int]     =torch.ones((batch_size, num_channels) + sizes			).to(lowerCAmelCase_			)
									A__					:       Union[str, Any]     =torch.tensor(batch_size * [1e-4]			).to(lowerCAmelCase_			)

									with torch.no_grad():
															A__					:       Any     =model(lowerCAmelCase_		,      lowerCAmelCase_			).sample

									A__					:       List[Any]     =output[0, -3:, -3:, -1].flatten().cpu()
									# fmt: off
									A__					:       List[Any]     =torch.tensor([-0.0325, -0.0900, -0.0869, -0.0332, -0.0725, -0.0270, -0.0101, 0.0227, 0.0256]			)
									# fmt: on

									self.assertTrue(torch_all_close(lowerCAmelCase_		,      lowerCAmelCase_		,      rtol=1e-2			)			)



			def lowercase__						(				self	:						Tuple			)      ->		Optional[int]:





									'''simple docstring'''
									# not required for this model
									pass




'''simple docstring'''



def 						__lowerCamelCase	(       __snake_case					:		int	)	->							bool:






						"""simple docstring"""





						if p < 2:
												raise ValueError("""p should not be less than 2!"""	)
						elif p == 2:
												return True

						A__					:       Any     =4
						A__					:       int     =(1 << p) - 1
						for _ in range(p - 2	):
												A__					:       Dict     =((s * s) - 2) % m
						return s == 0


if __name__ == "__main__":
		print(lucas_lehmer_test(7))
		print(lucas_lehmer_test(11))

