code: 
  
  
  
  
  
  
  from typing import TYPE_CHECKING
  
  from ...utils import (
      OptionalDependencyNotAvailable,
      _LazyModule,
      is_flax_available,
      is_tf_available,
      is_torch_available,
  )
  
  
  SCREAMING_SNAKE_CASE__		:       str   							=							{
      """auto_factory""": ["""get_values"""],
      """configuration_auto""": ["""ALL_PRETRAINED_CONFIG_ARCHIVE_MAP""", """CONFIG_MAPPING""", """MODEL_NAMES_MAPPING""", """AutoConfig"""],
      """feature_extraction_auto""": ["""FEATURE_EXTRACTOR_MAPPING""", """AutoFeatureExtractor"""],
      """image_processing_auto""": ["""IMAGE_PROCESSOR_MAPPING""", """AutoImageProcessor"""],
      """processing_auto""": ["""PROCESSOR_MAPPING""", """AutoProcessor"""],
      """tokenization_auto""": ["""TOKENIZER_MAPPING""", """AutoTokenizer"""],
  }
  
  try:
        if not is_torch_available():
              raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
        pass
  else:
        SCREAMING_SNAKE_CASE__		:       List[Any]   							=							[
            """MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING""",
            """MODEL_FOR_AUDIO_FRAME_CLASSIFICATION_MAPPING""",
            """MODEL_FOR_AUDIO_XVECTOR_MAPPING""",
            """MODEL_FOR_BACKBONE_MAPPING""",
            """MODEL_FOR_CAUSAL_IMAGE_MODELING_MAPPING""",
            """MODEL_FOR_CAUSAL_LM_MAPPING""",
            """MODEL_FOR_CTC_MAPPING""",
            """MODEL_FOR_DOCUMENT_QUESTION_ANSWERING_MAPPING""",
            """MODEL_FOR_DEPTH_ESTIMATION_MAPPING""",
            """MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING""",
            """MODEL_FOR_IMAGE_SEGMENTATION_MAPPING""",
            """MODEL_FOR_INSTANCE_SEGMENTATION_MAPPING""",
            """MODEL_FOR_MASKED_IMAGE_MODELING_MAPPING""",
            """MODEL_FOR_MASKED_LM_MAPPING""",
            """MODEL_FOR_MASK_GENERATION_MAPPING""",
            """MODEL_FOR_MULTIPLE_CHOICE_MAPPING""",
            """MODEL_FOR_NEXT_SENTENCE_PREDICTION_MAPPING""",
            """MODEL_FOR_OBJECT_DETECTION_MAPPING""",
            """MODEL_FOR_PRETRAINING_MAPPING""",
            """MODEL_FOR_QUESTION_ANSWERING_MAPPING""",
            """MODEL_FOR_SEMANTIC_SEGMENTATION_MAPPING""",
            """MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING""",
            """MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING""",
            """MODEL_FOR_SPEECH_SEQ_2_SEQ_MAPPING""",
            """MODEL_FOR_TABLE_QUESTION_ANSWERING_MAPPING""",
            """MODEL_FOR_TEXT_ENCODING_MAPPING""",
            """MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING""",
            """MODEL_FOR_UNIVERSAL_SEGMENTATION_MAPPING""",
            """MODEL_FOR_VIDEO_CLASSIFICATION_MAPPING""",
            """MODEL_FOR_VISION_2_SEQ_MAPPING""",
            """MODEL_FOR_VISUAL_QUESTION_ANSWERING_MAPPING""",
            """MODEL_MAPPING""",
            """MODEL_WITH_LM_HEAD_MAPPING""",
            """MODEL_FOR_ZERO_SHOT_IMAGE_CLASSIFICATION_MAPPING""",
            """MODEL_FOR_ZERO_SHOT_OBJECT_DETECTION_MAPPING""",
            """AutoModel""",
            """AutoBackbone""",
            """AutoModelForAudioClassification""",
            """AutoModelForAudioFrameClassification""",
            """AutoModelForAudioXVector""",
            """AutoModelForCausalLM""",
            """AutoModelForCTC""",
            """AutoModelForDepthEstimation""",
            """AutoModelForImageClassification""",
            """AutoModelForImageSegmentation""",
            """AutoModelForInstanceSegmentation""",
            """AutoModelForMaskGeneration""",
            """AutoModelForTextEncoding""",
            """AutoModelForMaskedImageModeling""",
            """AutoModelForMaskedLM""",
            """AutoModelForMultipleChoice""",
            """AutoModelForNextSentencePrediction""",
            """AutoModelForObjectDetection""",
            """AutoModelForPreTraining""",
            """AutoModelForQuestionAnswering""",
            """AutoModelForSemanticSegmentation""",
            """AutoModelForSeq2SeqLM""",
            """AutoModelForSequenceClassification""",
            """AutoModelForSpeechSeq2Seq""",
            """AutoModelForTableQuestionAnswering""",
            """AutoModelForTokenClassification""",
            """AutoModelForUniversalSegmentation""",
            """AutoModelForVideoClassification""",
            """AutoModelForVision2Seq""",
            """AutoModelForVisualQuestionAnswering""",
            """AutoModelForDocumentQuestionAnswering""",
            """AutoModelWithLMHead""",
            """AutoModelForZeroShotImageClassification""",
            """AutoModelForZeroShotObjectDetection""",
        ]
  
  try:
        if not is_tf_available():
              raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
        pass
  else:
        SCREAMING_SNAKE_CASE__		:       str   							=							[
            """TF_MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING""",
            """TF_MODEL_FOR_CAUSAL_LM_MAPPING""",
            """TF_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING""",
            """TF_MODEL_FOR_MASK_GENERATION_MAPPING""",
            """TF_MODEL_FOR_MASKED_IMAGE_MODELING_MAPPING""",
            """TF_MODEL_FOR_MASKED_LM_MAPPING""",
            """TF_MODEL_FOR_MULTIPLE_CHOICE_MAPPING""",
            """TF_MODEL_FOR_NEXT_SENTENCE_PREDICTION_MAPPING""",
            """TF_MODEL_FOR_PRETRAINING_MAPPING""",
            """TF_MODEL_FOR_QUESTION_ANSWERING_MAPPING""",
            """TF_MODEL_FOR_DOCUMENT_QUESTION_ANSWERING_MAPPING""",
            """TF_MODEL_FOR_SEMANTIC_SEGMENTATION_MAPPING""",
            """TF_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING""",
            """TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING""",
            """TF_MODEL_FOR_SPEECH_SEQ_2_SEQ_MAPPING""",
            """TF_MODEL_FOR_TABLE_QUESTION_ANSWERING_MAPPING""",
            """TF_MODEL_FOR_TEXT_ENCODING_MAPPING""",
            """TF_MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING""",
            """TF_MODEL_FOR_VISION_2_SEQ_MAPPING""",
            """TF_MODEL_FOR_ZERO_SHOT_IMAGE_CLASSIFICATION_MAPPING""",
            """TF_MODEL_MAPPING""",
            """TF_MODEL_WITH_LM_HEAD_MAPPING""",
            """TFAutoModel""",
            """TFAutoModelForAudioClassification""",
            """TFAutoModelForCausalLM""",
            """TFAutoModelForImageClassification""",
            """TFAutoModelForMaskedImageModeling""",
            """TFAutoModelForMaskedLM""",
            """TFAutoModelForMaskGeneration""",
            """TFAutoModelForMultipleChoice""",
            """TFAutoModelForNextSentencePrediction""",
            """TFAutoModelForPreTraining""",
            """TFAutoModelForDocumentQuestionAnswering""",
            """TFAutoModelForQuestionAnswering""",
            """TFAutoModelForSemanticSegmentation""",
            """TFAutoModelForSeq2SeqLM""",
            """TFAutoModelForSequenceClassification""",
            """TFAutoModelForSpeechSeq2Seq""",
            """TFAutoModelForTableQuestionAnswering""",
            """TFAutoModelForTextEncoding""",
            """TFAutoModelForTokenClassification""",
            """TFAutoModelForVision2Seq""",
            """TFAutoModelForZeroShotImageClassification""",
            """TFAutoModelWithLMHead""",
        ]
  
  try:
        if not is_flax_available():
              raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
        pass
  else:
        SCREAMING_SNAKE_CASE__		:       Optional[Any]   							=							[
            """FLAX_MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING""",
            """FLAX_MODEL_FOR_CAUSAL_LM_MAPPING""",
            """FLAX_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING""",
            """FLAX_MODEL_FOR_MASKED_LM_MAPPING""",
            """FLAX_MODEL_FOR_MULTIPLE_CHOICE_MAPPING""",
            """FLAX_MODEL_FOR_NEXT_SENTENCE_PREDICTION_MAPPING""",
            """FLAX_MODEL_FOR_PRETRAINING_MAPPING""",
            """FLAX_MODEL_FOR_QUESTION_ANSWERING_MAPPING""",
            """FLAX_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING""",
            """FLAX_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING""",
            """FLAX_MODEL_FOR_SPEECH_SEQ_2_SEQ_MAPPING""",
            """FLAX_MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING""",
            """FLAX_MODEL_FOR_VISION_2_SEQ_MAPPING""",
            """FLAX_MODEL_MAPPING""",
            """FlaxAutoModel""",
            """FlaxAutoModelForCausalLM""",
            """FlaxAutoModelForImageClassification""",
            """FlaxAutoModelForMaskedLM""",
            """FlaxAutoModelForMultipleChoice""",
            """FlaxAutoModelForNextSentencePrediction""",
            """FlaxAutoModelForPreTraining""",
            """FlaxAutoModelForQuestionAnswering""",
            """FlaxAutoModelForSeq2SeqLM""",
            """FlaxAutoModelForSequenceClassification""",
            """FlaxAutoModelForSpeechSeq2Seq""",
            """FlaxAutoModelForTokenClassification""",
            """FlaxAutoModelForVision2Seq""",
        ]
  
  
  if TYPE_CHECKING:
        from .auto_factory import get_values
        from .configuration_auto import ALL_PRETRAINED_CONFIG_ARCHIVE_MAP, CONFIG_MAPPING, MODEL_NAMES_MAPPING, AutoConfig
        from .feature_extraction_auto import FEATURE_EXTRACTOR_MAPPING, AutoFeatureExtractor
        from .image_processing_auto import IMAGE_PROCESSOR_MAPPING, AutoImageProcessor
        from .processing_auto import PROCESSOR_MAPPING, AutoProcessor
        from .tokenization_auto import TOKENIZER_MAPPING, AutoTokenizer
  
        try:
              if not is_torch_available():
                    raise OptionalDependencyNotAvailable()
        except OptionalDependencyNotAvailable:
              pass
        else:
              from .modeling_auto import (
                  MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING,
                  MODEL_FOR_AUDIO_FRAME_CLASSIFICATION_MAPPING,
                  MODEL_FOR_AUDIO_XVECTOR_MAPPING,
                  MODEL_FOR_BACKBONE_MAPPING,
                  MODEL_FOR_CAUSAL_IMAGE_MODELING_MAPPING,
                  MODEL_FOR_CAUSAL_LM_MAPPING,
                  MODEL_FOR_CTC_MAPPING,
                  MODEL_FOR_DEPTH_ESTIMATION_MAPPING,
                  MODEL_FOR_DOCUMENT_QUESTION_ANSWERING_MAPPING,
                  MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING,
                  MODEL_FOR_IMAGE_SEGMENTATION_MAPPING,
                  MODEL_FOR_INSTANCE_SEGMENTATION_MAPPING,
                  MODEL_FOR_MASK_GENERATION_MAPPING,
                  MODEL_FOR_MASKED_IMAGE_MODELING_MAPPING,
                  MODEL_FOR_MASKED_LM_MAPPING,
                  MODEL_FOR_MULTIPLE_CHOICE_MAPPING,
                  MODEL_FOR_NEXT_SENTENCE_PREDICTION_MAPPING,
                  MODEL_FOR_OBJECT_DETECTION_MAPPING,
                  MODEL_FOR_PRETRAINING_MAPPING,
                  MODEL_FOR_QUESTION_ANSWERING_MAPPING,
                  MODEL_FOR_SEMANTIC_SEGMENTATION_MAPPING,
                  MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING,
                  MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
                  MODEL_FOR_SPEECH_SEQ_2_SEQ_MAPPING,
                  MODEL_FOR_TABLE_QUESTION_ANSWERING_MAPPING,
                  MODEL_FOR_TEXT_ENCODING_MAPPING,
                  MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING,
                  MODEL_FOR_UNIVERSAL_SEGMENTATION_MAPPING,
                  MODEL_FOR_VIDEO_CLASSIFICATION_MAPPING,
                  MODEL_FOR_VISION_2_SEQ_MAPPING,
                  MODEL_FOR_VISUAL_QUESTION_ANSWERING_MAPPING,
                  MODEL_FOR_ZERO_SHOT_IMAGE_CLASSIFICATION_MAPPING,
                  MODEL_FOR_ZERO_SHOT_OBJECT_DETECTION_MAPPING,
                  MODEL_MAPPING,
                  MODEL_WITH_LM_HEAD_MAPPING,
                  AutoBackbone,
                  AutoModel,
                  AutoModelForAudioClassification,
                  AutoModelForAudioFrameClassification,
                  AutoModelForAudioXVector,
                  AutoModelForCausalLM,
                  AutoModelForCTC,
                  AutoModelForDepthEstimation,
                  AutoModelForDocumentQuestionAnswering,
                  AutoModelForImageClassification,
                  AutoModelForImageSegmentation,
                  AutoModelForInstanceSegmentation,
                  AutoModelForMaskedImageModeling,
                  AutoModelForMaskedLM,
                  AutoModelForMaskGeneration,
                  AutoModelForMultipleChoice,
                  AutoModelForNextSentencePrediction,
                  AutoModelForObjectDetection,
                  AutoModelForPreTraining,
                  AutoModelForQuestionAnswering,
                  AutoModelForSemanticSegmentation,
                  AutoModelForSeqaSeqLM,
                  AutoModelForSequenceClassification,
                  AutoModelForSpeechSeqaSeq,
                  AutoModelForTableQuestionAnswering,
                  AutoModelForTextEncoding,
                  AutoModelForTokenClassification,
                  AutoModelForUniversalSegmentation,
                  AutoModelForVideoClassification,
                  AutoModelForVisionaSeq,
                  AutoModelForVisualQuestionAnswering,
                  AutoModelForZeroShotImageClassification,
                  AutoModelForZeroShotObjectDetection,
                  AutoModelWithLMHead,
              )
  
        try:
              if not is_tf_available():
                    raise OptionalDependencyNotAvailable()
        except OptionalDependencyNotAvailable:
              pass
        else:
              from .modeling_tf_auto import (
                  TF_MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING,
                  TF_MODEL_FOR_CAUSAL_LM_MAPPING,
                  TF_MODEL_FOR_DOCUMENT_QUESTION_ANSWERING_MAPPING,
                  TF_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING,
                  TF_MODEL_FOR_MASK_GENERATION_MAPPING,
                  TF_MODEL_FOR_MASKED_IMAGE_MODELING_MAPPING,
                  TF_MODEL_FOR_MASKED_LM_MAPPING,
                  TF_MODEL_FOR_MULTIPLE_CHOICE_MAPPING,
                  TF_MODEL_FOR_NEXT_SENTENCE_PREDICTION_MAPPING,
                  TF_MODEL_FOR_PRETRAINING_MAPPING,
                  TF_MODEL_FOR_QUESTION_ANSWERING_MAPPING,
                  TF_MODEL_FOR_SEMANTIC_SEGMENTATION_MAPPING,
                  TF_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING,
                  TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
                  TF_MODEL_FOR_SPEECH_SEQ_2_SEQ_MAPPING,
                  TF_MODEL_FOR_TABLE_QUESTION_ANSWERING_MAPPING,
                  TF_MODEL_FOR_TEXT_ENCODING_MAPPING,
                  TF_MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING,
                  TF_MODEL_FOR_VISION_2_SEQ_MAPPING,
                  TF_MODEL_FOR_ZERO_SHOT_IMAGE_CLASSIFICATION_MAPPING,
                  TF_MODEL_MAPPING,
                  TF_MODEL_WITH_LM_HEAD_MAPPING,
                  TFAutoModel,
                  TFAutoModelForAudioClassification,
                  TFAutoModelForCausalLM,
                  TFAutoModelForDocumentQuestionAnswering,
                  TFAutoModelForImageClassification,
                  TFAutoModelForMaskedImageModeling,
                  TFAutoModelForMaskedLM,
                  TFAutoModelForMaskGeneration,
                  TFAutoModelForMultipleChoice,
                  TFAutoModelForNextSentencePrediction,
                  TFAutoModelForPreTraining,
                  TFAutoModelForQuestionAnswering,
                  TFAutoModelForSemanticSegmentation,
                  TFAutoModelForSeqaSeqLM,
                  TFAutoModelForSequenceClassification,
                  TFAutoModelForSpeechSeqaSeq,
                  TFAutoModelForTableQuestionAnswering,
                  TFAutoModelForTextEncoding,
                  TFAutoModelForTokenClassification,
                  TFAutoModelForVisionaSeq,
                  TFAutoModelForZeroShotImageClassification,
                  TFAutoModelWithLMHead,
              )
  
        try:
              if not is_flax_available():
                    raise OptionalDependencyNotAvailable()
        except OptionalDependencyNotAvailable:
              pass
        else:
              from .modeling_flax_auto import (
                  FLAX_MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING,
                  FLAX_MODEL_FOR_CAUSAL_LM_MAPPING,
                  FLAX_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING,
                  FLAX_MODEL_FOR_MASKED_LM_MAPPING,
                  FLAX_MODEL_FOR_MULTIPLE_CHOICE_MAPPING,
                  FLAX_MODEL_FOR_NEXT_SENTENCE_PREDICTION_MAPPING,
                  FLAX_MODEL_FOR_PRETRAINING_MAPPING,
                  FLAX_MODEL_FOR_QUESTION_ANSWERING_MAPPING,
                  FLAX_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING,
                  FLAX_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
                  FLAX_MODEL_FOR_SPEECH_SEQ_2_SEQ_MAPPING,
                  FLAX_MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING,
                  FLAX_MODEL_FOR_VISION_2_SEQ_MAPPING,
                  FLAX_MODEL_MAPPING,
                  FlaxAutoModel,
                  FlaxAutoModelForCausalLM,
                  FlaxAutoModelForImageClassification,
                  FlaxAutoModelForMaskedLM,
                  FlaxAutoModelForMultipleChoice,
                  FlaxAutoModelForNextSentencePrediction,
                  FlaxAutoModelForPreTraining,
                  FlaxAutoModelForQuestionAnswering,
                  FlaxAutoModelForSeqaSeqLM,
                  FlaxAutoModelForSequenceClassification,
                  FlaxAutoModelForSpeechSeqaSeq,
                  FlaxAutoModelForTokenClassification,
                  FlaxAutoModelForVisionaSeq,
              )
  
  else:
        import sys
  
        SCREAMING_SNAKE_CASE__		:       int   							=							_LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)
  
  
  
  
style_context: 
  
  
  
  
  
  
  import collections
  
  from .utils import ExplicitEnum, is_torch_available, logging
  
  
  if is_torch_available():
        import torch
  
  
  SCREAMING_SNAKE_CASE__		:       Any   							=							logging.get_logger(__name__)
  
  
  
  
  
  
  
  class 							UpperCAmelCase_     :
  
  
  
  
       def __init__(							self  ,	_lowerCAmelCase  ,	_lowerCAmelCase=21  ,	_lowerCAmelCase=[]  ,	_lowerCAmelCase=None		):
            UpperCAmelCase__			:     Union[str, Any]										= model
            UpperCAmelCase__			:     Union[str, Any]										= trace_batch_nums
            UpperCAmelCase__			:     Optional[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
            UpperCAmelCase__			:     int										= collections.deque([]  ,	_lowerCAmelCase		)
            UpperCAmelCase__			:     str										= []
            UpperCAmelCase__			:     Optional[int]										= 0
            UpperCAmelCase__			:     int										= 0
            UpperCAmelCase__			:     int										= False
            UpperCAmelCase__			:     List[str]										= """                 """
  
            self.analyse_model()
  
            self.register_forward_hook()
  
  
  
  
       def      __UpperCAmelCase     (							self  ,	_lowerCAmelCase=None		):
            if frame is not None:
                 self.expand_frame(_lowerCAmelCase		)
            self.frames.append("""\n""".join(self.frame		)		)
            UpperCAmelCase__			:     str										= []  # start a new frame
  
  
  
  
       def      __UpperCAmelCase     (							self  ,	_lowerCAmelCase		):
            self.frame.append(_lowerCAmelCase		)
  
  
  
  
       def      __UpperCAmelCase     (							self		):
            print("""\n""".join(self.frames		)		)
            UpperCAmelCase__			:     List[Any]										= []
  
  
  
  
       def      __UpperCAmelCase     (							self		):
            UpperCAmelCase__			:     Optional[int]										= []
  
  
  
  
       def      __UpperCAmelCase     (							self		):
            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"""		)
            UpperCAmelCase__			:     Any										= []
  
  
  
  
       def      __UpperCAmelCase     (							self		):
            # extract the fully qualified module names, to be able to report at run time. e.g.:
            # encoder.block.2.layer.0.SelfAttention.o
            #
            # for shared weights only the first shared module name will be registered
            UpperCAmelCase__			:     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      __UpperCAmelCase     (							self  ,	_lowerCAmelCase  ,	_lowerCAmelCase		):
            if torch.is_tensor(_lowerCAmelCase		):
                 self.expand_frame(get_abs_min_max(_lowerCAmelCase  ,	_lowerCAmelCase		)		)
                 if detect_overflow(_lowerCAmelCase  ,	_lowerCAmelCase		):
                      UpperCAmelCase__			:     Optional[int]										= True
            elif var is None:
                 self.expand_frame(f"{'None':>17} {ctx}"		)
            else:
                 self.expand_frame(f"{'not a tensor':>17} {ctx}"		)
  
  
  
  
       def      __UpperCAmelCase     (							self		):
            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      __UpperCAmelCase     (							self		):
            self.expand_frame(f"{self.prefix} *** Finished batch number={self.batch_number-1} ***\n\n"		)
  
  
  
  
       def      __UpperCAmelCase     (							self  ,	_lowerCAmelCase  ,	_lowerCAmelCase  ,	_lowerCAmelCase		):
            self.expand_frame(f"{self.prefix} {self.module_names[module]} {module.__class__.__name__}"		)
  
            # params
            for name, p in module.named_parameters(recurse=_lowerCAmelCase		):
                 self.analyse_variable(_lowerCAmelCase  ,	_lowerCAmelCase		)
  
            # inputs
            if isinstance(_lowerCAmelCase  ,	_lowerCAmelCase		):
                 for i, x in enumerate(_lowerCAmelCase		):
                      self.analyse_variable(_lowerCAmelCase  ,	f"input[{i}]"		)
            else:
                 self.analyse_variable(_lowerCAmelCase  ,	"""input"""		)
  
            # outputs
            if isinstance(_lowerCAmelCase  ,	_lowerCAmelCase		):
                 for i, x in enumerate(_lowerCAmelCase		):
                      # possibly a tuple of tuples
                      if isinstance(_lowerCAmelCase  ,	_lowerCAmelCase		):
                           for j, y in enumerate(_lowerCAmelCase		):
                                self.analyse_variable(_lowerCAmelCase  ,	f"output[{i}][{j}]"		)
                      else:
                           self.analyse_variable(_lowerCAmelCase  ,	f"output[{i}]"		)
            else:
                 self.analyse_variable(_lowerCAmelCase  ,	"""output"""		)
  
            self.save_frame()
  
  
  
  
       def      __UpperCAmelCase     (							self		):
            self.model.apply(self._register_forward_hook		)
  
  
  
  
       def      __UpperCAmelCase     (							self  ,	_lowerCAmelCase		):
            module.register_forward_hook(self.forward_hook		)
  
  
  
  
       def      __UpperCAmelCase     (							self  ,	_lowerCAmelCase  ,	_lowerCAmelCase  ,	_lowerCAmelCase		):
            # - input is a tuple of packed inputs (could be non-Tensors)
            # - output could be a Tensor or a tuple of Tensors and non-Tensors
  
            UpperCAmelCase__			:     Union[str, Any]										= False
  
            UpperCAmelCase__			:     List[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
                 UpperCAmelCase__			:     Dict										= True
  
            self.create_frame(_lowerCAmelCase  ,	_lowerCAmelCase  ,	_lowerCAmelCase		)
  
            # 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    _lowerCamelCase	(	__lowerCamelCase   ,       __lowerCamelCase					)   -> Optional[Any]:
  
       '''simple docstring'''
       UpperCAmelCase__			:     Dict										= var.abs()
       return F"{abs_var.min():8.2e} {abs_var.max():8.2e} {ctx}"
  
  
  
  
  
  def    _lowerCamelCase	(	__lowerCamelCase   ,       __lowerCamelCase					)   -> int:
  
       '''simple docstring'''
       UpperCAmelCase__			:     str										= False
       if torch.isnan(__lowerCamelCase					).any().item():
            UpperCAmelCase__			:     List[Any]										= True
            print(F"{ctx} has nans"					)
       if torch.isinf(__lowerCamelCase					).any().item():
            UpperCAmelCase__			:     List[str]										= True
            print(F"{ctx} has infs"					)
  
       # if needed to monitor large elements can enable the following
       if 0:  # and detected:
            UpperCAmelCase__			:     Dict										= var[torch.ge(var.abs()   ,       100					)]
            if naaa.numel() > 0:
                 print(F"{ctx}:  n100={naaa.numel()}"					)
            UpperCAmelCase__			:     Tuple										= var[torch.ge(var.abs()   ,       1000					)]
            if naaaa.numel() > 0:
                 print(F"{ctx}: n1000={naaaa.numel()}"					)
            UpperCAmelCase__			:     Optional[int]										= var[torch.ge(var.abs()   ,       1_0000					)]
            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_     (		__lowerCamelCase		):
       __lowerCamelCase										=     'underflow_overflow'
       __lowerCamelCase										=     'tpu_metrics_debug'
  
  
  
  
  
  
  