






import collections

from .utils import ExplicitEnum, is_torch_available, logging


if is_torch_available():
		import torch


lowerCamelCase_		  =						logging.get_logger(__name__)




class 							a_				:


							'''simple docstring'''






							def __init__(	self    ,    lowercase_    ,    lowercase_=2_1    ,    lowercase_=[]    ,    lowercase_=None     )      ->      Dict:
														'''simple docstring'''

														lowerCAmelCase_       		=  model
														lowerCAmelCase_       		=  trace_batch_nums
														lowerCAmelCase_       		=  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_       		=  collections.deque([]    ,    lowercase_     )
														lowerCAmelCase_       		=  []
														lowerCAmelCase_       		=  0
														lowerCAmelCase_       		=  0
														lowerCAmelCase_       		=  False
														lowerCAmelCase_       		=  '                 '

														self.analyse_model()

														self.register_forward_hook()

							def   _lowercase (	self    ,    lowercase_=None     )      ->      Optional[int]:
														'''simple docstring'''

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

							def   _lowercase (	self    ,    lowercase_     )      ->      List[Any]:
														'''simple docstring'''

														self.frame.append(lowercase_     )

							def   _lowercase (	self     )      ->      Any:
														'''simple docstring'''

														print('\n'.join(self.frames     )     )
														lowerCAmelCase_       		=  []

							def   _lowercase (	self     )      ->      List[Any]:
														'''simple docstring'''

														lowerCAmelCase_       		=  []

							def   _lowercase (	self     )      ->      int:
														'''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'     )
														lowerCAmelCase_       		=  []

							def   _lowercase (	self     )      ->      Union[str, Any]:
														'''simple docstring'''

														lowerCAmelCase_       		=  {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    ,    lowercase_    ,    lowercase_     )      ->      Dict:
														'''simple docstring'''

														if torch.is_tensor(lowercase_     ):
																					self.expand_frame(get_abs_min_max(lowercase_    ,    lowercase_     )     )
																					if detect_overflow(lowercase_    ,    lowercase_     ):
																												lowerCAmelCase_       		=  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     )      ->      Dict:
														'''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   _lowercase (	self     )      ->      List[Any]:
														'''simple docstring'''

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

							def   _lowercase (	self    ,    lowercase_    ,    lowercase_    ,    lowercase_     )      ->      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=lowercase_     ):
																					self.analyse_variable(lowercase_    ,    lowercase_     )

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

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

														self.save_frame()

							def   _lowercase (	self     )      ->      Dict:
														'''simple docstring'''

														self.model.apply(self._register_forward_hook     )

							def   _lowercase (	self    ,    lowercase_     )      ->      Optional[Any]:
														'''simple docstring'''

														module.register_forward_hook(self.forward_hook     )






							def   _lowercase (	self    ,    lowercase_    ,    lowercase_    ,    lowercase_     )      ->      List[Any]:
														'''simple docstring'''

														lowerCAmelCase_       		=  False

														lowerCAmelCase_       		=  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_       		=  True

														self.create_frame(lowercase_    ,    lowercase_    ,    lowercase_     )

														# 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      (		a_				,		a_			)			->    Dict:
							lowerCAmelCase_       		=  var.abs()
							return F'''{abs_var.min():8.2e} {abs_var.max():8.2e} {ctx}'''
def   lowerCamelCase      (		a_				,		a_			)			->    Optional[int]:
							lowerCAmelCase_       		=  False
							if torch.isnan(a_			).any().item():
														lowerCAmelCase_       		=  True
														print(F'''{ctx} has nans'''			)
							if torch.isinf(a_			).any().item():
														lowerCAmelCase_       		=  True
														print(F'''{ctx} has infs'''			)

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


							'''simple docstring'''






							__a:			Tuple									=					'''underflow_overflow'''
							__a:			Union[str, Any]									=					'''tpu_metrics_debug'''











import warnings

from ...processing_utils import ProcessorMixin
from ...tokenization_utils_base import BatchEncoding




class 							a_				(		a_	):


							'''simple docstring'''






							__a:			int									=					['''image_processor''', '''tokenizer''']
							__a:			int									=					'''VideoMAEImageProcessor'''
							__a:			Dict									=					('''CLIPTokenizer''', '''CLIPTokenizerFast''')

							def __init__(	self    ,    lowercase_=None    ,    lowercase_=None    ,    **lowercase_     )      ->      Optional[Any]:
														'''simple docstring'''

														lowerCAmelCase_       		=  None
														if "feature_extractor" in kwargs:
																					warnings.warn(
																					    'The `feature_extractor` argument is deprecated and will be removed in v5, use `image_processor`'
																					    ' instead.'    ,    lowercase_    ,    )
																					lowerCAmelCase_       		=  kwargs.pop('feature_extractor'     )

														lowerCAmelCase_       		=  image_processor if image_processor is not None else feature_extractor
														if image_processor is None:
																					raise ValueError('You need to specify an `image_processor`.'     )
														if tokenizer is None:
																					raise ValueError('You need to specify a `tokenizer`.'     )

														super().__init__(lowercase_    ,    lowercase_     )
														lowerCAmelCase_       		=  self.image_processor

							def __call__(	self    ,    lowercase_=None    ,    lowercase_=None    ,    lowercase_=None    ,    **lowercase_     )      ->      Optional[int]:
														'''simple docstring'''

														if text is None and videos is None:
																					raise ValueError('You have to specify either text or videos. Both cannot be none.'     )

														if text is not None:
																					lowerCAmelCase_       		=  self.tokenizer(lowercase_    ,    return_tensors=lowercase_    ,    **lowercase_     )

														if videos is not None:
																					lowerCAmelCase_       		=  self.image_processor(lowercase_    ,    return_tensors=lowercase_    ,    **lowercase_     )

														if text is not None and videos is not None:
																					lowerCAmelCase_       		=  image_features.pixel_values
																					return encoding
														elif text is not None:
																					return encoding
														else:
																					return BatchEncoding(data=dict(**lowercase_     )    ,    tensor_type=lowercase_     )

							def   _lowercase (	self    ,    *lowercase_    ,    **lowercase_     )      ->      Union[str, Any]:
														'''simple docstring'''

														return self.tokenizer.batch_decode(*lowercase_    ,    **lowercase_     )

							def   _lowercase (	self    ,    *lowercase_    ,    **lowercase_     )      ->      str:
														'''simple docstring'''

														return self.tokenizer.decode(*lowercase_    ,    **lowercase_     )

							@property
							def   _lowercase (	self     )      ->      Any:
														'''simple docstring'''

														return ["input_ids", "attention_mask", "position_ids", "pixel_values"]

							@property
							def   _lowercase (	self     )      ->      List[str]:
														'''simple docstring'''

														warnings.warn(
														    '`feature_extractor_class` is deprecated and will be removed in v5. Use `image_processor_class` instead.'    ,    lowercase_    ,    )
														return self.image_processor_class






							@property
							def   _lowercase (	self     )      ->      int:
														'''simple docstring'''

														warnings.warn(
														    '`feature_extractor` is deprecated and will be removed in v5. Use `image_processor` instead.'    ,    lowercase_    ,    )
														return self.image_processor



