


'''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



'''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__)