

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	(   SCREAMING_SNAKE_CASE     ,     SCREAMING_SNAKE_CASE     ,     unittest.TestCase				):
  _a		     =    AutoencoderKL
  _a		     =    """sample"""
  _a		     =    1e-2




  @property
  def     A__	(							self   )    ->					Tuple:
        '''simple docstring'''






        _lowercase      			=4
        _lowercase      			=3
        _lowercase      			=(32, 32)

        _lowercase      			=floats_tensor((batch_size, num_channels) + sizes   ).to(lowerCAmelCase   )

        return {"sample": image}




  @property
  def     A__	(							self   )    ->					Tuple:
        '''simple docstring'''






        return (3, 32, 32)




  @property
  def     A__	(							self   )    ->					Optional[Any]:
        '''simple docstring'''






        return (3, 32, 32)




  def     A__	(							self   )    ->					str:
        '''simple docstring'''






        _lowercase      			={
            'block_out_channels': [32, 64],
            'in_channels': 3,
            'out_channels': 3,
            'down_block_types': ['DownEncoderBlock2D', 'DownEncoderBlock2D'],
            'up_block_types': ['UpDecoderBlock2D', 'UpDecoderBlock2D'],
            'latent_channels': 4,
        }
        _lowercase      			=self.dummy_input
        return init_dict, inputs_dict




  def     A__	(							self   )    ->					Dict:
        '''simple docstring'''






        pass




  def     A__	(							self   )    ->					int:
        '''simple docstring'''






        pass




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






        _lowercase			,			_lowercase      			=self.prepare_init_args_and_inputs_for_common()
        _lowercase      			=self.model_class(**lowerCAmelCase   )
        model.to(lowerCAmelCase   )

        assert not model.is_gradient_checkpointing and model.training

        _lowercase      			=model(**lowerCAmelCase   ).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()

        _lowercase      			=torch.randn_like(lowerCAmelCase   )
        _lowercase      			=(out - labels).mean()
        loss.backward()

        # re-instantiate the model now enabling gradient checkpointing
        _lowercase      			=self.model_class(**lowerCAmelCase   )
        # clone model
        model_a.load_state_dict(model.state_dict()   )
        model_a.to(lowerCAmelCase   )
        model_a.enable_gradient_checkpointing()

        assert model_a.is_gradient_checkpointing and model_a.training

        _lowercase      			=model_a(**lowerCAmelCase   ).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()
        _lowercase      			=(out_a - labels).mean()
        loss_a.backward()

        # compare the output and parameters gradients
        self.assertTrue((loss - loss_a).abs() < 1e-5   )
        _lowercase      			=dict(model.named_parameters()   )
        _lowercase      			=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:
        '''simple docstring'''






        _lowercase			,			_lowercase      			=AutoencoderKL.from_pretrained('fusing/autoencoder-kl-dummy'				,  output_loading_info=lowerCAmelCase   )
        self.assertIsNotNone(lowerCAmelCase   )
        self.assertEqual(len(loading_info['missing_keys']   )				,  0   )

        model.to(lowerCAmelCase   )
        _lowercase      			=model(**self.dummy_input   )

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




  def     A__	(							self   )    ->					Any:
        '''simple docstring'''






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

        if torch_device == "mps":
              _lowercase      			=torch.manual_seed(0   )
        else:
              _lowercase      			=torch.Generator(device=lowerCAmelCase   ).manual_seed(0   )

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

        _lowercase      			=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":
              _lowercase      			=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":
              _lowercase      			=torch.tensor(
                  [-0.1352, 0.0878, 0.0419, -0.0818, -0.1069, 0.0688, -0.1458, -0.4446, -0.0026]   )
        else:
              _lowercase      			=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(lowerCAmelCase				,  lowerCAmelCase				,  rtol=1e-2   )   )





@slow
class 					__lowerCAmelCase	(   unittest.TestCase				):




  def     A__	(							self				,  lowerCAmelCase				,  lowerCAmelCase   )    ->					Optional[Any]:
        '''simple docstring'''






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




  def     A__	(							self   )    ->					List[str]:
        '''simple docstring'''






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




  def     A__	(							self				,  lowerCAmelCase=0				,  lowerCAmelCase=(4, 3, 512, 512)				,  lowerCAmelCase=False   )    ->					int:
        '''simple docstring'''






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




  def     A__	(							self				,  lowerCAmelCase="CompVis/stable-diffusion-v1-4"				,  lowerCAmelCase=False   )    ->					Any:
        '''simple docstring'''






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

        _lowercase      			=AutoencoderKL.from_pretrained(
            lowerCAmelCase				,  subfolder='vae'				,  torch_dtype=lowerCAmelCase				,  revision=lowerCAmelCase				,  )
        model.to(lowerCAmelCase   ).eval()

        return model




  def     A__	(							self				,  lowerCAmelCase=0   )    ->					List[str]:
        '''simple docstring'''






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




  @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     A__	(							self				,  lowerCAmelCase				,  lowerCAmelCase				,  lowerCAmelCase   )    ->					Dict:
        '''simple docstring'''






        _lowercase      			=self.get_sd_vae_model()
        _lowercase      			=self.get_sd_image(lowerCAmelCase   )
        _lowercase      			=self.get_generator(lowerCAmelCase   )

        with torch.no_grad():
              _lowercase      			=model(lowerCAmelCase				,  generator=lowerCAmelCase				,  sample_posterior=lowerCAmelCase   ).sample

        assert sample.shape == image.shape

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

        assert torch_all_close(lowerCAmelCase				,  lowerCAmelCase				,  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     A__	(							self				,  lowerCAmelCase				,  lowerCAmelCase   )    ->					Optional[int]:
        '''simple docstring'''






        _lowercase      			=self.get_sd_vae_model(fpaa=lowerCAmelCase   )
        _lowercase      			=self.get_sd_image(lowerCAmelCase				,  fpaa=lowerCAmelCase   )
        _lowercase      			=self.get_generator(lowerCAmelCase   )

        with torch.no_grad():
              _lowercase      			=model(lowerCAmelCase				,  generator=lowerCAmelCase				,  sample_posterior=lowerCAmelCase   ).sample

        assert sample.shape == image.shape

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

        assert torch_all_close(lowerCAmelCase				,  lowerCAmelCase				,  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     A__	(							self				,  lowerCAmelCase				,  lowerCAmelCase				,  lowerCAmelCase   )    ->					Union[str, Any]:
        '''simple docstring'''






        _lowercase      			=self.get_sd_vae_model()
        _lowercase      			=self.get_sd_image(lowerCAmelCase   )

        with torch.no_grad():
              _lowercase      			=model(lowerCAmelCase   ).sample

        assert sample.shape == image.shape

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

        assert torch_all_close(lowerCAmelCase				,  lowerCAmelCase				,  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     A__	(							self				,  lowerCAmelCase				,  lowerCAmelCase   )    ->					List[str]:
        '''simple docstring'''






        _lowercase      			=self.get_sd_vae_model()
        _lowercase      			=self.get_sd_image(lowerCAmelCase				,  shape=(3, 4, 64, 64)   )

        with torch.no_grad():
              _lowercase      			=model.decode(lowerCAmelCase   ).sample

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

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

        assert torch_all_close(lowerCAmelCase				,  lowerCAmelCase				,  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     A__	(							self				,  lowerCAmelCase				,  lowerCAmelCase   )    ->					str:
        '''simple docstring'''






        _lowercase      			=self.get_sd_vae_model(fpaa=lowerCAmelCase   )
        _lowercase      			=self.get_sd_image(lowerCAmelCase				,  shape=(3, 4, 64, 64)				,  fpaa=lowerCAmelCase   )

        with torch.no_grad():
              _lowercase      			=model.decode(lowerCAmelCase   ).sample

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

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

        assert torch_all_close(lowerCAmelCase				,  lowerCAmelCase				,  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				,  lowerCAmelCase   )    ->					Any:
        '''simple docstring'''






        _lowercase      			=self.get_sd_vae_model(fpaa=lowerCAmelCase   )
        _lowercase      			=self.get_sd_image(lowerCAmelCase				,  shape=(3, 4, 64, 64)				,  fpaa=lowerCAmelCase   )

        with torch.no_grad():
              _lowercase      			=model.decode(lowerCAmelCase   ).sample

        model.enable_xformers_memory_efficient_attention()
        with torch.no_grad():
              _lowercase      			=model.decode(lowerCAmelCase   ).sample

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

        assert torch_all_close(lowerCAmelCase				,  lowerCAmelCase				,  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				,  lowerCAmelCase   )    ->					int:
        '''simple docstring'''






        _lowercase      			=self.get_sd_vae_model()
        _lowercase      			=self.get_sd_image(lowerCAmelCase				,  shape=(3, 4, 64, 64)   )

        with torch.no_grad():
              _lowercase      			=model.decode(lowerCAmelCase   ).sample

        model.enable_xformers_memory_efficient_attention()
        with torch.no_grad():
              _lowercase      			=model.decode(lowerCAmelCase   ).sample

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

        assert torch_all_close(lowerCAmelCase				,  lowerCAmelCase				,  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     A__	(							self				,  lowerCAmelCase				,  lowerCAmelCase   )    ->					List[str]:
        '''simple docstring'''






        _lowercase      			=self.get_sd_vae_model()
        _lowercase      			=self.get_sd_image(lowerCAmelCase   )
        _lowercase      			=self.get_generator(lowerCAmelCase   )

        with torch.no_grad():
              _lowercase      			=model.encode(lowerCAmelCase   ).latent_dist
              _lowercase      			=dist.sample(generator=lowerCAmelCase   )

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

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

        _lowercase      			=3e-3 if torch_device != 'mps' else 1e-2
        assert torch_all_close(lowerCAmelCase				,  lowerCAmelCase				,  atol=lowerCAmelCase   )





from collections import OrderedDict
from typing import Mapping

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


lowercase_   							=  logging.get_logger(__name__)

lowercase_   							=  {
    'distilbert-base-uncased': 'https://huggingface.co/distilbert-base-uncased/resolve/main/config.json',
    'distilbert-base-uncased-distilled-squad': (
        'https://huggingface.co/distilbert-base-uncased-distilled-squad/resolve/main/config.json'
    ),
    'distilbert-base-cased': 'https://huggingface.co/distilbert-base-cased/resolve/main/config.json',
    'distilbert-base-cased-distilled-squad': (
        'https://huggingface.co/distilbert-base-cased-distilled-squad/resolve/main/config.json'
    ),
    'distilbert-base-german-cased': 'https://huggingface.co/distilbert-base-german-cased/resolve/main/config.json',
    'distilbert-base-multilingual-cased': (
        'https://huggingface.co/distilbert-base-multilingual-cased/resolve/main/config.json'
    ),
    'distilbert-base-uncased-finetuned-sst-2-english': (
        'https://huggingface.co/distilbert-base-uncased-finetuned-sst-2-english/resolve/main/config.json'
    ),
}





class 					__lowerCAmelCase	(   SCREAMING_SNAKE_CASE				):
  _a		     =    """distilbert"""
  _a		     =    {
      """hidden_size""": """dim""",
      """num_attention_heads""": """n_heads""",
      """num_hidden_layers""": """n_layers""",
  }




  def __init__(							self				,  lowerCAmelCase=30_522				,  lowerCAmelCase=512				,  lowerCAmelCase=False				,  lowerCAmelCase=6				,  lowerCAmelCase=12				,  lowerCAmelCase=768				,  lowerCAmelCase=4 * 768				,  lowerCAmelCase=0.1				,  lowerCAmelCase=0.1				,  lowerCAmelCase="gelu"				,  lowerCAmelCase=0.02				,  lowerCAmelCase=0.1				,  lowerCAmelCase=0.2				,  lowerCAmelCase=0				,  **lowerCAmelCase				,  )    ->					Dict:
        '''simple docstring'''






        _lowercase      			=vocab_size
        _lowercase      			=max_position_embeddings
        _lowercase      			=sinusoidal_pos_embds
        _lowercase      			=n_layers
        _lowercase      			=n_heads
        _lowercase      			=dim
        _lowercase      			=hidden_dim
        _lowercase      			=dropout
        _lowercase      			=attention_dropout
        _lowercase      			=activation
        _lowercase      			=initializer_range
        _lowercase      			=qa_dropout
        _lowercase      			=seq_classif_dropout
        super().__init__(**lowerCAmelCase				,  pad_token_id=lowerCAmelCase   )





class 					__lowerCAmelCase	(   SCREAMING_SNAKE_CASE				):




  @property
  def     A__	(							self   )    ->					Mapping[str, Mapping[int, str]]:
        '''simple docstring'''






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


