code: import unittest
  
  from transformers import load_tool
  
  from .test_tools_common import ToolTesterMixin
  
  
  UpperCAmelCase					=				'''
  Hugging Face was founded in 2016 by French entrepreneurs Clément Delangue, Julien Chaumond, and Thomas Wolf originally as a company that developed a chatbot app targeted at teenagers.[2] After open-sourcing the model behind the chatbot, the company pivoted to focus on being a platform for machine learning.
  
  In March 2021, Hugging Face raised $40 million in a Series B funding round.[3]
  
  On April 28, 2021, the company launched the BigScience Research Workshop in collaboration with several other research groups to release an open large language model.[4] In 2022, the workshop concluded with the announcement of BLOOM, a multilingual large language model with 176 billion parameters.[5]
  '''
  
  
  
  
  class    __lowerCAmelCase  (       unittest.TestCase,	a_						):
  
  
  
   '''simple docstring'''
  
   def 					__snake_case					(			self       :		int  ) ->							Optional[Any]:
          _UpperCamelCase     :       int  						=  load_tool('summarization'  )
          self.tool.setup()
          _UpperCamelCase     :       Optional[Any]  						=  load_tool('summarization'       ,			remote=lowerCamelCase  )
  
   def 					__snake_case					(			self       :		str  ) ->							int:
          _UpperCamelCase     :       Union[str, Any]  						=  self.tool(lowerCamelCase  )
          self.assertEqual(
              lowerCamelCase       ,			'Hugging Face was founded in 2016 by French entrepreneurs Clément Delangue, Julien Chaumond, and Thomas Wolf. In March 2021, Hugging Face raised $40 million in a Series B funding round. On April 28, 2021, the company launched the BigScience Research Workshop in collaboration with several other research groups to release an open large language model. In 2022, the workshop concluded with the announcement of BLOOM.'       ,			)
  
   def 					__snake_case					(			self       :		List[Any]  ) ->							Dict:
          _UpperCamelCase     :       Optional[int]  						=  self.remote_tool(lowerCamelCase  )
          self.assertEqual(
              lowerCamelCase       ,			'Hugging Face was founded in 2016 by French entrepreneurs Clément Delangue, Julien Chaumond, and Thomas Wolf. In March 2021, Hugging Face raised $40 million in a Series B funding round. On April 28, 2021, the company launched the BigScience Research Workshop in collaboration with several other research groups to release an open large language model. In 2022, the workshop concluded with the announcement of BLOOM.'       ,			)
  
   def 					__snake_case					(			self       :		Tuple  ) ->							List[str]:
          _UpperCamelCase     :       Union[str, Any]  						=  self.tool(text=lowerCamelCase  )
          self.assertEqual(
              lowerCamelCase       ,			'Hugging Face was founded in 2016 by French entrepreneurs Clément Delangue, Julien Chaumond, and Thomas Wolf. In March 2021, Hugging Face raised $40 million in a Series B funding round. On April 28, 2021, the company launched the BigScience Research Workshop in collaboration with several other research groups to release an open large language model. In 2022, the workshop concluded with the announcement of BLOOM.'       ,			)
  
   def 					__snake_case					(			self       :		Optional[int]  ) ->							Optional[int]:
          _UpperCamelCase     :       Optional[Any]  						=  self.remote_tool(text=lowerCamelCase  )
          self.assertEqual(
              lowerCamelCase       ,			'Hugging Face was founded in 2016 by French entrepreneurs Clément Delangue, Julien Chaumond, and Thomas Wolf. In March 2021, Hugging Face raised $40 million in a Series B funding round. On April 28, 2021, the company launched the BigScience Research Workshop in collaboration with several other research groups to release an open large language model. In 2022, the workshop concluded with the announcement of BLOOM.'       ,			)
  
  
  
  
style_context: 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    __lowerCAmelCase  (       unittest.TestCase						):
  
  
  
   '''simple docstring'''
   _lowerCamelCase						:	str				    = 'hf-internal-testing/tiny-stable-diffusion-pipe'
   _lowerCamelCase						:	int				    = 1
   _lowerCamelCase						:	Any				    = 77
   _lowerCamelCase						:	List[Any]				    = 32
   _lowerCamelCase						:	List[str]				    = 4
   _lowerCamelCase						:	Dict				    = 64
   _lowerCamelCase						:	List[str]				    = torch.manual_seed(0						)
  
   def 					__snake_case					(			self       :		Any       ,			lowerCamelCase       :		Union[str, Any]=0.9_9_9_9  ) ->							Dict:
          _UpperCamelCase     :       int  						=  UNetaDConditionModel.from_pretrained(self.model_id       ,			subfolder='unet'  )
          _UpperCamelCase     :       Any  						=  unet.to(lowerCamelCase  )
          _UpperCamelCase     :       Union[str, Any]  						=  EMAModel(unet.parameters()       ,			decay=lowerCamelCase       ,			model_cls=lowerCamelCase       ,			model_config=unet.config  )
          return unet, ema_unet
  
   def 					__snake_case					(			self       :		Tuple  ) ->							Union[str, Any]:
          _UpperCamelCase     :       Tuple  						=  torch.randn(
              self.batch_size       ,			self.num_in_channels       ,			self.latent_height       ,			self.latent_width       ,			generator=self.generator  ).to(lowerCamelCase  )
          _UpperCamelCase     :       Union[str, Any]  						=  torch.randint(0       ,			1_0_0_0       ,			size=(self.batch_size,)       ,			generator=self.generator  ).to(lowerCamelCase  )
          _UpperCamelCase     :       int  						=  torch.randn(
              self.batch_size       ,			self.prompt_length       ,			self.text_encoder_hidden_dim       ,			generator=self.generator  ).to(lowerCamelCase  )
          return noisy_latents, timesteps, encoder_hidden_states
  
   def 					__snake_case					(			self       :		str       ,			lowerCamelCase       :		List[Any]  ) ->							List[Any]:
          _UpperCamelCase     :       int  						=  {}
          for k, param in unet.state_dict().items():
                 _UpperCamelCase     :       Optional[Any]  						=  torch.randn_like(lowerCamelCase  ) + (param * torch.randn_like(lowerCamelCase  ))
                 updated_state_dict.update({k: updated_param}  )
          unet.load_state_dict(lowerCamelCase  )
          return unet
  
   def 					__snake_case					(			self       :		List[Any]  ) ->							Tuple:
          _UpperCamelCase						,      _UpperCamelCase     :       Union[str, Any]  						=  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 					__snake_case					(			self       :		int  ) ->							Any:
          _UpperCamelCase						,      _UpperCamelCase     :       Any  						=  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()  )
          _UpperCamelCase     :       List[Any]  						=  list(unet.parameters()  )
          for s_param, param in zip(ema_unet.shadow_params       ,			lowerCamelCase  ):
                 assert torch.allclose(lowerCamelCase       ,			lowerCamelCase  )
  
          # 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       ,			lowerCamelCase  ):
                 assert torch.allclose(lowerCamelCase       ,			lowerCamelCase  )
  
   def 					__snake_case					(			self       :		Dict  ) ->							Dict:
          _UpperCamelCase						,      _UpperCamelCase     :       Dict  						=  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.
          _UpperCamelCase     :       str  						=  self.simulate_backprop(lowerCamelCase  )
  
          # 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.
          _UpperCamelCase     :       Optional[Any]  						=  list(unet_pseudo_updated_step_one.parameters()  )
          for s_param, param in zip(ema_unet.shadow_params       ,			lowerCamelCase  ):
                 assert ~torch.allclose(lowerCamelCase       ,			lowerCamelCase  )
  
          # 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       ,			lowerCamelCase  ):
                 assert ~torch.allclose(lowerCamelCase       ,			lowerCamelCase  )
  
   def 					__snake_case					(			self       :		Union[str, Any]  ) ->							Tuple:
          # If we call EMA step after a backpropagation consecutively for two times,
          # the shadow params from those two steps should be different.
          _UpperCamelCase						,      _UpperCamelCase     :       Dict  						=  self.get_models()
  
          # First backprop + EMA
          _UpperCamelCase     :       Optional[Any]  						=  self.simulate_backprop(lowerCamelCase  )
          ema_unet.step(unet_step_one.parameters()  )
          _UpperCamelCase     :       Optional[Any]  						=  ema_unet.shadow_params
  
          # Second backprop + EMA
          _UpperCamelCase     :       Optional[int]  						=  self.simulate_backprop(lowerCamelCase  )
          ema_unet.step(unet_step_two.parameters()  )
          _UpperCamelCase     :       List[str]  						=  ema_unet.shadow_params
  
          for step_one, step_two in zip(lowerCamelCase       ,			lowerCamelCase  ):
                 assert ~torch.allclose(lowerCamelCase       ,			lowerCamelCase  )
  
   def 					__snake_case					(			self       :		str  ) ->							int:
          # If there's no decay even if there are backprops, EMA steps
          # won't take any effect i.e., the shadow params would remain the
          # same.
          _UpperCamelCase						,      _UpperCamelCase     :       List[str]  						=  self.get_models(decay=0.0  )
          _UpperCamelCase     :       Optional[Any]  						=  self.simulate_backprop(lowerCamelCase  )
          ema_unet.step(unet_step_one.parameters()  )
          _UpperCamelCase     :       Dict  						=  ema_unet.shadow_params
  
          _UpperCamelCase     :       List[str]  						=  self.simulate_backprop(lowerCamelCase  )
          ema_unet.step(unet_step_two.parameters()  )
          _UpperCamelCase     :       Union[str, Any]  						=  ema_unet.shadow_params
  
          for step_one, step_two in zip(lowerCamelCase       ,			lowerCamelCase  ):
                 assert torch.allclose(lowerCamelCase       ,			lowerCamelCase  )
  
   @skip_mps
   def 					__snake_case					(			self       :		Dict  ) ->							str:
          _UpperCamelCase						,      _UpperCamelCase     :       Optional[Any]  						=  self.get_models()
          _UpperCamelCase						,      _UpperCamelCase						,      _UpperCamelCase     :       Any  						=  self.get_dummy_inputs()
  
          with tempfile.TemporaryDirectory() as tmpdir:
                 ema_unet.save_pretrained(lowerCamelCase  )
                 _UpperCamelCase     :       List[str]  						=  UNetaDConditionModel.from_pretrained(lowerCamelCase       ,			model_cls=lowerCamelCase  )
                 _UpperCamelCase     :       Dict  						=  loaded_unet.to(unet.device  )
  
          # Since no EMA step has been performed the outputs should match.
          _UpperCamelCase     :       Optional[Any]  						=  unet(lowerCamelCase       ,			lowerCamelCase       ,			lowerCamelCase  ).sample
          _UpperCamelCase     :       List[str]  						=  loaded_unet(lowerCamelCase       ,			lowerCamelCase       ,			lowerCamelCase  ).sample
  
          assert torch.allclose(lowerCamelCase       ,			lowerCamelCase       ,			atol=1e-4  )
  
  
  
  