






"""simple docstring"""


import collections

from .utils import ExplicitEnum, is_torch_available, logging


if is_torch_available():
       import torch


lowercase_								=	logging.get_logger(__name__)


class    snake_case						:


   '''simple docstring'''

   def __init__(      self					:	Optional[int],			_lowerCamelCase					:	Tuple,			_lowerCamelCase					:	Dict=21,			_lowerCamelCase					:	Any=[],			_lowerCamelCase					:	Any=None    ):

     '''simple docstring'''
     __A		     =					model
     __A		     =					trace_batch_nums
     __A		     =					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
     __A		     =					collections.deque([],			_lowerCamelCase    )
     __A		     =					[]
     __A		     =					0
     __A		     =					0
     __A		     =					False
     __A		     =					'''                 '''

     self.analyse_model()

     self.register_forward_hook()


   def 							_SCREAMING_SNAKE_CASE							(      self					:	Union[str, Any],			_lowerCamelCase					:	Union[str, Any]=None    ):

     '''simple docstring'''
     if frame is not None:
       self.expand_frame(_lowerCamelCase    )
     self.frames.append('''\n'''.join(self.frame    )    )
     __A		     =					[]  # start a new frame


   def 							_SCREAMING_SNAKE_CASE							(      self					:	List[Any],			_lowerCamelCase					:	Union[str, Any]    ):

     '''simple docstring'''
     self.frame.append(_lowerCamelCase    )


   def 							_SCREAMING_SNAKE_CASE							(      self					:	List[Any]    ):

     '''simple docstring'''
     print('''\n'''.join(self.frames    )    )
     __A		     =					[]


   def 							_SCREAMING_SNAKE_CASE							(      self					:	int    ):

     '''simple docstring'''
     __A		     =					[]


   def 							_SCREAMING_SNAKE_CASE							(      self					:	Any    ):

     '''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'''    )
     __A		     =					[]


   def 							_SCREAMING_SNAKE_CASE							(      self					:	Tuple    ):

     '''simple docstring'''
     # 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
     __A		     =					{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					:	Optional[Any],			_lowerCamelCase					:	List[Any],			_lowerCamelCase					:	int    ):

     '''simple docstring'''
     if torch.is_tensor(_lowerCamelCase    ):
       self.expand_frame(get_abs_min_max(_lowerCamelCase,			_lowerCamelCase    )    )
       if detect_overflow(_lowerCamelCase,			_lowerCamelCase    ):
         __A		     =					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					:	str    ):

     '''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					:	Dict    ):

     '''simple docstring'''
     self.expand_frame(f'{self.prefix} *** Finished batch number={self.batch_number-1} ***\n\n'    )


   def 							_SCREAMING_SNAKE_CASE							(      self					:	List[str],			_lowerCamelCase					:	Union[str, Any],			_lowerCamelCase					:	Dict,			_lowerCamelCase					:	Optional[int]    ):

     '''simple docstring'''
     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 							_SCREAMING_SNAKE_CASE							(      self					:	Dict    ):

     '''simple docstring'''
     self.model.apply(self._register_forward_hook    )


   def 							_SCREAMING_SNAKE_CASE							(      self					:	Dict,			_lowerCamelCase					:	Tuple    ):

     '''simple docstring'''
     module.register_forward_hook(self.forward_hook    )






   def 							_SCREAMING_SNAKE_CASE							(      self					:	int,			_lowerCamelCase					:	str,			_lowerCamelCase					:	str,			_lowerCamelCase					:	Dict    ):

     '''simple docstring'''
     # - input is a tuple of packed inputs (could be non-Tensors)
     # - output could be a Tensor or a tuple of Tensors and non-Tensors

     __A		     =					False

     __A		     =					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
       __A		     =					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							(       __UpperCamelCase						,			__UpperCamelCase					):




  """simple docstring"""







  __A		     =					var.abs()
  return f'{abs_var.min():8.2e} {abs_var.max():8.2e} {ctx}'



def    lowerCAmelCase							(       __UpperCamelCase						,			__UpperCamelCase					):




  """simple docstring"""







  __A		     =					False
  if torch.isnan(__UpperCamelCase					).any().item():
    __A		     =					True
    print(f'{ctx} has nans'					)
  if torch.isinf(__UpperCamelCase					).any().item():
    __A		     =					True
    print(f'{ctx} has infs'					)

  # if needed to monitor large elements can enable the following
  if 0:  # and detected:
    __A		     =					var[torch.ge(var.abs()						,			1_0_0					)]
    if naaa.numel() > 0:
      print(f'{ctx}:  n100={naaa.numel()}'					)
    __A		     =					var[torch.ge(var.abs()						,			1_0_0_0					)]
    if naaaa.numel() > 0:
      print(f'{ctx}: n1000={naaaa.numel()}'					)
    __A		     =					var[torch.ge(var.abs()						,			1_0_0_0_0					)]
    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		):


   '''simple docstring'''

   A_		:      int							=					"underflow_overflow"
   A_		:      Optional[Any]							=					"tpu_metrics_debug"












"""simple docstring"""


import warnings

from ...utils import logging
from .image_processing_vilt import ViltImageProcessor


lowercase_								=	logging.get_logger(__name__)


class    snake_case						(				_lowerCAmelCase		):


   '''simple docstring'''

   def __init__(      self					:	Optional[int],			*_lowerCamelCase					:	int,			**_lowerCamelCase					:	str    ):

     '''simple docstring'''
     warnings.warn(
         '''The class ViltFeatureExtractor is deprecated and will be removed in version 5 of Transformers. Please'''
         ''' use ViltImageProcessor instead.''',			_lowerCamelCase,			)
     super().__init__(*_lowerCamelCase,			**_lowerCamelCase    )




