


"""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 _lowerCAmelCase       (   snake_case_					,							snake_case_					,							unittest.TestCase			):
   __UpperCAmelCase				: List[Any]													=						AutoencoderKL
   __UpperCAmelCase				: Union[str, Any]													=						'''sample'''
   __UpperCAmelCase				: List[Any]													=						1E-2







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

       '''simple docstring'''




       snake_case					:   int         =					4
       snake_case					:   Dict         =					3
       snake_case					:   Any         =					(32, 32)

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

       return {"sample": image}







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

       '''simple docstring'''




       return (3, 32, 32)







   @property
   def 				lowerCamelCase	(			self		)			->	Tuple:

       '''simple docstring'''




       return (3, 32, 32)







   def 				lowerCamelCase	(			self		)			->	List[str]:

       '''simple docstring'''




       snake_case					:   Optional[int]         =					{
           "block_out_channels": [32, 64],
           "in_channels": 3,
           "out_channels": 3,
           "down_block_types": ["DownEncoderBlock2D", "DownEncoderBlock2D"],
           "up_block_types": ["UpDecoderBlock2D", "UpDecoderBlock2D"],
           "latent_channels": 4,
       }
       snake_case					:   List[str]         =					self.dummy_input
       return init_dict, inputs_dict







   def 				lowerCamelCase	(			self		)			->	List[str]:

       '''simple docstring'''




       pass







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

       '''simple docstring'''




       pass







   @unittest.skipIf(torch_device == "mps"		,			"Gradient checkpointing skipped on MPS"		)
   def 				lowerCamelCase	(			self		)			->	List[str]:

       '''simple docstring'''




       snake_case      ,snake_case					:   Any         =					self.prepare_init_args_and_inputs_for_common()
       snake_case					:   int         =					self.model_class(**UpperCamelCase__		)
       model.to(UpperCamelCase__		)

       assert not model.is_gradient_checkpointing and model.training

       snake_case					:   List[str]         =					model(**UpperCamelCase__		).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()

       snake_case					:   Dict         =					torch.randn_like(UpperCamelCase__		)
       snake_case					:   Union[str, Any]         =					(out - labels).mean()
       loss.backward()

       # re-instantiate the model now enabling gradient checkpointing
       snake_case					:   Dict         =					self.model_class(**UpperCamelCase__		)
       # clone model
       model_a.load_state_dict(model.state_dict()		)
       model_a.to(UpperCamelCase__		)
       model_a.enable_gradient_checkpointing()

       assert model_a.is_gradient_checkpointing and model_a.training

       snake_case					:   str         =					model_a(**UpperCamelCase__		).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()
       snake_case					:   Dict         =					(out_a - labels).mean()
       loss_a.backward()

       # compare the output and parameters gradients
       self.assertTrue((loss - loss_a).abs() < 1e-5		)
       snake_case					:   Tuple         =					dict(model.named_parameters()		)
       snake_case					:   List[Any]         =					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		)			->	Dict:

       '''simple docstring'''




       snake_case      ,snake_case					:   str         =					AutoencoderKL.from_pretrained("fusing/autoencoder-kl-dummy"		,			output_loading_info=UpperCamelCase__		)
       self.assertIsNotNone(UpperCamelCase__		)
       self.assertEqual(len(loading_info["missing_keys"]		)		,			0		)

       model.to(UpperCamelCase__		)
       snake_case					:   Any         =					model(**self.dummy_input		)

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







   def 				lowerCamelCase	(			self		)			->	str:

       '''simple docstring'''




       snake_case					:   Tuple         =					AutoencoderKL.from_pretrained("fusing/autoencoder-kl-dummy"		)
       snake_case					:   List[str]         =					model.to(UpperCamelCase__		)
       model.eval()

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

       snake_case					:   Tuple         =					torch.randn(
           1		,			model.config.in_channels		,			model.config.sample_size		,			model.config.sample_size		,			generator=torch.manual_seed(0		)		,			)
       snake_case					:   Union[str, Any]         =					image.to(UpperCamelCase__		)
       with torch.no_grad():
           snake_case					:   str         =					model(UpperCamelCase__		,			sample_posterior=UpperCamelCase__		,			generator=UpperCamelCase__		).sample

       snake_case					:   Any         =					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":
           snake_case					:   str         =					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":
           snake_case					:   Optional[Any]         =					torch.tensor(
               [-0.1352, 0.0878, 0.0419, -0.0818, -0.1069, 0.0688, -0.1458, -0.4446, -0.0026]		)
       else:
           snake_case					:   Union[str, Any]         =					torch.tensor(
               [-0.2421, 0.4642, 0.2507, -0.0438, 0.0682, 0.3160, -0.2018, -0.0727, 0.2485]		)

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







@slow
class _lowerCAmelCase       (   unittest.TestCase			):







   def 				lowerCamelCase	(			self		,			UpperCamelCase__		,			UpperCamelCase__		)			->	List[str]:

       '''simple docstring'''




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







   def 				lowerCamelCase	(			self		)			->	Tuple:

       '''simple docstring'''




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







   def 				lowerCamelCase	(			self		,			UpperCamelCase__=0		,			UpperCamelCase__=(4, 3, 512, 512)		,			UpperCamelCase__=False		)			->	int:

       '''simple docstring'''




       snake_case					:   Union[str, Any]         =					torch.floataa if fpaa else torch.floataa
       snake_case					:   List[str]         =					torch.from_numpy(load_hf_numpy(self.get_file_format(UpperCamelCase__		,			UpperCamelCase__		)		)		).to(UpperCamelCase__		).to(UpperCamelCase__		)
       return image







   def 				lowerCamelCase	(			self		,			UpperCamelCase__="CompVis/stable-diffusion-v1-4"		,			UpperCamelCase__=False		)			->	Union[str, Any]:

       '''simple docstring'''




       snake_case					:   List[Any]         =					"fp16" if fpaa else None
       snake_case					:   Tuple         =					torch.floataa if fpaa else torch.floataa

       snake_case					:   int         =					AutoencoderKL.from_pretrained(
           UpperCamelCase__		,			subfolder="vae"		,			torch_dtype=UpperCamelCase__		,			revision=UpperCamelCase__		,			)
       model.to(UpperCamelCase__		).eval()

       return model







   def 				lowerCamelCase	(			self		,			UpperCamelCase__=0		)			->	Tuple:

       '''simple docstring'''




       if torch_device == "mps":
           return torch.manual_seed(UpperCamelCase__		)
       return torch.Generator(device=UpperCamelCase__		).manual_seed(UpperCamelCase__		)







   @parameterized.expand(
       [
           # fmt: off
           [33, [-0.1603, 0.9878, -0.0495, -0.0790, -0.2709, 0.8375, -0.2060, -0.0824], [-0.2395, 0.0098, 0.0102, -0.0709, -0.2840, -0.0274, -0.0718, -0.1824]],
           [47, [-0.2376, 0.1168, 0.1332, -0.4840, -0.2508, -0.0791, -0.0493, -0.4089], [0.0350, 0.0847, 0.0467, 0.0344, -0.0842, -0.0547, -0.0633, -0.1131]],
           # fmt: on
       ]		)
   def 				lowerCamelCase	(			self		,			UpperCamelCase__		,			UpperCamelCase__		,			UpperCamelCase__		)			->	Any:

       '''simple docstring'''




       snake_case					:   List[Any]         =					self.get_sd_vae_model()
       snake_case					:   Union[str, Any]         =					self.get_sd_image(UpperCamelCase__		)
       snake_case					:   List[Any]         =					self.get_generator(UpperCamelCase__		)

       with torch.no_grad():
           snake_case					:   int         =					model(UpperCamelCase__		,			generator=UpperCamelCase__		,			sample_posterior=UpperCamelCase__		).sample

       assert sample.shape == image.shape

       snake_case					:   int         =					sample[-1, -2:, -2:, :2].flatten().float().cpu()
       snake_case					:   List[str]         =					torch.tensor(expected_slice_mps if torch_device == "mps" else expected_slice		)

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







   @parameterized.expand(
       [
           # fmt: off
           [33, [-0.0513, 0.0289, 1.3799, 0.2166, -0.2573, -0.0871, 0.5103, -0.0999]],
           [47, [-0.4128, -0.1320, -0.3704, 0.1965, -0.4116, -0.2332, -0.3340, 0.2247]],
           # fmt: on
       ]		)
   @require_torch_gpu
   def 				lowerCamelCase	(			self		,			UpperCamelCase__		,			UpperCamelCase__		)			->	Optional[Any]:

       '''simple docstring'''




       snake_case					:   List[str]         =					self.get_sd_vae_model(fpaa=UpperCamelCase__		)
       snake_case					:   List[Any]         =					self.get_sd_image(UpperCamelCase__		,			fpaa=UpperCamelCase__		)
       snake_case					:   List[Any]         =					self.get_generator(UpperCamelCase__		)

       with torch.no_grad():
           snake_case					:   Optional[int]         =					model(UpperCamelCase__		,			generator=UpperCamelCase__		,			sample_posterior=UpperCamelCase__		).sample

       assert sample.shape == image.shape

       snake_case					:   Any         =					sample[-1, -2:, :2, -2:].flatten().float().cpu()
       snake_case					:   Union[str, Any]         =					torch.tensor(UpperCamelCase__		)

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







   @parameterized.expand(
       [
           # fmt: off
           [33, [-0.1609, 0.9866, -0.0487, -0.0777, -0.2716, 0.8368, -0.2055, -0.0814], [-0.2395, 0.0098, 0.0102, -0.0709, -0.2840, -0.0274, -0.0718, -0.1824]],
           [47, [-0.2377, 0.1147, 0.1333, -0.4841, -0.2506, -0.0805, -0.0491, -0.4085], [0.0350, 0.0847, 0.0467, 0.0344, -0.0842, -0.0547, -0.0633, -0.1131]],
           # fmt: on
       ]		)
   def 				lowerCamelCase	(			self		,			UpperCamelCase__		,			UpperCamelCase__		,			UpperCamelCase__		)			->	Optional[Any]:

       '''simple docstring'''




       snake_case					:   List[Any]         =					self.get_sd_vae_model()
       snake_case					:   str         =					self.get_sd_image(UpperCamelCase__		)

       with torch.no_grad():
           snake_case					:   Optional[Any]         =					model(UpperCamelCase__		).sample

       assert sample.shape == image.shape

       snake_case					:   Optional[Any]         =					sample[-1, -2:, -2:, :2].flatten().float().cpu()
       snake_case					:   Dict         =					torch.tensor(expected_slice_mps if torch_device == "mps" else expected_slice		)

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







   @parameterized.expand(
       [
           # fmt: off
           [13, [-0.2051, -0.1803, -0.2311, -0.2114, -0.3292, -0.3574, -0.2953, -0.3323]],
           [37, [-0.2632, -0.2625, -0.2199, -0.2741, -0.4539, -0.4990, -0.3720, -0.4925]],
           # fmt: on
       ]		)
   @require_torch_gpu
   def 				lowerCamelCase	(			self		,			UpperCamelCase__		,			UpperCamelCase__		)			->	List[Any]:

       '''simple docstring'''




       snake_case					:   Dict         =					self.get_sd_vae_model()
       snake_case					:   Union[str, Any]         =					self.get_sd_image(UpperCamelCase__		,			shape=(3, 4, 64, 64)		)

       with torch.no_grad():
           snake_case					:   List[Any]         =					model.decode(UpperCamelCase__		).sample

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

       snake_case					:   int         =					sample[-1, -2:, :2, -2:].flatten().cpu()
       snake_case					:   Optional[Any]         =					torch.tensor(UpperCamelCase__		)

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







   @parameterized.expand(
       [
           # fmt: off
           [27, [-0.0369, 0.0207, -0.0776, -0.0682, -0.1747, -0.1930, -0.1465, -0.2039]],
           [16, [-0.1628, -0.2134, -0.2747, -0.2642, -0.3774, -0.4404, -0.3687, -0.4277]],
           # fmt: on
       ]		)
   @require_torch_gpu
   def 				lowerCamelCase	(			self		,			UpperCamelCase__		,			UpperCamelCase__		)			->	Tuple:

       '''simple docstring'''




       snake_case					:   str         =					self.get_sd_vae_model(fpaa=UpperCamelCase__		)
       snake_case					:   Dict         =					self.get_sd_image(UpperCamelCase__		,			shape=(3, 4, 64, 64)		,			fpaa=UpperCamelCase__		)

       with torch.no_grad():
           snake_case					:   Union[str, Any]         =					model.decode(UpperCamelCase__		).sample

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

       snake_case					:   Dict         =					sample[-1, -2:, :2, -2:].flatten().float().cpu()
       snake_case					:   List[Any]         =					torch.tensor(UpperCamelCase__		)

       assert torch_all_close(UpperCamelCase__		,			UpperCamelCase__		,			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		,			UpperCamelCase__		)			->	Tuple:

       '''simple docstring'''




       snake_case					:   Tuple         =					self.get_sd_vae_model(fpaa=UpperCamelCase__		)
       snake_case					:   Optional[int]         =					self.get_sd_image(UpperCamelCase__		,			shape=(3, 4, 64, 64)		,			fpaa=UpperCamelCase__		)

       with torch.no_grad():
           snake_case					:   Any         =					model.decode(UpperCamelCase__		).sample

       model.enable_xformers_memory_efficient_attention()
       with torch.no_grad():
           snake_case					:   List[Any]         =					model.decode(UpperCamelCase__		).sample

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

       assert torch_all_close(UpperCamelCase__		,			UpperCamelCase__		,			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		,			UpperCamelCase__		)			->	Tuple:

       '''simple docstring'''




       snake_case					:   Dict         =					self.get_sd_vae_model()
       snake_case					:   str         =					self.get_sd_image(UpperCamelCase__		,			shape=(3, 4, 64, 64)		)

       with torch.no_grad():
           snake_case					:   Tuple         =					model.decode(UpperCamelCase__		).sample

       model.enable_xformers_memory_efficient_attention()
       with torch.no_grad():
           snake_case					:   List[str]         =					model.decode(UpperCamelCase__		).sample

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

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







   @parameterized.expand(
       [
           # fmt: off
           [33, [-0.3001, 0.0918, -2.6984, -3.9720, -3.2099, -5.0353, 1.7338, -0.2065, 3.4267]],
           [47, [-1.5030, -4.3871, -6.0355, -9.1157, -1.6661, -2.7853, 2.1607, -5.0823, 2.5633]],
           # fmt: on
       ]		)
   def 				lowerCamelCase	(			self		,			UpperCamelCase__		,			UpperCamelCase__		)			->	str:

       '''simple docstring'''




       snake_case					:   List[str]         =					self.get_sd_vae_model()
       snake_case					:   str         =					self.get_sd_image(UpperCamelCase__		)
       snake_case					:   int         =					self.get_generator(UpperCamelCase__		)

       with torch.no_grad():
           snake_case					:   int         =					model.encode(UpperCamelCase__		).latent_dist
           snake_case					:   str         =					dist.sample(generator=UpperCamelCase__		)

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

       snake_case					:   str         =					sample[0, -1, -3:, -3:].flatten().cpu()
       snake_case					:   List[str]         =					torch.tensor(UpperCamelCase__		)

       snake_case					:   Optional[Any]         =					3e-3 if torch_device != "mps" else 1e-2
       assert torch_all_close(UpperCamelCase__		,			UpperCamelCase__		,			atol=UpperCamelCase__		)









"""simple docstring"""



from collections import OrderedDict
from typing import Mapping

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging


__snake_case         =					logging.get_logger(__name__)

__snake_case         =					{
    """facebook/xmod-base""": """https://huggingface.co/facebook/xmod-base/resolve/main/config.json""",
    """facebook/xmod-large-prenorm""": """https://huggingface.co/facebook/xmod-large-prenorm/resolve/main/config.json""",
    """facebook/xmod-base-13-125k""": """https://huggingface.co/facebook/xmod-base-13-125k/resolve/main/config.json""",
    """facebook/xmod-base-30-125k""": """https://huggingface.co/facebook/xmod-base-30-125k/resolve/main/config.json""",
    """facebook/xmod-base-30-195k""": """https://huggingface.co/facebook/xmod-base-30-195k/resolve/main/config.json""",
    """facebook/xmod-base-60-125k""": """https://huggingface.co/facebook/xmod-base-60-125k/resolve/main/config.json""",
    """facebook/xmod-base-60-265k""": """https://huggingface.co/facebook/xmod-base-60-265k/resolve/main/config.json""",
    """facebook/xmod-base-75-125k""": """https://huggingface.co/facebook/xmod-base-75-125k/resolve/main/config.json""",
    """facebook/xmod-base-75-269k""": """https://huggingface.co/facebook/xmod-base-75-269k/resolve/main/config.json""",
}







class _lowerCAmelCase       (   snake_case_			):
   __UpperCAmelCase				: Union[str, Any]													=						'''xmod'''







   def __init__(			self		,			UpperCamelCase__=3_0522		,			UpperCamelCase__=768		,			UpperCamelCase__=12		,			UpperCamelCase__=12		,			UpperCamelCase__=3072		,			UpperCamelCase__="gelu"		,			UpperCamelCase__=0.1		,			UpperCamelCase__=0.1		,			UpperCamelCase__=512		,			UpperCamelCase__=2		,			UpperCamelCase__=0.02		,			UpperCamelCase__=1e-12		,			UpperCamelCase__=1		,			UpperCamelCase__=0		,			UpperCamelCase__=2		,			UpperCamelCase__="absolute"		,			UpperCamelCase__=True		,			UpperCamelCase__=None		,			UpperCamelCase__=False		,			UpperCamelCase__=2		,			UpperCamelCase__=False		,			UpperCamelCase__=True		,			UpperCamelCase__=True		,			UpperCamelCase__=("en_XX",)		,			UpperCamelCase__=None		,			**UpperCamelCase__		,			)			->	List[str]:

       '''simple docstring'''




       super().__init__(pad_token_id=UpperCamelCase__		,			bos_token_id=UpperCamelCase__		,			eos_token_id=UpperCamelCase__		,			**UpperCamelCase__		)

       snake_case					:   Optional[int]         =					vocab_size
       snake_case					:   Optional[Any]         =					hidden_size
       snake_case					:   Union[str, Any]         =					num_hidden_layers
       snake_case					:   int         =					num_attention_heads
       snake_case					:   Dict         =					hidden_act
       snake_case					:   Union[str, Any]         =					intermediate_size
       snake_case					:   str         =					hidden_dropout_prob
       snake_case					:   List[str]         =					attention_probs_dropout_prob
       snake_case					:   Dict         =					max_position_embeddings
       snake_case					:   Union[str, Any]         =					type_vocab_size
       snake_case					:   Union[str, Any]         =					initializer_range
       snake_case					:   str         =					layer_norm_eps
       snake_case					:   Dict         =					position_embedding_type
       snake_case					:   Any         =					use_cache
       snake_case					:   str         =					classifier_dropout
       snake_case					:   Any         =					pre_norm
       snake_case					:   Union[str, Any]         =					adapter_reduction_factor
       snake_case					:   Optional[int]         =					adapter_layer_norm
       snake_case					:   int         =					adapter_reuse_layer_norm
       snake_case					:   List[Any]         =					ln_before_adapter
       snake_case					:   Tuple         =					list(UpperCamelCase__		)
       snake_case					:   Tuple         =					default_language







class _lowerCAmelCase       (   snake_case_			):







   @property
   def 				lowerCamelCase	(			self		)			->	Mapping[str, Mapping[int, str]]:

       '''simple docstring'''




       if self.task == "multiple-choice":
           snake_case					:   str         =					{0: "batch", 1: "choice", 2: "sequence"}
       else:
           snake_case					:   Tuple         =					{0: "batch", 1: "sequence"}
       return OrderedDict(
           [
               ("input_ids", dynamic_axis),
               ("attention_mask", dynamic_axis),
           ]		)





