code: 
  
  
  
  
  
  
  """simple docstring"""
  import tempfile
  import unittest
  
  import torch
  
  from diffusers import UNetaDConditionModel
  from diffusers.training_utils import EMAModel
  from diffusers.utils.testing_utils import enable_full_determinism, skip_mps, torch_device
  
  
  enable_full_determinism()
  
  
  
  class 					UpperCamelCase__   (							unittest.TestCase):
  
  
  
  
  
  
  
      """simple docstring"""
      __UpperCAmelCase											=   """hf-internal-testing/tiny-stable-diffusion-pipe"""
      __UpperCAmelCase											=   1
      __UpperCAmelCase											=   77
      __UpperCAmelCase											=   32
      __UpperCAmelCase											=   4
      __UpperCAmelCase											=   __UpperCAmelCase											=   64
      __UpperCAmelCase											=   torch.manual_seed(0)
  
  
  
  
  
  
  
      def 							a__ (		self   :  str							,						UpperCamelCase_   :  Optional[int]=0.9_999   ):
  
  
  
  
  
             '''simple docstring'''
  
             __magic_name__										=						UNetaDConditionModel.from_pretrained(self.model_id							,						subfolder='unet'   )
             __magic_name__										=						unet.to(UpperCamelCase_   )
             __magic_name__										=						EMAModel(unet.parameters()							,						decay=UpperCamelCase_							,						model_cls=UpperCamelCase_							,						model_config=unet.config   )
             return unet, ema_unet
  
  
  
  
  
  
  
      def 							a__ (		self   :  Optional[int]   ):
  
  
  
  
  
             '''simple docstring'''
  
             __magic_name__										=						torch.randn(
                 self.batch_size							,						self.num_in_channels							,						self.latent_height							,						self.latent_width							,						generator=self.generator   ).to(UpperCamelCase_   )
             __magic_name__										=						torch.randint(0							,						1_0_0_0							,						size=(self.batch_size,)							,						generator=self.generator   ).to(UpperCamelCase_   )
             __magic_name__										=						torch.randn(
                 self.batch_size							,						self.prompt_length							,						self.text_encoder_hidden_dim							,						generator=self.generator   ).to(UpperCamelCase_   )
             return noisy_latents, timesteps, encoder_hidden_states
  
  
  
  
  
  
  
      def 							a__ (		self   :  str							,						UpperCamelCase_   :  Any   ):
  
  
  
  
  
             '''simple docstring'''
  
             __magic_name__										=						{}
             for k, param in unet.state_dict().items():
                    __magic_name__										=						torch.randn_like(UpperCamelCase_   ) + (param * torch.randn_like(UpperCamelCase_   ))
                    updated_state_dict.update({k: updated_param}   )
             unet.load_state_dict(UpperCamelCase_   )
             return unet
  
  
  
  
  
  
  
      def 							a__ (		self   :  List[Any]   ):
  
  
  
  
  
             '''simple docstring'''
  
             __magic_name__							,     __magic_name__										=						self.get_models()
             # Take the first (hypothetical) EMA step.
             ema_unet.step(unet.parameters()   )
             assert ema_unet.optimization_step == 1
  
             # Take two more.
             for _ in range(2   ):
                    ema_unet.step(unet.parameters()   )
             assert ema_unet.optimization_step == 3
  
  
  
  
  
  
  
      def 							a__ (		self   :  Union[str, Any]   ):
  
  
  
  
  
             '''simple docstring'''
  
             __magic_name__							,     __magic_name__										=						self.get_models()
             # Since the `unet` is not being updated (i.e., backprop'd)
             # there won't be any difference between the `params` of `unet`
             # and `ema_unet` even if we call `ema_unet.step(unet.parameters())`.
             ema_unet.step(unet.parameters()   )
             __magic_name__										=						list(unet.parameters()   )
             for s_param, param in zip(ema_unet.shadow_params							,						UpperCamelCase_   ):
                    assert torch.allclose(UpperCamelCase_							,						UpperCamelCase_   )
  
             # The above holds true even if we call `ema.step()` multiple times since
             # `unet` params are still not being updated.
             for _ in range(4   ):
                    ema_unet.step(unet.parameters()   )
             for s_param, param in zip(ema_unet.shadow_params							,						UpperCamelCase_   ):
                    assert torch.allclose(UpperCamelCase_							,						UpperCamelCase_   )
  
  
  
  
  
  
  
      def 							a__ (		self   :  Dict   ):
  
  
  
  
  
             '''simple docstring'''
  
             __magic_name__							,     __magic_name__										=						self.get_models()
             # Here we simulate the parameter updates for `unet`. Since there might
             # be some parameters which are initialized to zero we take extra care to
             # initialize their values to something non-zero before the multiplication.
             __magic_name__										=						self.simulate_backprop(UpperCamelCase_   )
  
             # Take the EMA step.
             ema_unet.step(unet_pseudo_updated_step_one.parameters()   )
  
             # Now the EMA'd parameters won't be equal to the original model parameters.
             __magic_name__										=						list(unet_pseudo_updated_step_one.parameters()   )
             for s_param, param in zip(ema_unet.shadow_params							,						UpperCamelCase_   ):
                    assert ~torch.allclose(UpperCamelCase_							,						UpperCamelCase_   )
  
             # Ensure this is the case when we take multiple EMA steps.
             for _ in range(4   ):
                    ema_unet.step(unet.parameters()   )
             for s_param, param in zip(ema_unet.shadow_params							,						UpperCamelCase_   ):
                    assert ~torch.allclose(UpperCamelCase_							,						UpperCamelCase_   )
  
  
  
  
  
  
  
      def 							a__ (		self   :  Union[str, Any]   ):
  
  
  
  
  
             '''simple docstring'''
  
             __magic_name__							,     __magic_name__										=						self.get_models()
  
             # First backprop + EMA
             __magic_name__										=						self.simulate_backprop(UpperCamelCase_   )
             ema_unet.step(unet_step_one.parameters()   )
             __magic_name__										=						ema_unet.shadow_params
  
             # Second backprop + EMA
             __magic_name__										=						self.simulate_backprop(UpperCamelCase_   )
             ema_unet.step(unet_step_two.parameters()   )
             __magic_name__										=						ema_unet.shadow_params
  
             for step_one, step_two in zip(UpperCamelCase_							,						UpperCamelCase_   ):
                    assert ~torch.allclose(UpperCamelCase_							,						UpperCamelCase_   )
  
  
  
  
  
  
  
      def 							a__ (		self   :  List[Any]   ):
  
  
  
  
  
             '''simple docstring'''
  
             __magic_name__							,     __magic_name__										=						self.get_models(decay=0.0   )
             __magic_name__										=						self.simulate_backprop(UpperCamelCase_   )
             ema_unet.step(unet_step_one.parameters()   )
             __magic_name__										=						ema_unet.shadow_params
  
             __magic_name__										=						self.simulate_backprop(UpperCamelCase_   )
             ema_unet.step(unet_step_two.parameters()   )
             __magic_name__										=						ema_unet.shadow_params
  
             for step_one, step_two in zip(UpperCamelCase_							,						UpperCamelCase_   ):
                    assert torch.allclose(UpperCamelCase_							,						UpperCamelCase_   )
  
  
  
  
  
  
  
      @skip_mps
      def 							a__ (		self   :  Tuple   ):
  
  
  
  
  
             '''simple docstring'''
  
             __magic_name__							,     __magic_name__										=						self.get_models()
             __magic_name__							,     __magic_name__							,     __magic_name__										=						self.get_dummy_inputs()
  
             with tempfile.TemporaryDirectory() as tmpdir:
                    ema_unet.save_pretrained(UpperCamelCase_   )
                    __magic_name__										=						UNetaDConditionModel.from_pretrained(UpperCamelCase_							,						model_cls=UpperCamelCase_   )
                    __magic_name__										=						loaded_unet.to(unet.device   )
  
             # Since no EMA step has been performed the outputs should match.
             __magic_name__										=						unet(UpperCamelCase_							,						UpperCamelCase_							,						UpperCamelCase_   ).sample
             __magic_name__										=						loaded_unet(UpperCamelCase_							,						UpperCamelCase_							,						UpperCamelCase_   ).sample
  
             assert torch.allclose(UpperCamelCase_							,						UpperCamelCase_							,						atol=1e-4   )
style_context: 
  
  
  
  
  
  
  """simple docstring"""
  from ...configuration_utils import PretrainedConfig
  from ...utils import logging
  
  
  snake_case   :   int    		=		logging.get_logger(__name__)
  
  snake_case   :   List[str]    		=		{
      """uw-madison/nystromformer-512""": """https://huggingface.co/uw-madison/nystromformer-512/resolve/main/config.json""",
      # See all Nystromformer models at https://huggingface.co/models?filter=nystromformer
  }
  
  
  
  class 					UpperCamelCase__   (							a_):
  
  
  
  
  
  
  
      """simple docstring"""
      __UpperCAmelCase											=   """nystromformer"""
  
  
  
  
  
  
  
      def __init__(		self   :  Dict							,						UpperCamelCase_   :  Optional[Any]=3_0_0_0_0							,						UpperCamelCase_   :  Dict=7_6_8							,						UpperCamelCase_   :  Tuple=1_2							,						UpperCamelCase_   :  Any=1_2							,						UpperCamelCase_   :  List[str]=3_0_7_2							,						UpperCamelCase_   :  Tuple="gelu_new"							,						UpperCamelCase_   :  Optional[Any]=0.1							,						UpperCamelCase_   :  str=0.1							,						UpperCamelCase_   :  Tuple=5_1_0							,						UpperCamelCase_   :  Optional[int]=2							,						UpperCamelCase_   :  Optional[int]=6_4							,						UpperCamelCase_   :  Tuple=6_4							,						UpperCamelCase_   :  Optional[int]=6_5							,						UpperCamelCase_   :  Optional[int]=False							,						UpperCamelCase_   :  List[str]=0.02							,						UpperCamelCase_   :  List[Any]=1e-5							,						UpperCamelCase_   :  Union[str, Any]=1							,						UpperCamelCase_   :  Tuple=0							,						UpperCamelCase_   :  List[Any]=2							,						**UpperCamelCase_   :  str							,						):
  
  
  
  
  
             '''simple docstring'''
  
             __magic_name__										=						vocab_size
             __magic_name__										=						max_position_embeddings
             __magic_name__										=						hidden_size
             __magic_name__										=						num_hidden_layers
             __magic_name__										=						num_attention_heads
             __magic_name__										=						intermediate_size
             __magic_name__										=						hidden_act
             __magic_name__										=						hidden_dropout_prob
             __magic_name__										=						attention_probs_dropout_prob
             __magic_name__										=						initializer_range
             __magic_name__										=						type_vocab_size
             __magic_name__										=						segment_means_seq_len
             __magic_name__										=						num_landmarks
             __magic_name__										=						conv_kernel_size
             __magic_name__										=						inv_coeff_init_option
             __magic_name__										=						layer_norm_eps
             super().__init__(pad_token_id=UpperCamelCase_							,						bos_token_id=UpperCamelCase_							,						eos_token_id=UpperCamelCase_							,						**UpperCamelCase_   )