code: 
  
  
  '''simple docstring'''
  
  import unittest
  
  import torch
  
  from diffusers import UNetaDModel
  from diffusers.utils import floats_tensor, slow, torch_device
  
  from .test_modeling_common import ModelTesterMixin, UNetTesterMixin
  
  
  
  
  
  
  
  class  UpperCAmelCase (       SCREAMING_SNAKE_CASE__		,			SCREAMING_SNAKE_CASE__		,			unittest.TestCase):
   _lowerCamelCase :					str    					=					UNetaDModel
   _lowerCamelCase :					Tuple    					=					'sample'
  
   @property
   def 		lowercase_						( self :	Dict					):
  
  
  
  
  
      """simple docstring"""
  
  
  
      UpperCamelCase__ 						=						4
      UpperCamelCase__ 						=						14
      UpperCamelCase__ 						=						16
  
      UpperCamelCase__ 						=						floats_tensor((batch_size, num_features, seq_len)					).to(a_					)
      UpperCamelCase__ 						=						torch.tensor([10] * batch_size					).to(a_					)
  
      return {"sample": noise, "timestep": time_step}
  
   @property
   def 		lowercase_						( self :	List[Any]					):
  
  
  
  
  
      """simple docstring"""
  
  
  
      return (4, 14, 16)
  
   @property
   def 		lowercase_						( self :	Dict					):
  
  
  
  
  
      """simple docstring"""
  
  
  
      return (4, 14, 16)
  
   def 		lowercase_						( self :	List[Any]					):
  
  
  
  
  
      """simple docstring"""
  
  
  
      pass
  
   def 		lowercase_						( self :	Tuple					):
  
  
  
  
  
      """simple docstring"""
  
  
  
      pass
  
   @unittest.skipIf(torch_device == "mps",					"mish op not supported in MPS"					)
   def 		lowercase_						( self :	Union[str, Any]					):
  
  
  
  
  
      """simple docstring"""
  
  
  
      super().test_determinism()
  
   @unittest.skipIf(torch_device == "mps",					"mish op not supported in MPS"					)
   def 		lowercase_						( self :	List[Any]					):
  
  
  
  
  
      """simple docstring"""
  
  
  
      super().test_outputs_equivalence()
  
   @unittest.skipIf(torch_device == "mps",					"mish op not supported in MPS"					)
   def 		lowercase_						( self :	Dict					):
  
  
  
  
  
      """simple docstring"""
  
  
  
      super().test_from_save_pretrained()
  
   @unittest.skipIf(torch_device == "mps",					"mish op not supported in MPS"					)
   def 		lowercase_						( self :	str					):
  
  
  
  
  
      """simple docstring"""
  
  
  
      super().test_from_save_pretrained_variant()
  
   @unittest.skipIf(torch_device == "mps",					"mish op not supported in MPS"					)
   def 		lowercase_						( self :	Tuple					):
  
  
  
  
  
      """simple docstring"""
  
  
  
      super().test_model_from_pretrained()
  
   @unittest.skipIf(torch_device == "mps",					"mish op not supported in MPS"					)
   def 		lowercase_						( self :	Tuple					):
  
  
  
  
  
      """simple docstring"""
  
  
  
      super().test_output()
  
   def 		lowercase_						( self :	List[str]					):
  
  
  
  
  
      """simple docstring"""
  
  
  
      UpperCamelCase__ 						=						{
          "block_out_channels": (32, 64, 128, 256),
          "in_channels": 14,
          "out_channels": 14,
          "time_embedding_type": "positional",
          "use_timestep_embedding": True,
          "flip_sin_to_cos": False,
          "freq_shift": 1.0,
          "out_block_type": "OutConv1DBlock",
          "mid_block_type": "MidResTemporalBlock1D",
          "down_block_types": ("DownResnetBlock1D", "DownResnetBlock1D", "DownResnetBlock1D", "DownResnetBlock1D"),
          "up_block_types": ("UpResnetBlock1D", "UpResnetBlock1D", "UpResnetBlock1D"),
          "act_fn": "mish",
      }
      UpperCamelCase__ 						=						self.dummy_input
      return init_dict, inputs_dict
  
   @unittest.skipIf(torch_device == "mps",					"mish op not supported in MPS"					)
   def 		lowercase_						( self :	Dict					):
  
  
  
  
  
      """simple docstring"""
  
  
  
      UpperCamelCase__						,		UpperCamelCase__ 						=						UNetaDModel.from_pretrained(
          "bglick13/hopper-medium-v2-value-function-hor32",					output_loading_info=a_,					subfolder="unet"					)
      self.assertIsNotNone(a_					)
      self.assertEqual(len(loading_info["missing_keys"]					),					0					)
  
      model.to(a_					)
      UpperCamelCase__ 						=						model(**self.dummy_input					)
  
      assert image is not None, "Make sure output is not None"
  
   @unittest.skipIf(torch_device == "mps",					"mish op not supported in MPS"					)
   def 		lowercase_						( self :	Optional[int]					):
  
  
  
  
  
      """simple docstring"""
  
  
  
      UpperCamelCase__ 						=						UNetaDModel.from_pretrained("bglick13/hopper-medium-v2-value-function-hor32",					subfolder="unet"					)
      torch.manual_seed(0					)
      if torch.cuda.is_available():
         torch.cuda.manual_seed_all(0					)
  
      UpperCamelCase__ 						=						model.config.in_channels
      UpperCamelCase__ 						=						16
      UpperCamelCase__ 						=						torch.randn((1, seq_len, num_features)					).permute(
          0,					2,					1					)  # match original, we can update values and remove
      UpperCamelCase__ 						=						torch.full((num_features,),					0					)
  
      with torch.no_grad():
         UpperCamelCase__ 						=						model(a_,					a_					).sample.permute(0,					2,					1					)
  
      UpperCamelCase__ 						=						output[0, -3:, -3:].flatten()
      # fmt: off
      UpperCamelCase__ 						=						torch.tensor([-2.137_172, 1.1_426_016, 0.3_688_687, -0.766_922, 0.7_303_146, 0.11_038_864, -0.4_760_633, 0.13_270_172, 0.02_591_348]					)
      # fmt: on
      self.assertTrue(torch.allclose(a_,					a_,					rtol=1e-3					)					)
  
   def 		lowercase_						( self :	str					):
  
  
  
  
  
      """simple docstring"""
  
  
  
      pass
  
   @slow
   def 		lowercase_						( self :	Optional[int]					):
  
  
  
  
  
      """simple docstring"""
  
  
  
      UpperCamelCase__ 						=						"harmonai/maestro-150k"
      UpperCamelCase__ 						=						UNetaDModel.from_pretrained(a_,					subfolder="unet"					)
      model.to(a_					)
  
      UpperCamelCase__ 						=						6_5536
      UpperCamelCase__ 						=						torch.sin(torch.arange(a_					)[None, None, :].repeat(1,					2,					1					)					).to(a_					)
      UpperCamelCase__ 						=						torch.tensor([1]					).to(a_					)
  
      with torch.no_grad():
         UpperCamelCase__ 						=						model(a_,					a_					).sample
  
      UpperCamelCase__ 						=						output.abs().sum()
      UpperCamelCase__ 						=						output.abs().max()
  
      assert (output_sum - 224.0_896).abs() < 0.5
      assert (output_max - 0.0_607).abs() < 4e-4
  
  
  
  
  
  
  
  class  UpperCAmelCase (       SCREAMING_SNAKE_CASE__		,			SCREAMING_SNAKE_CASE__		,			unittest.TestCase):
   _lowerCamelCase :					int    					=					UNetaDModel
   _lowerCamelCase :					Optional[int]    					=					'sample'
  
   @property
   def 		lowercase_						( self :	Dict					):
  
  
  
  
  
      """simple docstring"""
  
  
  
      UpperCamelCase__ 						=						4
      UpperCamelCase__ 						=						14
      UpperCamelCase__ 						=						16
  
      UpperCamelCase__ 						=						floats_tensor((batch_size, num_features, seq_len)					).to(a_					)
      UpperCamelCase__ 						=						torch.tensor([10] * batch_size					).to(a_					)
  
      return {"sample": noise, "timestep": time_step}
  
   @property
   def 		lowercase_						( self :	Any					):
  
  
  
  
  
      """simple docstring"""
  
  
  
      return (4, 14, 16)
  
   @property
   def 		lowercase_						( self :	str					):
  
  
  
  
  
      """simple docstring"""
  
  
  
      return (4, 14, 1)
  
   @unittest.skipIf(torch_device == "mps",					"mish op not supported in MPS"					)
   def 		lowercase_						( self :	Optional[int]					):
  
  
  
  
  
      """simple docstring"""
  
  
  
      super().test_determinism()
  
   @unittest.skipIf(torch_device == "mps",					"mish op not supported in MPS"					)
   def 		lowercase_						( self :	Optional[Any]					):
  
  
  
  
  
      """simple docstring"""
  
  
  
      super().test_outputs_equivalence()
  
   @unittest.skipIf(torch_device == "mps",					"mish op not supported in MPS"					)
   def 		lowercase_						( self :	Tuple					):
  
  
  
  
  
      """simple docstring"""
  
  
  
      super().test_from_save_pretrained()
  
   @unittest.skipIf(torch_device == "mps",					"mish op not supported in MPS"					)
   def 		lowercase_						( self :	Union[str, Any]					):
  
  
  
  
  
      """simple docstring"""
  
  
  
      super().test_from_save_pretrained_variant()
  
   @unittest.skipIf(torch_device == "mps",					"mish op not supported in MPS"					)
   def 		lowercase_						( self :	List[Any]					):
  
  
  
  
  
      """simple docstring"""
  
  
  
      super().test_model_from_pretrained()
  
   @unittest.skipIf(torch_device == "mps",					"mish op not supported in MPS"					)
   def 		lowercase_						( self :	Any					):
  
  
  
  
  
      """simple docstring"""
  
  
  
      UpperCamelCase__						,		UpperCamelCase__ 						=						self.prepare_init_args_and_inputs_for_common()
      UpperCamelCase__ 						=						self.model_class(**a_					)
      model.to(a_					)
      model.eval()
  
      with torch.no_grad():
         UpperCamelCase__ 						=						model(**a_					)
  
         if isinstance(a_,					a_					):
            UpperCamelCase__ 						=						output.sample
  
      self.assertIsNotNone(a_					)
      UpperCamelCase__ 						=						torch.Size((inputs_dict["sample"].shape[0], 1)					)
      self.assertEqual(output.shape,					a_,					"Input and output shapes do not match"					)
  
   def 		lowercase_						( self :	Dict					):
  
  
  
  
  
      """simple docstring"""
  
  
  
      pass
  
   def 		lowercase_						( self :	Optional[Any]					):
  
  
  
  
  
      """simple docstring"""
  
  
  
      pass
  
   def 		lowercase_						( self :	str					):
  
  
  
  
  
      """simple docstring"""
  
  
  
      UpperCamelCase__ 						=						{
          "in_channels": 14,
          "out_channels": 14,
          "down_block_types": ["DownResnetBlock1D", "DownResnetBlock1D", "DownResnetBlock1D", "DownResnetBlock1D"],
          "up_block_types": [],
          "out_block_type": "ValueFunction",
          "mid_block_type": "ValueFunctionMidBlock1D",
          "block_out_channels": [32, 64, 128, 256],
          "layers_per_block": 1,
          "downsample_each_block": True,
          "use_timestep_embedding": True,
          "freq_shift": 1.0,
          "flip_sin_to_cos": False,
          "time_embedding_type": "positional",
          "act_fn": "mish",
      }
      UpperCamelCase__ 						=						self.dummy_input
      return init_dict, inputs_dict
  
   @unittest.skipIf(torch_device == "mps",					"mish op not supported in MPS"					)
   def 		lowercase_						( self :	List[str]					):
  
  
  
  
  
      """simple docstring"""
  
  
  
      UpperCamelCase__						,		UpperCamelCase__ 						=						UNetaDModel.from_pretrained(
          "bglick13/hopper-medium-v2-value-function-hor32",					output_loading_info=a_,					subfolder="value_function"					)
      self.assertIsNotNone(a_					)
      self.assertEqual(len(vf_loading_info["missing_keys"]					),					0					)
  
      value_function.to(a_					)
      UpperCamelCase__ 						=						value_function(**self.dummy_input					)
  
      assert image is not None, "Make sure output is not None"
  
   @unittest.skipIf(torch_device == "mps",					"mish op not supported in MPS"					)
   def 		lowercase_						( self :	Any					):
  
  
  
  
  
      """simple docstring"""
  
  
  
      UpperCamelCase__						,		UpperCamelCase__ 						=						UNetaDModel.from_pretrained(
          "bglick13/hopper-medium-v2-value-function-hor32",					output_loading_info=a_,					subfolder="value_function"					)
      torch.manual_seed(0					)
      if torch.cuda.is_available():
         torch.cuda.manual_seed_all(0					)
  
      UpperCamelCase__ 						=						value_function.config.in_channels
      UpperCamelCase__ 						=						14
      UpperCamelCase__ 						=						torch.randn((1, seq_len, num_features)					).permute(
          0,					2,					1					)  # match original, we can update values and remove
      UpperCamelCase__ 						=						torch.full((num_features,),					0					)
  
      with torch.no_grad():
         UpperCamelCase__ 						=						value_function(a_,					a_					).sample
  
      # fmt: off
      UpperCamelCase__ 						=						torch.tensor([165.25] * seq_len					)
      # fmt: on
      self.assertTrue(torch.allclose(a_,					a_,					rtol=1e-3					)					)
  
   def 		lowercase_						( self :	Optional[int]					):
  
  
  
  
  
      """simple docstring"""
  
  
  
      pass
style_context: 
  
  
  '''simple docstring'''
  
  from typing import TYPE_CHECKING
  
  from ...utils import (
      OptionalDependencyNotAvailable,
      _LazyModule,
      is_sentencepiece_available,
      is_tokenizers_available,
      is_torch_available,
  )
  
  
  __lowercase:		int							=     {
      "configuration_open_llama": ["OPEN_LLAMA_PRETRAINED_CONFIG_ARCHIVE_MAP", "OpenLlamaConfig"],
  }
  
  try:
         if not is_sentencepiece_available():
                raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
         pass
  else:
         __lowercase:		str							=     ["LlamaTokenizer"]
  
  try:
         if not is_tokenizers_available():
                raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
         pass
  else:
         __lowercase:		List[Any]							=     ["LlamaTokenizerFast"]
  
  try:
         if not is_torch_available():
                raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
         pass
  else:
         __lowercase:		Union[str, Any]							=     [
             "OpenLlamaForCausalLM",
             "OpenLlamaModel",
             "OpenLlamaPreTrainedModel",
             "OpenLlamaForSequenceClassification",
         ]
  
  
  if TYPE_CHECKING:
         from .configuration_open_llama import OPEN_LLAMA_PRETRAINED_CONFIG_ARCHIVE_MAP, OpenLlamaConfig
  
         try:
                if not is_sentencepiece_available():
                       raise OptionalDependencyNotAvailable()
         except OptionalDependencyNotAvailable:
                pass
         else:
                from transformers import LlamaTokenizer
  
         try:
                if not is_tokenizers_available():
                       raise OptionalDependencyNotAvailable()
         except OptionalDependencyNotAvailable:
                pass
         else:
                from transformers import LlamaTokenizerFast
  
         try:
                if not is_torch_available():
                       raise OptionalDependencyNotAvailable()
         except OptionalDependencyNotAvailable:
                pass
         else:
                from .modeling_open_llama import (
                    OpenLlamaForCausalLM,
                    OpenLlamaForSequenceClassification,
                    OpenLlamaModel,
                    OpenLlamaPreTrainedModel,
                )
  
  
  else:
         import sys
  
         __lowercase:		Tuple							=     _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)