



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 			__lowerCAmelCase    (			A				,						A				,						unittest.TestCase						):
			UpperCamelCase   					=     AutoencoderKL
			UpperCamelCase   					=     '''sample'''
			UpperCamelCase   					=     1e-2



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



						"""simple docstring"""






						_UpperCAmelCase		       =   4
						_UpperCAmelCase		       =   3
						_UpperCAmelCase		       =   (32, 32)

						_UpperCAmelCase		       =   floats_tensor((batch_size, num_channels) + sizes).to(_snake_case)

						return {"sample": image}



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



						"""simple docstring"""






						return (3, 32, 32)



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



						"""simple docstring"""






						return (3, 32, 32)



			def     _lowerCamelCase       (						self   :  List[Any])   ->    Dict:



						"""simple docstring"""






						_UpperCAmelCase		       =   {
						    '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		       =   self.dummy_input
						return init_dict, inputs_dict



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



						"""simple docstring"""






						pass



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



						"""simple docstring"""






						pass



			@unittest.skipIf(torch_device == 'mps' ,		'Gradient checkpointing skipped on MPS')
			def     _lowerCamelCase       (						self   :  Tuple)   ->    int:



						"""simple docstring"""






						_UpperCAmelCase       ,     _UpperCAmelCase		       =   self.prepare_init_args_and_inputs_for_common()
						_UpperCAmelCase		       =   self.model_class(**_snake_case)
						model.to(_snake_case)

						assert not model.is_gradient_checkpointing and model.training

						_UpperCAmelCase		       =   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		       =   torch.randn_like(_snake_case)
						_UpperCAmelCase		       =   (out - labels).mean()
						loss.backward()

						# re-instantiate the model now enabling gradient checkpointing
						_UpperCAmelCase		       =   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		       =   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		       =   (out_a - labels).mean()
						loss_a.backward()

						# compare the output and parameters gradients
						self.assertTrue((loss - loss_a).abs() < 1E-5)
						_UpperCAmelCase		       =   dict(model.named_parameters())
						_UpperCAmelCase		       =   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     _lowerCamelCase       (						self   :  str)   ->    Dict:



						"""simple docstring"""






						_UpperCAmelCase       ,     _UpperCAmelCase		       =   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		       =   model(**self.dummy_input)

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



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



						"""simple docstring"""






						_UpperCAmelCase		       =   AutoencoderKL.from_pretrained('fusing/autoencoder-kl-dummy')
						_UpperCAmelCase		       =   model.to(_snake_case)
						model.eval()

						if torch_device == "mps":
									_UpperCAmelCase		       =   torch.manual_seed(0)
						else:
									_UpperCAmelCase		       =   torch.Generator(device=_snake_case).manual_seed(0)

						_UpperCAmelCase		       =   torch.randn(
						    1 ,		model.config.in_channels ,		model.config.sample_size ,		model.config.sample_size ,		generator=torch.manual_seed(0) ,		)
						_UpperCAmelCase		       =   image.to(_snake_case)
						with torch.no_grad():
									_UpperCAmelCase		       =   model(_snake_case ,		sample_posterior=_snake_case ,		generator=_snake_case).sample

						_UpperCAmelCase		       =   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		       =   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		       =   torch.tensor(
									    [-0.1_3_5_2, 0.0_8_7_8, 0.0_4_1_9, -0.0_8_1_8, -0.1_0_6_9, 0.0_6_8_8, -0.1_4_5_8, -0.4_4_4_6, -0.0_0_2_6])
						else:
									_UpperCAmelCase		       =   torch.tensor(
									    [-0.2_4_2_1, 0.4_6_4_2, 0.2_5_0_7, -0.0_4_3_8, 0.0_6_8_2, 0.3_1_6_0, -0.2_0_1_8, -0.0_7_2_7, 0.2_4_8_5])

						self.assertTrue(torch_all_close(_snake_case ,		_snake_case ,		rtol=1E-2))







@slow
class 			__lowerCAmelCase    (			unittest.TestCase						):



			def     _lowerCamelCase       (						self   :  str ,		A   :  Any ,		A   :  Union[str, Any])   ->    Optional[Any]:



						"""simple docstring"""






						return F"gaussian_noise_s={seed}_shape={'_'.join([str(_snake_case) for s in shape])}.npy"



			def     _lowerCamelCase       (						self   :  Optional[Any])   ->    Dict:



						"""simple docstring"""






						super().tearDown()
						gc.collect()
						torch.cuda.empty_cache()



			def     _lowerCamelCase       (						self   :  Union[str, Any] ,		A   :  Tuple=0 ,		A   :  str=(4, 3, 5_12, 5_12) ,		A   :  Optional[int]=False)   ->    Any:



						"""simple docstring"""






						_UpperCAmelCase		       =   torch.floataa if fpaa else torch.floataa
						_UpperCAmelCase		       =   torch.from_numpy(load_hf_numpy(self.get_file_format(_snake_case ,		_snake_case))).to(_snake_case).to(_snake_case)
						return image



			def     _lowerCamelCase       (						self   :  List[str] ,		A   :  Any="CompVis/stable-diffusion-v1-4" ,		A   :  List[Any]=False)   ->    Optional[Any]:



						"""simple docstring"""






						_UpperCAmelCase		       =   'fp16' if fpaa else None
						_UpperCAmelCase		       =   torch.floataa if fpaa else torch.floataa

						_UpperCAmelCase		       =   AutoencoderKL.from_pretrained(
						    _snake_case ,		subfolder='vae' ,		torch_dtype=_snake_case ,		revision=_snake_case ,		)
						model.to(_snake_case).eval()

						return model



			def     _lowerCamelCase       (						self   :  str ,		A   :  int=0)   ->    Tuple:



						"""simple docstring"""






						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_6_0_3, 0.9_8_7_8, -0.0_4_9_5, -0.0_7_9_0, -0.2_7_0_9, 0.8_3_7_5, -0.2_0_6_0, -0.0_8_2_4], [-0.2_3_9_5, 0.0_0_9_8, 0.0_1_0_2, -0.0_7_0_9, -0.2_8_4_0, -0.0_2_7_4, -0.0_7_1_8, -0.1_8_2_4]],
			        [47, [-0.2_3_7_6, 0.1_1_6_8, 0.1_3_3_2, -0.4_8_4_0, -0.2_5_0_8, -0.0_7_9_1, -0.0_4_9_3, -0.4_0_8_9], [0.0_3_5_0, 0.0_8_4_7, 0.0_4_6_7, 0.0_3_4_4, -0.0_8_4_2, -0.0_5_4_7, -0.0_6_3_3, -0.1_1_3_1]],
			        # fmt: on
			    ])
			def     _lowerCamelCase       (						self   :  Optional[Any] ,		A   :  Tuple ,		A   :  int ,		A   :  Optional[Any])   ->    List[Any]:



						"""simple docstring"""






						_UpperCAmelCase		       =   self.get_sd_vae_model()
						_UpperCAmelCase		       =   self.get_sd_image(_snake_case)
						_UpperCAmelCase		       =   self.get_generator(_snake_case)

						with torch.no_grad():
									_UpperCAmelCase		       =   model(_snake_case ,		generator=_snake_case ,		sample_posterior=_snake_case).sample

						assert sample.shape == image.shape

						_UpperCAmelCase		       =   sample[-1, -2:, -2:, :2].flatten().float().cpu()
						_UpperCAmelCase		       =   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_5_1_3, 0.0_2_8_9, 1.3_7_9_9, 0.2_1_6_6, -0.2_5_7_3, -0.0_8_7_1, 0.5_1_0_3, -0.0_9_9_9]],
			        [47, [-0.4_1_2_8, -0.1_3_2_0, -0.3_7_0_4, 0.1_9_6_5, -0.4_1_1_6, -0.2_3_3_2, -0.3_3_4_0, 0.2_2_4_7]],
			        # fmt: on
			    ])
			@require_torch_gpu
			def     _lowerCamelCase       (						self   :  int ,		A   :  Union[str, Any] ,		A   :  Optional[Any])   ->    Tuple:



						"""simple docstring"""






						_UpperCAmelCase		       =   self.get_sd_vae_model(fpaa=_snake_case)
						_UpperCAmelCase		       =   self.get_sd_image(_snake_case ,		fpaa=_snake_case)
						_UpperCAmelCase		       =   self.get_generator(_snake_case)

						with torch.no_grad():
									_UpperCAmelCase		       =   model(_snake_case ,		generator=_snake_case ,		sample_posterior=_snake_case).sample

						assert sample.shape == image.shape

						_UpperCAmelCase		       =   sample[-1, -2:, :2, -2:].flatten().float().cpu()
						_UpperCAmelCase		       =   torch.tensor(_snake_case)

						assert torch_all_close(_snake_case ,		_snake_case ,		atol=1E-2)



			@parameterized.expand(
			    [
			        # fmt: off
			        [33, [-0.1_6_0_9, 0.9_8_6_6, -0.0_4_8_7, -0.0_7_7_7, -0.2_7_1_6, 0.8_3_6_8, -0.2_0_5_5, -0.0_8_1_4], [-0.2_3_9_5, 0.0_0_9_8, 0.0_1_0_2, -0.0_7_0_9, -0.2_8_4_0, -0.0_2_7_4, -0.0_7_1_8, -0.1_8_2_4]],
			        [47, [-0.2_3_7_7, 0.1_1_4_7, 0.1_3_3_3, -0.4_8_4_1, -0.2_5_0_6, -0.0_8_0_5, -0.0_4_9_1, -0.4_0_8_5], [0.0_3_5_0, 0.0_8_4_7, 0.0_4_6_7, 0.0_3_4_4, -0.0_8_4_2, -0.0_5_4_7, -0.0_6_3_3, -0.1_1_3_1]],
			        # fmt: on
			    ])
			def     _lowerCamelCase       (						self   :  int ,		A   :  Tuple ,		A   :  List[str] ,		A   :  Any)   ->    Optional[int]:



						"""simple docstring"""






						_UpperCAmelCase		       =   self.get_sd_vae_model()
						_UpperCAmelCase		       =   self.get_sd_image(_snake_case)

						with torch.no_grad():
									_UpperCAmelCase		       =   model(_snake_case).sample

						assert sample.shape == image.shape

						_UpperCAmelCase		       =   sample[-1, -2:, -2:, :2].flatten().float().cpu()
						_UpperCAmelCase		       =   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_0_5_1, -0.1_8_0_3, -0.2_3_1_1, -0.2_1_1_4, -0.3_2_9_2, -0.3_5_7_4, -0.2_9_5_3, -0.3_3_2_3]],
			        [37, [-0.2_6_3_2, -0.2_6_2_5, -0.2_1_9_9, -0.2_7_4_1, -0.4_5_3_9, -0.4_9_9_0, -0.3_7_2_0, -0.4_9_2_5]],
			        # fmt: on
			    ])
			@require_torch_gpu
			def     _lowerCamelCase       (						self   :  Tuple ,		A   :  Optional[Any] ,		A   :  Tuple)   ->    Optional[int]:



						"""simple docstring"""






						_UpperCAmelCase		       =   self.get_sd_vae_model()
						_UpperCAmelCase		       =   self.get_sd_image(_snake_case ,		shape=(3, 4, 64, 64))

						with torch.no_grad():
									_UpperCAmelCase		       =   model.decode(_snake_case).sample

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

						_UpperCAmelCase		       =   sample[-1, -2:, :2, -2:].flatten().cpu()
						_UpperCAmelCase		       =   torch.tensor(_snake_case)

						assert torch_all_close(_snake_case ,		_snake_case ,		atol=1E-3)



			@parameterized.expand(
			    [
			        # fmt: off
			        [27, [-0.0_3_6_9, 0.0_2_0_7, -0.0_7_7_6, -0.0_6_8_2, -0.1_7_4_7, -0.1_9_3_0, -0.1_4_6_5, -0.2_0_3_9]],
			        [16, [-0.1_6_2_8, -0.2_1_3_4, -0.2_7_4_7, -0.2_6_4_2, -0.3_7_7_4, -0.4_4_0_4, -0.3_6_8_7, -0.4_2_7_7]],
			        # fmt: on
			    ])
			@require_torch_gpu
			def     _lowerCamelCase       (						self   :  Tuple ,		A   :  str ,		A   :  int)   ->    Optional[Any]:



						"""simple docstring"""






						_UpperCAmelCase		       =   self.get_sd_vae_model(fpaa=_snake_case)
						_UpperCAmelCase		       =   self.get_sd_image(_snake_case ,		shape=(3, 4, 64, 64) ,		fpaa=_snake_case)

						with torch.no_grad():
									_UpperCAmelCase		       =   model.decode(_snake_case).sample

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

						_UpperCAmelCase		       =   sample[-1, -2:, :2, -2:].flatten().float().cpu()
						_UpperCAmelCase		       =   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     _lowerCamelCase       (						self   :  str ,		A   :  List[str])   ->    Union[str, Any]:



						"""simple docstring"""






						_UpperCAmelCase		       =   self.get_sd_vae_model(fpaa=_snake_case)
						_UpperCAmelCase		       =   self.get_sd_image(_snake_case ,		shape=(3, 4, 64, 64) ,		fpaa=_snake_case)

						with torch.no_grad():
									_UpperCAmelCase		       =   model.decode(_snake_case).sample

						model.enable_xformers_memory_efficient_attention()
						with torch.no_grad():
									_UpperCAmelCase		       =   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     _lowerCamelCase       (						self   :  Tuple ,		A   :  Optional[Any])   ->    List[str]:



						"""simple docstring"""






						_UpperCAmelCase		       =   self.get_sd_vae_model()
						_UpperCAmelCase		       =   self.get_sd_image(_snake_case ,		shape=(3, 4, 64, 64))

						with torch.no_grad():
									_UpperCAmelCase		       =   model.decode(_snake_case).sample

						model.enable_xformers_memory_efficient_attention()
						with torch.no_grad():
									_UpperCAmelCase		       =   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_0_0_1, 0.0_9_1_8, -2.6_9_8_4, -3.9_7_2_0, -3.2_0_9_9, -5.0_3_5_3, 1.7_3_3_8, -0.2_0_6_5, 3.4_2_6_7]],
			        [47, [-1.5_0_3_0, -4.3_8_7_1, -6.0_3_5_5, -9.1_1_5_7, -1.6_6_6_1, -2.7_8_5_3, 2.1_6_0_7, -5.0_8_2_3, 2.5_6_3_3]],
			        # fmt: on
			    ])
			def     _lowerCamelCase       (						self   :  Optional[int] ,		A   :  int ,		A   :  List[Any])   ->    Optional[int]:



						"""simple docstring"""






						_UpperCAmelCase		       =   self.get_sd_vae_model()
						_UpperCAmelCase		       =   self.get_sd_image(_snake_case)
						_UpperCAmelCase		       =   self.get_generator(_snake_case)

						with torch.no_grad():
									_UpperCAmelCase		       =   model.encode(_snake_case).latent_dist
									_UpperCAmelCase		       =   dist.sample(generator=_snake_case)

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

						_UpperCAmelCase		       =   sample[0, -1, -3:, -3:].flatten().cpu()
						_UpperCAmelCase		       =   torch.tensor(_snake_case)

						_UpperCAmelCase		       =   3E-3 if torch_device != 'mps' else 1E-2
						assert torch_all_close(_snake_case ,		_snake_case ,		atol=_snake_case)


from __future__ import annotations

import typing
from collections import Counter


def     __lowerCAmelCase			(			a__  )       ->  typing.Counter[int]:
				__a										=    Counter()
				for base in range(1						,    max_perimeter + 1  ):
								for perpendicular in range(a__						,    max_perimeter + 1  ):
												__a										=    (base * base + perpendicular * perpendicular) ** 0.5
												if hypotenuse == int(a__  ):
																__a										=    int(base + perpendicular + hypotenuse  )
																if perimeter > max_perimeter:
																				continue
																triplets[perimeter] += 1
				return triplets


def     __lowerCAmelCase			(			a__ = 1000  )       ->  int:
				__a										=    pythagorean_triple(a__  )
				return triplets.most_common(1  )[0][0]


if __name__ == "__main__":
					print(F"Perimeter {solution()} has maximum solutions")