






'''simple docstring'''





import gc
import unittest

import torch
from parameterized import parameterized

from diffusers import AutoencoderKL
from diffusers.utils import floats_tensor, load_hf_numpy, require_torch_gpu, slow, torch_all_close, torch_device
from diffusers.utils.import_utils import is_xformers_available
from diffusers.utils.testing_utils import enable_full_determinism

from .test_modeling_common import ModelTesterMixin, UNetTesterMixin


enable_full_determinism()


class  snake_case__      (					snake_case__     ,				snake_case__     ,				unittest.TestCase):
					a_        =					AutoencoderKL
					a_        =					"sample"
					a_        =					1E-2




					@property
					def 		A      (  self  :		str      )    ->							int:
								UpperCAmelCase_      :       str          =       4
								UpperCAmelCase_      :       int          =       3
								UpperCAmelCase_      :       List[str]          =       (32, 32)

								UpperCAmelCase_      :       Union[str, Any]          =       floats_tensor((batch_size, num_channels) + sizes      ).to(__snake_case      )

								return {"sample": image}




					@property
					def 		A      (  self  :		Optional[int]      )    ->							Optional[int]:
								return (3, 32, 32)




					@property
					def 		A      (  self  :		Union[str, Any]      )    ->							Union[str, Any]:
								return (3, 32, 32)




					def 		A      (  self  :		Optional[int]      )    ->							List[Any]:
								UpperCAmelCase_      :       Union[str, Any]          =       {
								    '''block_out_channels''': [32, 64],
								    '''in_channels''': 3,
								    '''out_channels''': 3,
								    '''down_block_types''': ['''DownEncoderBlock2D''', '''DownEncoderBlock2D'''],
								    '''up_block_types''': ['''UpDecoderBlock2D''', '''UpDecoderBlock2D'''],
								    '''latent_channels''': 4,
								}
								UpperCAmelCase_      :       List[str]          =       self.dummy_input
								return init_dict, inputs_dict




					def 		A      (  self  :		int      )    ->							List[str]:
								pass




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




					@unittest.skipIf(torch_device == '''mps'''				, '''Gradient checkpointing skipped on MPS'''      )
					def 		A      (  self  :		Tuple      )    ->							List[Any]:
								# enable deterministic behavior for gradient checkpointing
								UpperCAmelCase_    ,      UpperCAmelCase_      :       Union[str, Any]          =       self.prepare_init_args_and_inputs_for_common()
								UpperCAmelCase_      :       Dict          =       self.model_class(**__snake_case      )
								model.to(__snake_case      )

								assert not model.is_gradient_checkpointing and model.training

								UpperCAmelCase_      :       Dict          =       model(**__snake_case      ).sample
								# run the backwards pass on the model. For backwards pass, for simplicity purpose,
								# we won't calculate the loss and rather backprop on out.sum()
								model.zero_grad()

								UpperCAmelCase_      :       Optional[Any]          =       torch.randn_like(__snake_case      )
								UpperCAmelCase_      :       Tuple          =       (out - labels).mean()
								loss.backward()

								# re-instantiate the model now enabling gradient checkpointing
								UpperCAmelCase_      :       List[Any]          =       self.model_class(**__snake_case      )
								# clone model
								model_a.load_state_dict(model.state_dict()      )
								model_a.to(__snake_case      )
								model_a.enable_gradient_checkpointing()

								assert model_a.is_gradient_checkpointing and model_a.training

								UpperCAmelCase_      :       Optional[Any]          =       model_a(**__snake_case      ).sample
								# run the backwards pass on the model. For backwards pass, for simplicity purpose,
								# we won't calculate the loss and rather backprop on out.sum()
								model_a.zero_grad()
								UpperCAmelCase_      :       List[Any]          =       (out_a - labels).mean()
								loss_a.backward()

								# compare the output and parameters gradients
								self.assertTrue((loss - loss_a).abs() < 1e-5      )
								UpperCAmelCase_      :       Tuple          =       dict(model.named_parameters()      )
								UpperCAmelCase_      :       Optional[int]          =       dict(model_a.named_parameters()      )
								for name, param in named_params.items():
											self.assertTrue(torch_all_close(param.grad.data				, named_params_a[name].grad.data				, atol=5e-5      )      )




					def 		A      (  self  :		Tuple      )    ->							Optional[Any]:
								UpperCAmelCase_    ,      UpperCAmelCase_      :       str          =       AutoencoderKL.from_pretrained('''fusing/autoencoder-kl-dummy'''				, output_loading_info=__snake_case      )
								self.assertIsNotNone(__snake_case      )
								self.assertEqual(len(loading_info['''missing_keys''']      )				, 0      )

								model.to(__snake_case      )
								UpperCAmelCase_      :       Optional[Any]          =       model(**self.dummy_input      )

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





					def 		A      (  self  :		Optional[int]      )    ->							Tuple:
								UpperCAmelCase_      :       str          =       AutoencoderKL.from_pretrained('''fusing/autoencoder-kl-dummy'''      )
								UpperCAmelCase_      :       Union[str, Any]          =       model.to(__snake_case      )
								model.eval()

								if torch_device == "mps":
											UpperCAmelCase_      :       List[Any]          =       torch.manual_seed(0      )
								else:
											UpperCAmelCase_      :       Optional[Any]          =       torch.Generator(device=__snake_case      ).manual_seed(0      )

								UpperCAmelCase_      :       str          =       torch.randn(
								    1				, model.config.in_channels				, model.config.sample_size				, model.config.sample_size				, generator=torch.manual_seed(0      )				, )
								UpperCAmelCase_      :       List[str]          =       image.to(__snake_case      )
								with torch.no_grad():
											UpperCAmelCase_      :       Dict          =       model(__snake_case				, sample_posterior=__snake_case				, generator=__snake_case      ).sample

								UpperCAmelCase_      :       Dict          =       output[0, -1, -3:, -3:].flatten().cpu()

								# Since the VAE Gaussian prior's generator is seeded on the appropriate device,
								# the expected output slices are not the same for CPU and GPU.
								if torch_device == "mps":
											UpperCAmelCase_      :       Any          =       torch.tensor(
											    [
											        -4.0078e-01,
											        -3.8323e-04,
											        -1.2681e-01,
											        -1.1462e-01,
											        2.0095e-01,
											        1.0893e-01,
											        -8.8247e-02,
											        -3.0361e-01,
											        -9.8644e-03,
											    ]      )
								elif torch_device == "cpu":
											UpperCAmelCase_      :       Tuple          =       torch.tensor(
											    [-0.1_352, 0.0_878, 0.0_419, -0.0_818, -0.1_069, 0.0_688, -0.1_458, -0.4_446, -0.0_026]      )
								else:
											UpperCAmelCase_      :       List[Any]          =       torch.tensor(
											    [-0.2_421, 0.4_642, 0.2_507, -0.0_438, 0.0_682, 0.3_160, -0.2_018, -0.0_727, 0.2_485]      )

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






@slow
class  snake_case__      (					unittest.TestCase):




					def 		A      (  self  :		Tuple				, _A  :		Union[str, Any]				, _A  :		Any      )    ->							List[Any]:
								return F"gaussian_noise_s={seed}_shape={'_'.join([str(__snake_case      ) for s in shape]      )}.npy"




					def 		A      (  self  :		Optional[int]      )    ->							Union[str, Any]:
								# clean up the VRAM after each test
								super().tearDown()
								gc.collect()
								torch.cuda.empty_cache()




					def 		A      (  self  :		Optional[Any]				, _A  :		Optional[Any]=0				, _A  :		Union[str, Any]=(4, 3, 5_12, 5_12)				, _A  :		Optional[int]=False      )    ->							Tuple:
								UpperCAmelCase_      :       Optional[int]          =       torch.floataa if fpaa else torch.floataa
								UpperCAmelCase_      :       List[Any]          =       torch.from_numpy(load_hf_numpy(self.get_file_format(__snake_case				, __snake_case      )      )      ).to(__snake_case      ).to(__snake_case      )
								return image




					def 		A      (  self  :		int				, _A  :		List[Any]="CompVis/stable-diffusion-v1-4"				, _A  :		Optional[Any]=False      )    ->							Tuple:
								UpperCAmelCase_      :       Dict          =       '''fp16''' if fpaa else None
								UpperCAmelCase_      :       List[Any]          =       torch.floataa if fpaa else torch.floataa

								UpperCAmelCase_      :       Tuple          =       AutoencoderKL.from_pretrained(
								    __snake_case				, subfolder='''vae'''				, torch_dtype=__snake_case				, revision=__snake_case				, )
								model.to(__snake_case      ).eval()

								return model




					def 		A      (  self  :		Optional[int]				, _A  :		Dict=0      )    ->							int:
								if torch_device == "mps":
											return torch.manual_seed(__snake_case      )
								return torch.Generator(device=__snake_case      ).manual_seed(__snake_case      )




					@parameterized.expand(
					    [
					        # fmt: off
					        [33, [-0.1_603, 0.9_878, -0.0_495, -0.0_790, -0.2_709, 0.8_375, -0.2_060, -0.0_824], [-0.2_395, 0.0_098, 0.0_102, -0.0_709, -0.2_840, -0.0_274, -0.0_718, -0.1_824]],
					        [47, [-0.2_376, 0.1_168, 0.1_332, -0.4_840, -0.2_508, -0.0_791, -0.0_493, -0.4_089], [0.0_350, 0.0_847, 0.0_467, 0.0_344, -0.0_842, -0.0_547, -0.0_633, -0.1_131]],
					        # fmt: on
					    ]      )
					def 		A      (  self  :		List[Any]				, _A  :		Optional[int]				, _A  :		Dict				, _A  :		int      )    ->							Optional[int]:
								UpperCAmelCase_      :       Union[str, Any]          =       self.get_sd_vae_model()
								UpperCAmelCase_      :       List[str]          =       self.get_sd_image(__snake_case      )
								UpperCAmelCase_      :       Union[str, Any]          =       self.get_generator(__snake_case      )

								with torch.no_grad():
											UpperCAmelCase_      :       Union[str, Any]          =       model(__snake_case				, generator=__snake_case				, sample_posterior=__snake_case      ).sample

								assert sample.shape == image.shape

								UpperCAmelCase_      :       Union[str, Any]          =       sample[-1, -2:, -2:, :2].flatten().float().cpu()
								UpperCAmelCase_      :       Dict          =       torch.tensor(expected_slice_mps if torch_device == '''mps''' else expected_slice      )

								assert torch_all_close(__snake_case				, __snake_case				, atol=3e-3      )




					@parameterized.expand(
					    [
					        # fmt: off
					        [33, [-0.0_513, 0.0_289, 1.3_799, 0.2_166, -0.2_573, -0.0_871, 0.5_103, -0.0_999]],
					        [47, [-0.4_128, -0.1_320, -0.3_704, 0.1_965, -0.4_116, -0.2_332, -0.3_340, 0.2_247]],
					        # fmt: on
					    ]      )
					@require_torch_gpu
					def 		A      (  self  :		Optional[int]				, _A  :		List[Any]				, _A  :		List[str]      )    ->							str:
								UpperCAmelCase_      :       List[str]          =       self.get_sd_vae_model(fpaa=__snake_case      )
								UpperCAmelCase_      :       Optional[Any]          =       self.get_sd_image(__snake_case				, fpaa=__snake_case      )
								UpperCAmelCase_      :       Dict          =       self.get_generator(__snake_case      )

								with torch.no_grad():
											UpperCAmelCase_      :       Dict          =       model(__snake_case				, generator=__snake_case				, sample_posterior=__snake_case      ).sample

								assert sample.shape == image.shape

								UpperCAmelCase_      :       Any          =       sample[-1, -2:, :2, -2:].flatten().float().cpu()
								UpperCAmelCase_      :       Tuple          =       torch.tensor(__snake_case      )

								assert torch_all_close(__snake_case				, __snake_case				, atol=1e-2      )




					@parameterized.expand(
					    [
					        # fmt: off
					        [33, [-0.1_609, 0.9_866, -0.0_487, -0.0_777, -0.2_716, 0.8_368, -0.2_055, -0.0_814], [-0.2_395, 0.0_098, 0.0_102, -0.0_709, -0.2_840, -0.0_274, -0.0_718, -0.1_824]],
					        [47, [-0.2_377, 0.1_147, 0.1_333, -0.4_841, -0.2_506, -0.0_805, -0.0_491, -0.4_085], [0.0_350, 0.0_847, 0.0_467, 0.0_344, -0.0_842, -0.0_547, -0.0_633, -0.1_131]],
					        # fmt: on
					    ]      )
					def 		A      (  self  :		str				, _A  :		Union[str, Any]				, _A  :		Optional[int]				, _A  :		Dict      )    ->							List[Any]:
								UpperCAmelCase_      :       List[str]          =       self.get_sd_vae_model()
								UpperCAmelCase_      :       int          =       self.get_sd_image(__snake_case      )

								with torch.no_grad():
											UpperCAmelCase_      :       Dict          =       model(__snake_case      ).sample

								assert sample.shape == image.shape

								UpperCAmelCase_      :       Tuple          =       sample[-1, -2:, -2:, :2].flatten().float().cpu()
								UpperCAmelCase_      :       Any          =       torch.tensor(expected_slice_mps if torch_device == '''mps''' else expected_slice      )

								assert torch_all_close(__snake_case				, __snake_case				, atol=3e-3      )




					@parameterized.expand(
					    [
					        # fmt: off
					        [13, [-0.2_051, -0.1_803, -0.2_311, -0.2_114, -0.3_292, -0.3_574, -0.2_953, -0.3_323]],
					        [37, [-0.2_632, -0.2_625, -0.2_199, -0.2_741, -0.4_539, -0.4_990, -0.3_720, -0.4_925]],
					        # fmt: on
					    ]      )
					@require_torch_gpu
					def 		A      (  self  :		Any				, _A  :		List[str]				, _A  :		Optional[Any]      )    ->							int:
								UpperCAmelCase_      :       List[str]          =       self.get_sd_vae_model()
								UpperCAmelCase_      :       List[str]          =       self.get_sd_image(__snake_case				, shape=(3, 4, 64, 64)      )

								with torch.no_grad():
											UpperCAmelCase_      :       List[str]          =       model.decode(__snake_case      ).sample

								assert list(sample.shape      ) == [3, 3, 5_12, 5_12]

								UpperCAmelCase_      :       Dict          =       sample[-1, -2:, :2, -2:].flatten().cpu()
								UpperCAmelCase_      :       List[Any]          =       torch.tensor(__snake_case      )

								assert torch_all_close(__snake_case				, __snake_case				, atol=1e-3      )




					@parameterized.expand(
					    [
					        # fmt: off
					        [27, [-0.0_369, 0.0_207, -0.0_776, -0.0_682, -0.1_747, -0.1_930, -0.1_465, -0.2_039]],
					        [16, [-0.1_628, -0.2_134, -0.2_747, -0.2_642, -0.3_774, -0.4_404, -0.3_687, -0.4_277]],
					        # fmt: on
					    ]      )
					@require_torch_gpu
					def 		A      (  self  :		Any				, _A  :		List[Any]				, _A  :		str      )    ->							Dict:
								UpperCAmelCase_      :       Optional[int]          =       self.get_sd_vae_model(fpaa=__snake_case      )
								UpperCAmelCase_      :       List[Any]          =       self.get_sd_image(__snake_case				, shape=(3, 4, 64, 64)				, fpaa=__snake_case      )

								with torch.no_grad():
											UpperCAmelCase_      :       List[Any]          =       model.decode(__snake_case      ).sample

								assert list(sample.shape      ) == [3, 3, 5_12, 5_12]

								UpperCAmelCase_      :       str          =       sample[-1, -2:, :2, -2:].flatten().float().cpu()
								UpperCAmelCase_      :       int          =       torch.tensor(__snake_case      )

								assert torch_all_close(__snake_case				, __snake_case				, atol=5e-3      )




					@parameterized.expand([(13,), (16,), (27,)]      )
					@require_torch_gpu
					@unittest.skipIf(not is_xformers_available()				, reason='''xformers is not required when using PyTorch 2.0.'''      )
					def 		A      (  self  :		Any				, _A  :		Dict      )    ->							int:
								UpperCAmelCase_      :       int          =       self.get_sd_vae_model(fpaa=__snake_case      )
								UpperCAmelCase_      :       Union[str, Any]          =       self.get_sd_image(__snake_case				, shape=(3, 4, 64, 64)				, fpaa=__snake_case      )

								with torch.no_grad():
											UpperCAmelCase_      :       List[Any]          =       model.decode(__snake_case      ).sample

								model.enable_xformers_memory_efficient_attention()
								with torch.no_grad():
											UpperCAmelCase_      :       Optional[int]          =       model.decode(__snake_case      ).sample

								assert list(sample.shape      ) == [3, 3, 5_12, 5_12]

								assert torch_all_close(__snake_case				, __snake_case				, atol=1e-1      )




					@parameterized.expand([(13,), (16,), (37,)]      )
					@require_torch_gpu
					@unittest.skipIf(not is_xformers_available()				, reason='''xformers is not required when using PyTorch 2.0.'''      )
					def 		A      (  self  :		List[str]				, _A  :		List[str]      )    ->							Union[str, Any]:
								UpperCAmelCase_      :       Optional[Any]          =       self.get_sd_vae_model()
								UpperCAmelCase_      :       Union[str, Any]          =       self.get_sd_image(__snake_case				, shape=(3, 4, 64, 64)      )

								with torch.no_grad():
											UpperCAmelCase_      :       List[str]          =       model.decode(__snake_case      ).sample

								model.enable_xformers_memory_efficient_attention()
								with torch.no_grad():
											UpperCAmelCase_      :       str          =       model.decode(__snake_case      ).sample

								assert list(sample.shape      ) == [3, 3, 5_12, 5_12]

								assert torch_all_close(__snake_case				, __snake_case				, atol=1e-2      )





					@parameterized.expand(
					    [
					        # fmt: off
					        [33, [-0.3_001, 0.0_918, -2.6_984, -3.9_720, -3.2_099, -5.0_353, 1.7_338, -0.2_065, 3.4_267]],
					        [47, [-1.5_030, -4.3_871, -6.0_355, -9.1_157, -1.6_661, -2.7_853, 2.1_607, -5.0_823, 2.5_633]],
					        # fmt: on
					    ]      )
					def 		A      (  self  :		Optional[Any]				, _A  :		Optional[int]				, _A  :		List[Any]      )    ->							str:
								UpperCAmelCase_      :       str          =       self.get_sd_vae_model()
								UpperCAmelCase_      :       List[str]          =       self.get_sd_image(__snake_case      )
								UpperCAmelCase_      :       List[str]          =       self.get_generator(__snake_case      )

								with torch.no_grad():
											UpperCAmelCase_      :       Optional[Any]          =       model.encode(__snake_case      ).latent_dist
											UpperCAmelCase_      :       str          =       dist.sample(generator=__snake_case      )

								assert list(sample.shape      ) == [image.shape[0], 4] + [i // 8 for i in image.shape[2:]]

								UpperCAmelCase_      :       Dict          =       sample[0, -1, -3:, -3:].flatten().cpu()
								UpperCAmelCase_      :       Tuple          =       torch.tensor(__snake_case      )

								UpperCAmelCase_      :       List[Any]          =       3e-3 if torch_device != '''mps''' else 1e-2
								assert torch_all_close(__snake_case				, __snake_case				, atol=__snake_case      )






from functools import lru_cache
def      UpperCAmelCase__		(UpperCamelCase_							):



     """simple docstring"""






     snake_case											=							2
     snake_case											=							set()
     while i * i <= n:
          if n % i:
               i += 1
          else:
               n //= i
               factors.add(UpperCamelCase_							)
     if n > 1:
          factors.add(UpperCamelCase_							)
     return factors
@lru_cache
def      UpperCAmelCase__		(UpperCamelCase_							):



     """simple docstring"""






     return len(unique_prime_factors(UpperCamelCase_							)							)
def      UpperCAmelCase__		(UpperCamelCase_							):



     """simple docstring"""






     return len(set(UpperCamelCase_							)							) in (0, 1)
def      UpperCAmelCase__		(UpperCamelCase_							):



     """simple docstring"""






     snake_case											=							2

     while True:
          # Increment each value of a generated range
          snake_case											=							[base + i for i in range(UpperCamelCase_							)]

          # Run elements through out unique_prime_factors function
          # Append our target number to the end.
          snake_case											=							[upf_len(UpperCamelCase_							) for x in group]
          checker.append(UpperCamelCase_							)

          # If all numbers in the list are equal, return the group variable.
          if equality(UpperCamelCase_							):
               return group

          # Increment our base variable by 1
          base += 1
def      UpperCAmelCase__		(UpperCamelCase_ = 4							):



     """simple docstring"""






     snake_case											=							run(UpperCamelCase_							)
     return results[0] if len(UpperCamelCase_							) else None


if __name__ == "__main__":
 print(solution())




