code: 
  
  
  
  
  
  '''simple docstring'''
  
  
  
  
  
  
  
  import collections
  
  from .utils import ExplicitEnum, is_torch_available, logging
  
  
  if is_torch_available():
  	import torch
  
  
  _a      :				Any											=					logging.get_logger(__name__)
  
  
  
  
  
  class 					_UpperCAmelCase							:
  		def __init__(						self,__SCREAMING_SNAKE_CASE,__SCREAMING_SNAKE_CASE=21,__SCREAMING_SNAKE_CASE=[],__SCREAMING_SNAKE_CASE=None    ):
  
  
  
  					'''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([],__SCREAMING_SNAKE_CASE    )
  					__lowerCAmelCase      		=       []
  					__lowerCAmelCase      		=       0
  					__lowerCAmelCase      		=       0
  					__lowerCAmelCase      		=       False
  					__lowerCAmelCase      		=       """                 """
  
  					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    )    )
  					__lowerCAmelCase      		=       []  # 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    )    )
  					__lowerCAmelCase      		=       []
  		def 						lowerCamelCase__    (						self    ):
  
  
  
  					'''simple docstring'''
  
  					__lowerCAmelCase      		=       []
  		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"""    )
  					__lowerCAmelCase      		=       []
  		def 						lowerCamelCase__    (						self    ):
  
  
  
  					'''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 						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    ):
  											__lowerCAmelCase      		=       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'''
  
  					__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(__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      _lowerCAmelCase		(		lowercase      ,			lowercase			)      ->      Optional[Any]:
  			__lowerCAmelCase      		=       var.abs()
  			return f'{abs_var.min():8.2e} {abs_var.max():8.2e} {ctx}'
  
  
  
  
  
  def      _lowerCAmelCase		(		lowercase      ,			lowercase			)      ->      int:
  			__lowerCAmelCase      		=       False
  			if torch.isnan(lowercase			).any().item():
  						__lowerCAmelCase      		=       True
  						print(f'{ctx} has nans'			)
  			if torch.isinf(lowercase			).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()      ,			1000			)]
  						if naaaa.numel() > 0:
  									print(f'{ctx}: n1000={naaaa.numel()}'			)
  						__lowerCAmelCase      		=       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_     ):
  		a     :     str     						="""underflow_overflow"""
  		a     :     List[Any]     						="""tpu_metrics_debug"""
  
  
style_context: 
  
  
  
  
  
  '''simple docstring'''
  
  
  
  
  
  
  
  from cva import destroyAllWindows, imread, imshow, waitKey
  
  
  
  
  
  def      _lowerCAmelCase		(		lowercase      ,			lowercase			)      ->      int:
  			__lowerCAmelCase		, __lowerCAmelCase      		=       img.shape[0], img.shape[1]
  
  			def to_grayscale(lowercase      ,			lowercase      ,			lowercase			):
  						return 0.21_26 * red + 0.5_87 * green + 0.1_14 * blue
  
  			def normalize(lowercase			):
  						return min(lowercase      ,			255			)
  
  			for i in range(lowercase			):
  						for j in range(lowercase			):
  									__lowerCAmelCase      		=       int(to_grayscale(*img[i][j]			)			)
  									__lowerCAmelCase      		=       [
  									    normalize(lowercase			),
  									    normalize(greyscale + factor			),
  									    normalize(greyscale + 2 * factor			),
  									]
  
  			return img
  
  
  if __name__ == "__main__":
  	# read original image
  	_a      :				Any											=					{
  	    percentage: imread("""image_data/lena.jpg""", 1) for percentage in (1_0, 2_0, 3_0, 4_0)
  	}
  
  	for percentage, img in images.items():
  		make_sepia(img, percentage)
  
  	for percentage, img in images.items():
  		imshow(f'Original image with sepia (factor: {percentage})', img)
  
  	waitKey(0)
  	destroyAllWindows()
  
  