


'''simple docstring'''



import collections

from .utils import ExplicitEnum, is_torch_available, logging


if is_torch_available():
						import torch


A__		: List[str]												=  logging.get_logger(__name__)





class        UpperCAmelCase_  :





				"""simple docstring"""






				def __init__(							self      ,					SCREAMING_SNAKE_CASE_      ,					SCREAMING_SNAKE_CASE_=21      ,					SCREAMING_SNAKE_CASE_=[]      ,					SCREAMING_SNAKE_CASE_=None     )    ->					Tuple:
									__lowerCamelCase       :     Optional[Any]        =		model
									__lowerCamelCase       :     str        =		trace_batch_nums
									__lowerCamelCase       :     Dict        =		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
									__lowerCamelCase       :     List[str]        =		collections.deque([]      ,					snake_case__     )
									__lowerCamelCase       :     Optional[Any]        =		[]
									__lowerCamelCase       :     int        =		0
									__lowerCamelCase       :     List[str]        =		0
									__lowerCamelCase       :     Dict        =		False
									__lowerCamelCase       :     Dict        =		'                 '

									self.analyse_model()

									self.register_forward_hook()







				def 				lowercase_    (							self      ,					SCREAMING_SNAKE_CASE_=None     )    ->					Union[str, Any]:


									if frame is not None:
														self.expand_frame(snake_case__     )
									self.frames.append('\n'.join(self.frame     )     )
									__lowerCamelCase       :     Any        =		[]  # start a new frame







				def 				lowercase_    (							self      ,					SCREAMING_SNAKE_CASE_     )    ->					Union[str, Any]:
									self.frame.append(snake_case__     )







				def 				lowercase_    (							self     )    ->					Optional[Any]:
									print('\n'.join(self.frames     )     )
									__lowerCamelCase       :     Dict        =		[]







				def 				lowercase_    (							self     )    ->					List[str]:
									__lowerCamelCase       :     Union[str, Any]        =		[]







				def 				lowercase_    (							self     )    ->					str:
									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'     )
									__lowerCamelCase       :     Optional[int]        =		[]







				def 				lowercase_    (							self     )    ->					Optional[Any]:
									__lowerCamelCase       :     str        =		{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 				lowercase_    (							self      ,					SCREAMING_SNAKE_CASE_      ,					SCREAMING_SNAKE_CASE_     )    ->					List[str]:


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







				def 				lowercase_    (							self     )    ->					Union[str, Any]:
									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 				lowercase_    (							self     )    ->					Any:
									self.expand_frame(f'{self.prefix} *** Finished batch number={self.batch_number-1} ***\n\n'     )







				def 				lowercase_    (							self      ,					SCREAMING_SNAKE_CASE_      ,					SCREAMING_SNAKE_CASE_      ,					SCREAMING_SNAKE_CASE_     )    ->					Tuple:
									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 				lowercase_    (							self     )    ->					List[Any]:
									self.model.apply(self._register_forward_hook     )







				def 				lowercase_    (							self      ,					SCREAMING_SNAKE_CASE_     )    ->					List[str]:
									module.register_forward_hook(self.forward_hook     )







				def 				lowercase_    (							self      ,					SCREAMING_SNAKE_CASE_      ,					SCREAMING_SNAKE_CASE_      ,					SCREAMING_SNAKE_CASE_     )    ->					Optional[Any]:
									__lowerCamelCase       :     Tuple        =		False

									__lowerCamelCase       :     Union[str, Any]        =		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
														__lowerCamelCase       :     Optional[int]        =		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       UpperCAmelCase__ (     UpperCAmelCase_   :    str				,   UpperCAmelCase_   :    Dict							)					->		List[str]:
					__lowerCamelCase       :     Optional[Any]        =		var.abs()
					return F'{abs_var.min():8.2e} {abs_var.max():8.2e} {ctx}'



def       UpperCAmelCase__ (     UpperCAmelCase_   :    Optional[int]				,   UpperCAmelCase_   :    int							)					->		str:
					__lowerCamelCase       :     Tuple        =		False
					if torch.isnan(_lowerCAmelCase							).any().item():
										__lowerCamelCase       :     Optional[Any]        =		True
										print(F'{ctx} has nans'							)
					if torch.isinf(_lowerCAmelCase							).any().item():
										__lowerCamelCase       :     Tuple        =		True
										print(F'{ctx} has infs'							)

					# if needed to monitor large elements can enable the following
					if 0:  # and detected:
										__lowerCamelCase       :     Dict        =		var[torch.ge(var.abs()				,   1_00							)]
										if naaa.numel() > 0:
															print(F'{ctx}:  n100={naaa.numel()}'							)
										__lowerCamelCase       :     Any        =		var[torch.ge(var.abs()				,   10_00							)]
										if naaaa.numel() > 0:
															print(F'{ctx}: n1000={naaaa.numel()}'							)
										__lowerCamelCase       :     Optional[int]        =		var[torch.ge(var.abs()				,   1_00_00							)]
										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        UpperCAmelCase_  (a_  ):





				"""simple docstring"""






				lowerCamelCase  : Dict												=      'underflow_overflow'
				lowerCamelCase  : List[Any]												=      'tpu_metrics_debug'










'''simple docstring'''



from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tf_available, is_torch_available


A__		: str												=  {"""configuration_hubert""": ["""HUBERT_PRETRAINED_CONFIG_ARCHIVE_MAP""", """HubertConfig"""]}

try:
      if not is_torch_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      A__		: List[str]												=  [
          """HUBERT_PRETRAINED_MODEL_ARCHIVE_LIST""",
          """HubertForCTC""",
          """HubertForSequenceClassification""",
          """HubertModel""",
          """HubertPreTrainedModel""",
      ]


try:
      if not is_tf_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      A__		: Optional[int]												=  [
          """TF_HUBERT_PRETRAINED_MODEL_ARCHIVE_LIST""",
          """TFHubertForCTC""",
          """TFHubertModel""",
          """TFHubertPreTrainedModel""",
      ]

if TYPE_CHECKING:
      from .configuration_hubert import HUBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, HubertConfig

      try:
            if not is_torch_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .modeling_hubert import (
                HUBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
                HubertForCTC,
                HubertForSequenceClassification,
                HubertModel,
                HubertPreTrainedModel,
            )

      try:
            if not is_tf_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .modeling_tf_hubert import (
                TF_HUBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
                TFHubertForCTC,
                TFHubertModel,
                TFHubertPreTrainedModel,
            )


else:
      import sys

      A__		: Optional[int]												=  _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)






