"""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 							a					(		lowerCamelCase__						,				lowerCamelCase__						,				unittest.TestCase ):
    _snake_case  :	Optional[int]  				=				AutoencoderKL
    _snake_case  :	List[str]  				=				'sample'
    _snake_case  :	Union[str, Any]  				=				1e-2


    @property
    def   lowerCAmelCase_	(       self						:	Optional[Any]       ):
      _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]       ):
      return (3, 32, 32)


    @property
    def   lowerCAmelCase_	(       self						:	List[Any]       ):
      return (3, 32, 32)


    def   lowerCAmelCase_	(       self						:	str       ):
      _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						:	str       ):
      pass


    def   lowerCAmelCase_	(       self						:	Optional[int]       ):
      pass


    @unittest.skipIf(torch_device == """mps""" ,					"""Gradient checkpointing skipped on MPS"""       )
    def   lowerCAmelCase_	(       self						:	List[Any]       ):
      # enable deterministic behavior for gradient checkpointing
      _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						:	Union[str, Any]       ):
      _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						:	Tuple       ):
      _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.0_0_7_8e-0_1,
                -3.8_3_2_3e-0_4,
                -1.2_6_8_1e-0_1,
                -1.1_4_6_2e-0_1,
                2.0_0_9_5e-0_1,
                1.0_8_9_3e-0_1,
                -8.8_2_4_7e-0_2,
                -3.0_3_6_1e-0_1,
                -9.8_6_4_4e-0_3,
            ]       )
      elif torch_device == "cpu":
        _UpperCAmelCase    			=   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    			=   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 							a					(		unittest.TestCase ):


    def   lowerCAmelCase_	(       self						:	Dict ,					__lowerCAmelCase						:	List[Any] ,					__lowerCAmelCase						:	str       ):
      return f'''gaussian_noise_s={seed}_shape={"_".join([str(__snake_case       ) for s in shape]       )}.npy'''


    def   lowerCAmelCase_	(       self						:	List[str]       ):
      # clean up the VRAM after each test
      super().tearDown()
      gc.collect()
      torch.cuda.empty_cache()


    def   lowerCAmelCase_	(       self						:	Union[str, Any] ,					__lowerCAmelCase						:	Tuple=0 ,					__lowerCAmelCase						:	int=(4, 3, 512, 512) ,					__lowerCAmelCase						:	Any=False       ):
      _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						:	str ,					__lowerCAmelCase						:	List[str]="CompVis/stable-diffusion-v1-4" ,					__lowerCAmelCase						:	int=False       ):
      _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						:	Dict ,					__lowerCAmelCase						:	List[str]=0       ):
      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   lowerCAmelCase_	(       self						:	Tuple ,					__lowerCAmelCase						:	Tuple ,					__lowerCAmelCase						:	Tuple ,					__lowerCAmelCase						:	str       ):
      _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_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   lowerCAmelCase_	(       self						:	Any ,					__lowerCAmelCase						:	Any ,					__lowerCAmelCase						:	Any       ):
      _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_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   lowerCAmelCase_	(       self						:	Optional[int] ,					__lowerCAmelCase						:	Dict ,					__lowerCAmelCase						:	Any ,					__lowerCAmelCase						:	Any       ):
      _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_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   lowerCAmelCase_	(       self						:	List[Any] ,					__lowerCAmelCase						:	Tuple ,					__lowerCAmelCase						:	Optional[int]       ):
      _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, 512, 512]

      _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_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   lowerCAmelCase_	(       self						:	List[Any] ,					__lowerCAmelCase						:	List[str] ,					__lowerCAmelCase						:	List[str]       ):
      _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, 512, 512]

      _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						:	Optional[Any] ,					__lowerCAmelCase						:	Optional[Any]       ):
      _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, 512, 512]

      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						:	Union[str, Any] ,					__lowerCAmelCase						:	str       ):
      _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, 512, 512]

      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   lowerCAmelCase_	(       self						:	Union[str, Any] ,					__lowerCAmelCase						:	str ,					__lowerCAmelCase						:	Union[str, Any]       ):
      _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       )





'''simple docstring'''






from ...configuration_utils import PretrainedConfig
from ...utils import logging


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

lowerCAmelCase:   int					=		{'ctrl': 'https://huggingface.co/ctrl/resolve/main/config.json'}

class 				a__(   lowerCamelCase__      ):
    lowercase__					=       """ctrl"""
    lowercase__					=       ["""past_key_values"""]
    lowercase__					=       {
        """max_position_embeddings""": """n_positions""",
        """hidden_size""": """n_embd""",
        """num_attention_heads""": """n_head""",
        """num_hidden_layers""": """n_layer""",
    }







    def __init__( self					:    Optional[int]		,     __snake_case					:    Union[str, Any]=24_65_34		,     __snake_case					:    Dict=2_56		,     __snake_case					:    Optional[int]=12_80		,     __snake_case					:    Optional[int]=81_92		,     __snake_case					:    Union[str, Any]=48		,     __snake_case					:    str=16		,     __snake_case					:    Any=0.1		,     __snake_case					:    List[Any]=0.1		,     __snake_case					:    str=1e-6		,     __snake_case					:    List[str]=0.02		,     __snake_case					:    int=True		,     **__snake_case					:    Any		,     ):
      a		:   int	  =	vocab_size
      a		:   Union[str, Any]	  =	n_positions
      a		:   Optional[int]	  =	n_embd
      a		:   Dict	  =	n_layer
      a		:   Union[str, Any]	  =	n_head
      a		:   Tuple	  =	dff
      a		:   Union[str, Any]	  =	resid_pdrop
      a		:   Tuple	  =	embd_pdrop
      a		:   int	  =	layer_norm_epsilon
      a		:   str	  =	initializer_range

      a		:   Any	  =	use_cache

      super().__init__(**__snake_case      )