code: 
  
  
  
  
  """simple docstring"""
  
  import collections
  
  from .utils import ExplicitEnum, is_torch_available, logging
  
  
  if is_torch_available():
  							import torch
  
  
  __A 		=			logging.get_logger(__name__)
  class 			lowerCamelCase__    :
  
  
  			def __init__(     self				, SCREAMING_SNAKE_CASE				, SCREAMING_SNAKE_CASE=21				, SCREAMING_SNAKE_CASE=[]				, SCREAMING_SNAKE_CASE=None							):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					snake_case		:						List[Any]								=				model
  					snake_case		:						List[str]								=				trace_batch_nums
  					snake_case		:						Optional[int]								=				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
  					snake_case		:						Optional[int]								=				collections.deque([]				, SCREAMING_SNAKE_CASE							)
  					snake_case		:						Union[str, Any]								=				[]
  					snake_case		:						Dict								=				0
  					snake_case		:						Tuple								=				0
  					snake_case		:						List[str]								=				False
  					snake_case		:						Tuple								=				"                 "
  
  					self.analyse_model()
  
  					self.register_forward_hook()
  
  
  			def 							lowerCamelCase_				(     self				, SCREAMING_SNAKE_CASE=None							):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					if frame is not None:
  							self.expand_frame(SCREAMING_SNAKE_CASE							)
  					self.frames.append("\n".join(self.frame							)							)
  					snake_case		:						Optional[Any]								=				[]  # start a new frame
  
  
  			def 							lowerCamelCase_				(     self				, SCREAMING_SNAKE_CASE							):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					self.frame.append(SCREAMING_SNAKE_CASE							)
  
  
  			def 							lowerCamelCase_				(     self							):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					print("\n".join(self.frames							)							)
  					snake_case		:						List[str]								=				[]
  
  
  			def 							lowerCamelCase_				(     self							):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					snake_case		:						str								=				[]
  
  
  			def 							lowerCamelCase_				(     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"							)
  					snake_case		:						Optional[int]								=				[]
  
  
  			def 							lowerCamelCase_				(     self							):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					snake_case		:						Any								=				{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 							lowerCamelCase_				(     self				, SCREAMING_SNAKE_CASE				, SCREAMING_SNAKE_CASE							):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					if torch.is_tensor(SCREAMING_SNAKE_CASE							):
  							self.expand_frame(get_abs_min_max(SCREAMING_SNAKE_CASE				, SCREAMING_SNAKE_CASE							)							)
  							if detect_overflow(SCREAMING_SNAKE_CASE				, SCREAMING_SNAKE_CASE							):
  									snake_case		:						Optional[Any]								=				True
  					elif var is None:
  							self.expand_frame(F'''{'None':>17} {ctx}'''							)
  					else:
  							self.expand_frame(F'''{'not a tensor':>17} {ctx}'''							)
  
  
  			def 							lowerCamelCase_				(     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 							lowerCamelCase_				(     self							):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					self.expand_frame(F'''{self.prefix} *** Finished batch number={self.batch_number-1} ***\n\n'''							)
  
  
  			def 							lowerCamelCase_				(     self				, SCREAMING_SNAKE_CASE				, SCREAMING_SNAKE_CASE				, SCREAMING_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=SCREAMING_SNAKE_CASE							):
  							self.analyse_variable(SCREAMING_SNAKE_CASE				, SCREAMING_SNAKE_CASE							)
  
  					# inputs
  					if isinstance(SCREAMING_SNAKE_CASE				, SCREAMING_SNAKE_CASE							):
  							for i, x in enumerate(SCREAMING_SNAKE_CASE							):
  									self.analyse_variable(SCREAMING_SNAKE_CASE				, F'''input[{i}]'''							)
  					else:
  							self.analyse_variable(SCREAMING_SNAKE_CASE				, "input"							)
  
  					# outputs
  					if isinstance(SCREAMING_SNAKE_CASE				, SCREAMING_SNAKE_CASE							):
  							for i, x in enumerate(SCREAMING_SNAKE_CASE							):
  									# possibly a tuple of tuples
  									if isinstance(SCREAMING_SNAKE_CASE				, SCREAMING_SNAKE_CASE							):
  											for j, y in enumerate(SCREAMING_SNAKE_CASE							):
  													self.analyse_variable(SCREAMING_SNAKE_CASE				, F'''output[{i}][{j}]'''							)
  									else:
  											self.analyse_variable(SCREAMING_SNAKE_CASE				, F'''output[{i}]'''							)
  					else:
  							self.analyse_variable(SCREAMING_SNAKE_CASE				, "output"							)
  
  					self.save_frame()
  
  
  			def 							lowerCamelCase_				(     self							):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					self.model.apply(self._register_forward_hook							)
  
  
  			def 							lowerCamelCase_				(     self				, SCREAMING_SNAKE_CASE							):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					module.register_forward_hook(self.forward_hook							)
  
  
  
  			def 							lowerCamelCase_				(     self				, SCREAMING_SNAKE_CASE				, SCREAMING_SNAKE_CASE				, SCREAMING_SNAKE_CASE							):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					snake_case		:						Tuple								=				False
  
  					snake_case		:						Tuple								=				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
  							snake_case		:						Optional[Any]								=				True
  
  					self.create_frame(SCREAMING_SNAKE_CASE				, SCREAMING_SNAKE_CASE				, SCREAMING_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__     (		lowercase__  :     List[Any]       ,     lowercase__  :     List[Any]   ):
  		snake_case		:						Any								=				var.abs()
  		return F'''{abs_var.min():8.2e} {abs_var.max():8.2e} {ctx}'''
  
  
  
  def   UpperCamelCase__     (		lowercase__  :     int       ,     lowercase__  :     Optional[int]   ):
  		snake_case		:						Tuple								=				False
  		if torch.isnan(lowercase__   ).any().item():
  				snake_case		:						Optional[int]								=				True
  				print(F'''{ctx} has nans'''   )
  		if torch.isinf(lowercase__   ).any().item():
  				snake_case		:						str								=				True
  				print(F'''{ctx} has infs'''   )
  
  		# if needed to monitor large elements can enable the following
  		if 0:  # and detected:
  				snake_case		:						int								=				var[torch.ge(var.abs()       ,     100   )]
  				if naaa.numel() > 0:
  						print(F'''{ctx}:  n100={naaa.numel()}'''   )
  				snake_case		:						List[str]								=				var[torch.ge(var.abs()       ,     1000   )]
  				if naaaa.numel() > 0:
  						print(F'''{ctx}: n1000={naaaa.numel()}'''   )
  				snake_case		:						List[Any]								=				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 			lowerCamelCase__    (  lowerCamelCase_			):
  			a__ :      Dict								=     """underflow_overflow"""
  			a__ :      Any								=     """tpu_metrics_debug"""
  
  
  
  
  
style_context: 
  
  
  
  
  """simple docstring"""
  
  from ...processing_utils import ProcessorMixin
  from ...tokenization_utils_base import BatchEncoding
  class 			lowerCamelCase__    (  lowerCamelCase_			):
  			a__ :      Tuple								=     ["""image_processor""", """tokenizer"""]
  			a__ :      List[Any]								=     """EfficientNetImageProcessor"""
  			a__ :      str								=     ("""BertTokenizer""", """BertTokenizerFast""")
  
  
  			def __init__(     self				, SCREAMING_SNAKE_CASE				, SCREAMING_SNAKE_CASE							):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					super().__init__(SCREAMING_SNAKE_CASE				, SCREAMING_SNAKE_CASE							)
  
  
  			def __call__(     self				, SCREAMING_SNAKE_CASE=None				, SCREAMING_SNAKE_CASE=None				, SCREAMING_SNAKE_CASE="max_length"				, SCREAMING_SNAKE_CASE=64				, SCREAMING_SNAKE_CASE=None				, **SCREAMING_SNAKE_CASE							):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					if text is None and images is None:
  							raise ValueError("You have to specify either text or images. Both cannot be none."							)
  
  					if text is not None:
  							snake_case		:						Dict								=				self.tokenizer(
  							    SCREAMING_SNAKE_CASE				, padding=SCREAMING_SNAKE_CASE				, max_length=SCREAMING_SNAKE_CASE				, return_tensors=SCREAMING_SNAKE_CASE				, **SCREAMING_SNAKE_CASE							)
  
  					if images is not None:
  							snake_case		:						Tuple								=				self.image_processor(SCREAMING_SNAKE_CASE				, return_tensors=SCREAMING_SNAKE_CASE				, **SCREAMING_SNAKE_CASE							)
  
  					if text is not None and images is not None:
  							snake_case		:						Dict								=				image_features.pixel_values
  							return encoding
  					elif text is not None:
  							return encoding
  					else:
  							return BatchEncoding(data=dict(**SCREAMING_SNAKE_CASE							)				, tensor_type=SCREAMING_SNAKE_CASE							)
  
  
  			def 							lowerCamelCase_				(     self				, *SCREAMING_SNAKE_CASE				, **SCREAMING_SNAKE_CASE							):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					return self.tokenizer.batch_decode(*SCREAMING_SNAKE_CASE				, **SCREAMING_SNAKE_CASE							)
  
  
  			def 							lowerCamelCase_				(     self				, *SCREAMING_SNAKE_CASE				, **SCREAMING_SNAKE_CASE							):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					return self.tokenizer.decode(*SCREAMING_SNAKE_CASE				, **SCREAMING_SNAKE_CASE							)
  
  
  
  			@property
  			def 							lowerCamelCase_				(     self							):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					snake_case		:						Optional[Any]								=				self.tokenizer.model_input_names
  					snake_case		:						Any								=				self.image_processor.model_input_names
  					return list(dict.fromkeys(tokenizer_input_names + image_processor_input_names							)							)
  
  