
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 __snake_case	(   lowerCAmelCase      ,			lowerCAmelCase      ,			unittest.TestCase  ):
    _a	:		Any=       UNetaDModel
    _a	:		Any=       "sample"
    @property
    def    _SCREAMING_SNAKE_CASE (						self   ):



           '''simple docstring'''







           lowercase							:  Tuple 			=   4
           lowercase							:  Any 			=   14
           lowercase							:  List[Any] 			=   16

           lowercase							:  Optional[int] 			=   floats_tensor((batch_size, num_features, seq_len)   ).to(snake_case   )
           lowercase							:  Union[str, Any] 			=   torch.tensor([10] * batch_size   ).to(snake_case   )

           return {"sample": noise, "timestep": time_step}
    @property
    def    _SCREAMING_SNAKE_CASE (						self   ):



           '''simple docstring'''







           return (4, 14, 16)
    @property
    def    _SCREAMING_SNAKE_CASE (						self   ):



           '''simple docstring'''







           return (4, 14, 16)
    def    _SCREAMING_SNAKE_CASE (						self   ):



           '''simple docstring'''







           pass
    def    _SCREAMING_SNAKE_CASE (						self   ):



           '''simple docstring'''







           pass
    @unittest.skipIf(torch_device == """mps"""	,"""mish op not supported in MPS"""   )
    def    _SCREAMING_SNAKE_CASE (						self   ):



           '''simple docstring'''







           super().test_determinism()
    @unittest.skipIf(torch_device == """mps"""	,"""mish op not supported in MPS"""   )
    def    _SCREAMING_SNAKE_CASE (						self   ):



           '''simple docstring'''







           super().test_outputs_equivalence()
    @unittest.skipIf(torch_device == """mps"""	,"""mish op not supported in MPS"""   )
    def    _SCREAMING_SNAKE_CASE (						self   ):



           '''simple docstring'''







           super().test_from_save_pretrained()
    @unittest.skipIf(torch_device == """mps"""	,"""mish op not supported in MPS"""   )
    def    _SCREAMING_SNAKE_CASE (						self   ):



           '''simple docstring'''







           super().test_from_save_pretrained_variant()
    @unittest.skipIf(torch_device == """mps"""	,"""mish op not supported in MPS"""   )
    def    _SCREAMING_SNAKE_CASE (						self   ):



           '''simple docstring'''







           super().test_model_from_pretrained()
    @unittest.skipIf(torch_device == """mps"""	,"""mish op not supported in MPS"""   )
    def    _SCREAMING_SNAKE_CASE (						self   ):



           '''simple docstring'''







           super().test_output()
    def    _SCREAMING_SNAKE_CASE (						self   ):



           '''simple docstring'''







           lowercase							:  List[str] 			=   {
               """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""",
           }
           lowercase							:  List[str] 			=   self.dummy_input
           return init_dict, inputs_dict
    @unittest.skipIf(torch_device == """mps"""	,"""mish op not supported in MPS"""   )
    def    _SCREAMING_SNAKE_CASE (						self   ):



           '''simple docstring'''







           lowercase			,    lowercase							:  str 			=   UNetaDModel.from_pretrained(
               """bglick13/hopper-medium-v2-value-function-hor32"""	,output_loading_info=snake_case	,subfolder="""unet"""   )
           self.assertIsNotNone(snake_case   )
           self.assertEqual(len(loading_info["""missing_keys"""]   )	,0   )

           model.to(snake_case   )
           lowercase							:  Dict 			=   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    _SCREAMING_SNAKE_CASE (						self   ):



           '''simple docstring'''







           lowercase							:  Optional[int] 			=   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   )

           lowercase							:  List[Any] 			=   model.config.in_channels
           lowercase							:  int 			=   16
           lowercase							:  List[Any] 			=   torch.randn((1, seq_len, num_features)   ).permute(
               0	,2	,1   )  # match original, we can update values and remove
           lowercase							:  List[str] 			=   torch.full((num_features,)	,0   )

           with torch.no_grad():
                  lowercase							:  str 			=   model(snake_case	,snake_case   ).sample.permute(0	,2	,1   )

           lowercase							:  int 			=   output[0, -3:, -3:].flatten()
           # fmt: off
           lowercase							:  Tuple 			=   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(snake_case	,snake_case	,rtol=1e-3   )   )
    def    _SCREAMING_SNAKE_CASE (						self   ):



           '''simple docstring'''







           pass
    @slow
    def    _SCREAMING_SNAKE_CASE (						self   ):



           '''simple docstring'''







           lowercase							:  Tuple 			=   """harmonai/maestro-150k"""
           lowercase							:  List[Any] 			=   UNetaDModel.from_pretrained(snake_case	,subfolder="""unet"""   )
           model.to(snake_case   )

           lowercase							:  List[str] 			=   65536
           lowercase							:  int 			=   torch.sin(torch.arange(snake_case   )[None, None, :].repeat(1	,2	,1   )   ).to(snake_case   )
           lowercase							:  Dict 			=   torch.tensor([1]   ).to(snake_case   )

           with torch.no_grad():
                  lowercase							:  Any 			=   model(snake_case	,snake_case   ).sample

           lowercase							:  Optional[Any] 			=   output.abs().sum()
           lowercase							:  List[str] 			=   output.abs().max()

           assert (output_sum - 224.0_896).abs() < 0.5
           assert (output_max - 0.0_607).abs() < 4e-4






class __snake_case	(   lowerCAmelCase      ,			lowerCAmelCase      ,			unittest.TestCase  ):
    _a	:		int=       UNetaDModel
    _a	:		Union[str, Any]=       "sample"
    @property
    def    _SCREAMING_SNAKE_CASE (						self   ):



           '''simple docstring'''







           lowercase							:  Tuple 			=   4
           lowercase							:  Any 			=   14
           lowercase							:  List[str] 			=   16

           lowercase							:  Optional[int] 			=   floats_tensor((batch_size, num_features, seq_len)   ).to(snake_case   )
           lowercase							:  str 			=   torch.tensor([10] * batch_size   ).to(snake_case   )

           return {"sample": noise, "timestep": time_step}
    @property
    def    _SCREAMING_SNAKE_CASE (						self   ):



           '''simple docstring'''







           return (4, 14, 16)
    @property
    def    _SCREAMING_SNAKE_CASE (						self   ):



           '''simple docstring'''







           return (4, 14, 1)
    @unittest.skipIf(torch_device == """mps"""	,"""mish op not supported in MPS"""   )
    def    _SCREAMING_SNAKE_CASE (						self   ):



           '''simple docstring'''







           super().test_determinism()
    @unittest.skipIf(torch_device == """mps"""	,"""mish op not supported in MPS"""   )
    def    _SCREAMING_SNAKE_CASE (						self   ):



           '''simple docstring'''







           super().test_outputs_equivalence()
    @unittest.skipIf(torch_device == """mps"""	,"""mish op not supported in MPS"""   )
    def    _SCREAMING_SNAKE_CASE (						self   ):



           '''simple docstring'''







           super().test_from_save_pretrained()
    @unittest.skipIf(torch_device == """mps"""	,"""mish op not supported in MPS"""   )
    def    _SCREAMING_SNAKE_CASE (						self   ):



           '''simple docstring'''







           super().test_from_save_pretrained_variant()
    @unittest.skipIf(torch_device == """mps"""	,"""mish op not supported in MPS"""   )
    def    _SCREAMING_SNAKE_CASE (						self   ):



           '''simple docstring'''







           super().test_model_from_pretrained()
    @unittest.skipIf(torch_device == """mps"""	,"""mish op not supported in MPS"""   )
    def    _SCREAMING_SNAKE_CASE (						self   ):



           '''simple docstring'''







           lowercase			,    lowercase							:  Optional[Any] 			=   self.prepare_init_args_and_inputs_for_common()
           lowercase							:  Any 			=   self.model_class(**snake_case   )
           model.to(snake_case   )
           model.eval()

           with torch.no_grad():
                  lowercase							:  Dict 			=   model(**snake_case   )

                  if isinstance(snake_case	,snake_case   ):
                         lowercase							:  str 			=   output.sample

           self.assertIsNotNone(snake_case   )
           lowercase							:  Optional[int] 			=   torch.Size((inputs_dict["""sample"""].shape[0], 1)   )
           self.assertEqual(output.shape	,snake_case	,"""Input and output shapes do not match"""   )
    def    _SCREAMING_SNAKE_CASE (						self   ):



           '''simple docstring'''







           pass
    def    _SCREAMING_SNAKE_CASE (						self   ):



           '''simple docstring'''







           pass
    def    _SCREAMING_SNAKE_CASE (						self   ):



           '''simple docstring'''







           lowercase							:  List[Any] 			=   {
               """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""",
           }
           lowercase							:  Optional[Any] 			=   self.dummy_input
           return init_dict, inputs_dict
    @unittest.skipIf(torch_device == """mps"""	,"""mish op not supported in MPS"""   )
    def    _SCREAMING_SNAKE_CASE (						self   ):



           '''simple docstring'''







           lowercase			,    lowercase							:  Union[str, Any] 			=   UNetaDModel.from_pretrained(
               """bglick13/hopper-medium-v2-value-function-hor32"""	,output_loading_info=snake_case	,subfolder="""value_function"""   )
           self.assertIsNotNone(snake_case   )
           self.assertEqual(len(vf_loading_info["""missing_keys"""]   )	,0   )

           value_function.to(snake_case   )
           lowercase							:  Dict 			=   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    _SCREAMING_SNAKE_CASE (						self   ):



           '''simple docstring'''







           lowercase			,    lowercase							:  Tuple 			=   UNetaDModel.from_pretrained(
               """bglick13/hopper-medium-v2-value-function-hor32"""	,output_loading_info=snake_case	,subfolder="""value_function"""   )
           torch.manual_seed(0   )
           if torch.cuda.is_available():
                  torch.cuda.manual_seed_all(0   )

           lowercase							:  Tuple 			=   value_function.config.in_channels
           lowercase							:  Tuple 			=   14
           lowercase							:  Tuple 			=   torch.randn((1, seq_len, num_features)   ).permute(
               0	,2	,1   )  # match original, we can update values and remove
           lowercase							:  List[Any] 			=   torch.full((num_features,)	,0   )

           with torch.no_grad():
                  lowercase							:  List[str] 			=   value_function(snake_case	,snake_case   ).sample

           # fmt: off
           lowercase							:  Tuple 			=   torch.tensor([165.25] * seq_len   )
           # fmt: on
           self.assertTrue(torch.allclose(snake_case	,snake_case	,rtol=1e-3   )   )
    def    _SCREAMING_SNAKE_CASE (						self   ):



           '''simple docstring'''







           pass


import collections

from .utils import ExplicitEnum, is_torch_available, logging


if is_torch_available():
  import torch


lowercase						:      Any							=							logging.get_logger(__name__)

class __snake_case	:
    def __init__(						self	,snake_case	,snake_case=21	,snake_case=[]	,snake_case=None   ):



           '''simple docstring'''







           lowercase							:  Tuple 			=   model
           lowercase							:  List[Any] 			=   trace_batch_nums
           lowercase							:  Union[str, Any] 			=   abort_after_batch_num

           # keep a LIFO buffer of frames to dump as soon as inf/nan is encountered to give context to the problem emergence
           lowercase							:  List[Any] 			=   collections.deque([]	,snake_case   )
           lowercase							:  List[Any] 			=   []
           lowercase							:  Tuple 			=   0
           lowercase							:  Optional[Any] 			=   0
           lowercase							:  int 			=   False
           lowercase							:  List[str] 			=   """                 """

           self.analyse_model()

           self.register_forward_hook()
    def    _SCREAMING_SNAKE_CASE (						self	,snake_case=None   ):



           '''simple docstring'''







           if frame is not None:
                  self.expand_frame(snake_case   )
           self.frames.append("""\n""".join(self.frame   )   )
           lowercase							:  List[str] 			=   []  # start a new frame
    def    _SCREAMING_SNAKE_CASE (						self	,snake_case   ):



           '''simple docstring'''







           self.frame.append(snake_case   )
    def    _SCREAMING_SNAKE_CASE (						self   ):



           '''simple docstring'''







           print("""\n""".join(self.frames   )   )
           lowercase							:  Any 			=   []
    def    _SCREAMING_SNAKE_CASE (						self   ):



           '''simple docstring'''







           lowercase							:  List[str] 			=   []
    def    _SCREAMING_SNAKE_CASE (						self   ):



           '''simple docstring'''







           print(f"\nDetected inf/nan during batch_number={self.batch_number}"   )
           print(f"Last {len(self.frames   )} forward frames:"   )
           print(f"{'abs min':8} {'abs max':8} metadata"   )
           print("""\n""".join(self.frames   )   )
           print("""\n\n"""   )
           lowercase							:  Dict 			=   []
    def    _SCREAMING_SNAKE_CASE (						self   ):



           '''simple docstring'''







           lowercase							:  int 			=   {m: name for name, m in self.model.named_modules()}
           # self.longest_module_name = max(len(v) for v in self.module_names.values())
    def    _SCREAMING_SNAKE_CASE (						self	,snake_case	,snake_case   ):



           '''simple docstring'''







           if torch.is_tensor(snake_case   ):
                  self.expand_frame(get_abs_min_max(snake_case	,snake_case   )   )
                  if detect_overflow(snake_case	,snake_case   ):
                         lowercase							:  str 			=   True
           elif var is None:
                  self.expand_frame(f"{'None':>17} {ctx}"   )
           else:
                  self.expand_frame(f"{'not a tensor':>17} {ctx}"   )
    def    _SCREAMING_SNAKE_CASE (						self   ):



           '''simple docstring'''







           self.expand_frame(f"\n\n{self.prefix} *** Starting batch number={self.batch_number} ***"   )
           self.expand_frame(f"{'abs min':8} {'abs max':8} metadata"   )
    def    _SCREAMING_SNAKE_CASE (						self   ):



           '''simple docstring'''







           self.expand_frame(f"{self.prefix} *** Finished batch number={self.batch_number-1} ***\n\n"   )
    def    _SCREAMING_SNAKE_CASE (						self	,snake_case	,snake_case	,snake_case   ):



           '''simple docstring'''







           self.expand_frame(f"{self.prefix} {self.module_names[module]} {module.__class__.__name__}"   )

           # params
           for name, p in module.named_parameters(recurse=snake_case   ):
                  self.analyse_variable(snake_case	,snake_case   )

           # inputs
           if isinstance(snake_case	,snake_case   ):
                  for i, x in enumerate(snake_case   ):
                         self.analyse_variable(snake_case	,f"input[{i}]"   )
           else:
                  self.analyse_variable(snake_case	,"""input"""   )

           # outputs
           if isinstance(snake_case	,snake_case   ):
                  for i, x in enumerate(snake_case   ):
                         # possibly a tuple of tuples
                         if isinstance(snake_case	,snake_case   ):
                                for j, y in enumerate(snake_case   ):
                                       self.analyse_variable(snake_case	,f"output[{i}][{j}]"   )
                         else:
                                self.analyse_variable(snake_case	,f"output[{i}]"   )
           else:
                  self.analyse_variable(snake_case	,"""output"""   )

           self.save_frame()
    def    _SCREAMING_SNAKE_CASE (						self   ):



           '''simple docstring'''







           self.model.apply(self._register_forward_hook   )
    def    _SCREAMING_SNAKE_CASE (						self	,snake_case   ):



           '''simple docstring'''







           module.register_forward_hook(self.forward_hook   )
    def    _SCREAMING_SNAKE_CASE (						self	,snake_case	,snake_case	,snake_case   ):



           '''simple docstring'''







           lowercase							:  Dict 			=   False

           lowercase							:  str 			=   True if self.batch_number in self.trace_batch_nums else False
           if trace_mode:
                  self.reset_saved_frames()

           if self.total_calls == 0:
                  self.batch_start_frame()
           self.total_calls += 1

           # count batch numbers - the very first forward hook of the batch will be called when the
           # batch completes - i.e. it gets called very last - we know this batch has finished
           if module == self.model:
                  self.batch_number += 1
                  lowercase							:  Tuple 			=   True

           self.create_frame(snake_case	,snake_case	,snake_case   )

           # if last_frame_of_batch:
           #     self.batch_end_frame()

           if trace_mode:
                  self.trace_frames()

           if last_frame_of_batch:
                  self.batch_start_frame()

           if self.detected_overflow and not trace_mode:
                  self.dump_saved_frames()

                  # now we can abort, as it's pointless to continue running
                  raise ValueError(
                      """DebugUnderflowOverflow: inf/nan detected, aborting as there is no point running further. """
                      """Please scroll up above this traceback to see the activation values prior to this event."""   )

           # abort after certain batch if requested to do so
           if self.abort_after_batch_num is not None and self.batch_number > self.abort_after_batch_num:
                  raise ValueError(
                      f"DebugUnderflowOverflow: aborting after {self.batch_number} batches due to"
                      f" `abort_after_batch_num={self.abort_after_batch_num}` arg"   )







def 		_snake_case(						SCREAMING_SNAKE_CASE__      ,			SCREAMING_SNAKE_CASE__       )				->					List[str]:
       lowercase							:  str 			=   var.abs()
       return f"{abs_var.min():8.2e} {abs_var.max():8.2e} {ctx}"







def 		_snake_case(						SCREAMING_SNAKE_CASE__      ,			SCREAMING_SNAKE_CASE__       )				->					Optional[int]:
       lowercase							:  Any 			=   False
       if torch.isnan(SCREAMING_SNAKE_CASE__       ).any().item():
              lowercase							:  Tuple 			=   True
              print(f"{ctx} has nans"       )
       if torch.isinf(SCREAMING_SNAKE_CASE__       ).any().item():
              lowercase							:  Union[str, Any] 			=   True
              print(f"{ctx} has infs"       )

       # if needed to monitor large elements can enable the following
       if 0:  # and detected:
              lowercase							:  Optional[int] 			=   var[torch.ge(var.abs()      ,			100       )]
              if naaa.numel() > 0:
                     print(f"{ctx}:  n100={naaa.numel()}"       )
              lowercase							:  Union[str, Any] 			=   var[torch.ge(var.abs()      ,			1_000       )]
              if naaaa.numel() > 0:
                     print(f"{ctx}: n1000={naaaa.numel()}"       )
              lowercase							:  List[str] 			=   var[torch.ge(var.abs()      ,			10_000       )]
              if naaaaa.numel() > 0:
                     print(f"{ctx}: n10000={naaaaa.numel()}"       )

       if 0:
              print(f"min={var.min():9.2e} max={var.max():9.2e}"       )

       if 0:
              print(f"min={var.min():9.2e} max={var.max():9.2e} var={var.var():9.2e} mean={var.mean():9.2e} ({ctx})"       )

       return detected




class __snake_case	(   lowerCAmelCase  ):
    _a	:		Dict=       "underflow_overflow"
    _a	:		Union[str, Any]=       "tpu_metrics_debug"
