




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


_lowerCamelCase      :  Optional[int]      						=						logging.get_logger(__name__)

enable_full_determinism()
class        __snake_case  (_a						,	_a						,	unittest.TestCase		):
				lowerCAmelCase__				=     UNetaDModel
				lowerCAmelCase__				=     "sample"



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





								'''simple docstring'''




								_lowerCAmelCase    :    List[Any]										=      4
								_lowerCAmelCase    :    Optional[Any]										=      3
								_lowerCAmelCase    :    Optional[Any]										=      (32, 32)

								_lowerCAmelCase    :    Tuple										=      floats_tensor((batch_size, num_channels) + sizes      ).to(_UpperCAmelCase      )
								_lowerCAmelCase    :    Any										=      torch.tensor([10]      ).to(_UpperCAmelCase      )

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



				@property
				def       SCREAMING_SNAKE_CASE       (      self      :		Any      )  ->    Dict:





								'''simple docstring'''




								return (3, 32, 32)



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





								'''simple docstring'''




								return (3, 32, 32)



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





								'''simple docstring'''




								_lowerCAmelCase    :    Any										=      {
								    """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,
								}
								_lowerCAmelCase    :    Any										=      self.dummy_input
								return init_dict, inputs_dict






class        __snake_case  (_a						,	_a						,	unittest.TestCase		):
				lowerCAmelCase__				=     UNetaDModel
				lowerCAmelCase__				=     "sample"



				@property
				def       SCREAMING_SNAKE_CASE       (      self      :		Optional[Any]      )  ->    Optional[Any]:





								'''simple docstring'''




								_lowerCAmelCase    :    Union[str, Any]										=      4
								_lowerCAmelCase    :    Any										=      4
								_lowerCAmelCase    :    Optional[int]										=      (32, 32)

								_lowerCAmelCase    :    Optional[int]										=      floats_tensor((batch_size, num_channels) + sizes      ).to(_UpperCAmelCase      )
								_lowerCAmelCase    :    Optional[Any]										=      torch.tensor([10]      ).to(_UpperCAmelCase      )

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



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





								'''simple docstring'''




								return (4, 32, 32)



				@property
				def       SCREAMING_SNAKE_CASE       (      self      :		Optional[int]      )  ->    Tuple:





								'''simple docstring'''




								return (4, 32, 32)



				def       SCREAMING_SNAKE_CASE       (      self      :		Dict      )  ->    str:





								'''simple docstring'''




								_lowerCAmelCase    :    Tuple										=      {
								    """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"""),
								}
								_lowerCAmelCase    :    Optional[Any]										=      self.dummy_input
								return init_dict, inputs_dict



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





								'''simple docstring'''




								_lowerCAmelCase					,    _lowerCAmelCase    :    int										=      UNetaDModel.from_pretrained("""fusing/unet-ldm-dummy-update"""		,	output_loading_info=_UpperCAmelCase      )

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

								model.to(_UpperCAmelCase      )
								_lowerCAmelCase    :    int										=      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       SCREAMING_SNAKE_CASE       (      self      :		Any      )  ->    Any:





								'''simple docstring'''




								_lowerCAmelCase					,    _lowerCAmelCase    :    Any										=      UNetaDModel.from_pretrained("""fusing/unet-ldm-dummy-update"""		,	output_loading_info=_UpperCAmelCase      )
								model.to(_UpperCAmelCase      )
								_lowerCAmelCase    :    int										=      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       SCREAMING_SNAKE_CASE       (      self      :		int      )  ->    Tuple:





								'''simple docstring'''




								_lowerCAmelCase					,    _lowerCAmelCase    :    Dict										=      UNetaDModel.from_pretrained("""fusing/unet-ldm-dummy-update"""		,	output_loading_info=_UpperCAmelCase      )
								model_accelerate.to(_UpperCAmelCase      )
								model_accelerate.eval()

								_lowerCAmelCase    :    Dict										=      torch.randn(
								    1		,	model_accelerate.config.in_channels		,	model_accelerate.config.sample_size		,	model_accelerate.config.sample_size		,	generator=torch.manual_seed(0      )		,	)
								_lowerCAmelCase    :    Dict										=      noise.to(_UpperCAmelCase      )
								_lowerCAmelCase    :    List[Any]										=      torch.tensor([10] * noise.shape[0]      ).to(_UpperCAmelCase      )

								_lowerCAmelCase    :    Optional[Any]										=      model_accelerate(_UpperCAmelCase		,	_UpperCAmelCase      )["""sample"""]

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

								_lowerCAmelCase					,    _lowerCAmelCase    :    Any										=      UNetaDModel.from_pretrained(
								    """fusing/unet-ldm-dummy-update"""		,	output_loading_info=_UpperCAmelCase		,	low_cpu_mem_usage=_UpperCAmelCase      )
								model_normal_load.to(_UpperCAmelCase      )
								model_normal_load.eval()
								_lowerCAmelCase    :    Union[str, Any]										=      model_normal_load(_UpperCAmelCase		,	_UpperCAmelCase      )["""sample"""]

								assert torch_all_close(_UpperCAmelCase		,	_UpperCAmelCase		,	rtol=1E-3      )



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





								'''simple docstring'''




								_lowerCAmelCase    :    List[str]										=      UNetaDModel.from_pretrained("""fusing/unet-ldm-dummy-update"""      )
								model.eval()
								model.to(_UpperCAmelCase      )

								_lowerCAmelCase    :    Optional[int]										=      torch.randn(
								    1		,	model.config.in_channels		,	model.config.sample_size		,	model.config.sample_size		,	generator=torch.manual_seed(0      )		,	)
								_lowerCAmelCase    :    List[Any]										=      noise.to(_UpperCAmelCase      )
								_lowerCAmelCase    :    List[str]										=      torch.tensor([10] * noise.shape[0]      ).to(_UpperCAmelCase      )

								with torch.no_grad():
												_lowerCAmelCase    :    Any										=      model(_UpperCAmelCase		,	_UpperCAmelCase      ).sample

								_lowerCAmelCase    :    List[Any]										=      output[0, -1, -3:, -3:].flatten().cpu()
								# fmt: off
								_lowerCAmelCase    :    Tuple										=      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(_UpperCAmelCase		,	_UpperCAmelCase		,	rtol=1E-3      )      )






class        __snake_case  (_a						,	_a						,	unittest.TestCase		):
				lowerCAmelCase__				=     UNetaDModel
				lowerCAmelCase__				=     "sample"



				@property
				def       SCREAMING_SNAKE_CASE       (      self      :		List[str]		,	_UpperCAmelCase      :		Tuple=(32, 32)      )  ->    List[Any]:





								'''simple docstring'''




								_lowerCAmelCase    :    Union[str, Any]										=      4
								_lowerCAmelCase    :    Union[str, Any]										=      3

								_lowerCAmelCase    :    Any										=      floats_tensor((batch_size, num_channels) + sizes      ).to(_UpperCAmelCase      )
								_lowerCAmelCase    :    Union[str, Any]										=      torch.tensor(batch_size * [10]      ).to(dtype=torch.intaa		,	device=_UpperCAmelCase      )

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



				@property
				def       SCREAMING_SNAKE_CASE       (      self      :		str      )  ->    int:





								'''simple docstring'''




								return (3, 32, 32)



				@property
				def       SCREAMING_SNAKE_CASE       (      self      :		Tuple      )  ->    str:





								'''simple docstring'''




								return (3, 32, 32)



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





								'''simple docstring'''




								_lowerCAmelCase    :    Optional[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""",
								    ],
								}
								_lowerCAmelCase    :    Tuple										=      self.dummy_input
								return init_dict, inputs_dict



				@slow
				def       SCREAMING_SNAKE_CASE       (      self      :		List[Any]      )  ->    Tuple:





								'''simple docstring'''




								_lowerCAmelCase					,    _lowerCAmelCase    :    Any										=      UNetaDModel.from_pretrained("""google/ncsnpp-celebahq-256"""		,	output_loading_info=_UpperCAmelCase      )
								self.assertIsNotNone(_UpperCAmelCase      )
								self.assertEqual(len(loading_info["""missing_keys"""]      )		,	0      )

								model.to(_UpperCAmelCase      )
								_lowerCAmelCase    :    Any										=      self.dummy_input
								_lowerCAmelCase    :    str										=      floats_tensor((4, 3) + (256, 256)      ).to(_UpperCAmelCase      )
								_lowerCAmelCase    :    str										=      noise
								_lowerCAmelCase    :    Any										=      model(**_UpperCAmelCase      )

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



				@slow
				def       SCREAMING_SNAKE_CASE       (      self      :		Tuple      )  ->    Optional[Any]:





								'''simple docstring'''




								_lowerCAmelCase    :    Optional[Any]										=      UNetaDModel.from_pretrained("""google/ncsnpp-celebahq-256"""      )
								model.to(_UpperCAmelCase      )

								_lowerCAmelCase    :    Optional[int]										=      4
								_lowerCAmelCase    :    Optional[int]										=      3
								_lowerCAmelCase    :    int										=      (256, 256)

								_lowerCAmelCase    :    Any										=      torch.ones((batch_size, num_channels) + sizes      ).to(_UpperCAmelCase      )
								_lowerCAmelCase    :    int										=      torch.tensor(batch_size * [1E-4]      ).to(_UpperCAmelCase      )

								with torch.no_grad():
												_lowerCAmelCase    :    Tuple										=      model(_UpperCAmelCase		,	_UpperCAmelCase      ).sample

								_lowerCAmelCase    :    int										=      output[0, -3:, -3:, -1].flatten().cpu()
								# fmt: off
								_lowerCAmelCase    :    Union[str, Any]										=      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(_UpperCAmelCase		,	_UpperCAmelCase		,	rtol=1E-2      )      )



				def       SCREAMING_SNAKE_CASE       (      self      :		Union[str, Any]      )  ->    Dict:





								'''simple docstring'''




								_lowerCAmelCase    :    Dict										=      UNetaDModel.from_pretrained("""fusing/ncsnpp-ffhq-ve-dummy-update"""      )
								model.to(_UpperCAmelCase      )

								_lowerCAmelCase    :    List[str]										=      4
								_lowerCAmelCase    :    int										=      3
								_lowerCAmelCase    :    Dict										=      (32, 32)

								_lowerCAmelCase    :    List[str]										=      torch.ones((batch_size, num_channels) + sizes      ).to(_UpperCAmelCase      )
								_lowerCAmelCase    :    List[Any]										=      torch.tensor(batch_size * [1E-4]      ).to(_UpperCAmelCase      )

								with torch.no_grad():
												_lowerCAmelCase    :    Dict										=      model(_UpperCAmelCase		,	_UpperCAmelCase      ).sample

								_lowerCAmelCase    :    Optional[Any]										=      output[0, -3:, -3:, -1].flatten().cpu()
								# fmt: off
								_lowerCAmelCase    :    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(_UpperCAmelCase		,	_UpperCAmelCase		,	rtol=1E-2      )      )



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





								'''simple docstring'''




								pass







from math import loga




def 							_UpperCAmelCase  (UpperCamelCase_ : int       ):
				'''simple docstring'''
				if a < 0:
								raise ValueError("""Input value must be a positive integer"""       )
				elif isinstance(UpperCamelCase_      ,    UpperCamelCase_       ):
								raise TypeError("""Input value must be a 'int' type"""       )
				return 0 if (a == 0) else int(loga(a & -a       )       )


if __name__ == "__main__":
	import doctest

	doctest.testmod()

