




"""simple docstring"""
import logging
import re

import pytorch_quantization
import pytorch_quantization.nn as quant_nn
import torch
from pytorch_quantization import calib
from pytorch_quantization.tensor_quant import QuantDescriptor


a_					:     List[Any]					    =  logging.getLogger(__name__)

a_					:     Tuple					    =  50  # max width of layer names
a_					:     int					    =  70  # max width of quantizer names





def     UpperCAmelCase					(      A__:     Optional[int]  )	->  str:
			__lowerCamelCase       :						int													=					parser.add_argument_group('quant_trainer arguments'  )
			group.add_argument('--wprec'				,					type=_UpperCAmelCase				,					default=8				,					help='weight precision'  )
			group.add_argument('--aprec'				,					type=_UpperCAmelCase				,					default=8				,					help='activation precision'  )
			group.add_argument('--quant-per-tensor'				,					action='store_true'				,					help='per tensor weight scaling'  )
			group.add_argument('--quant-disable'				,					action='store_true'				,					help='disable all quantizers'  )
			group.add_argument('--quant-disable-embeddings'				,					action='store_true'				,					help='disable all embeddings quantizers'  )
			group.add_argument('--quant-disable-keyword'				,					type=_UpperCAmelCase				,					nargs='+'				,					help='disable quantizers by keyword'  )
			group.add_argument('--quant-disable-layer-module'				,					type=_UpperCAmelCase				,					help='disable quantizers by keyword under layer.'  )
			group.add_argument('--quant-enable-layer-module'				,					type=_UpperCAmelCase				,					help='enable quantizers by keyword under layer'  )
			group.add_argument('--calibrator'				,					default='max'				,					help='which quantization range calibrator to use'  )
			group.add_argument('--percentile'				,					default=_UpperCAmelCase				,					type=_UpperCAmelCase				,					help='percentile for PercentileCalibrator'  )
			group.add_argument('--fuse-qkv'				,					action='store_true'				,					help='use the same scale factor for qkv'  )
			group.add_argument('--clip-gelu'				,					metavar='N'				,					type=_UpperCAmelCase				,					help='clip gelu output maximum value to N'  )
			group.add_argument(
			    '--recalibrate-weights'				,					action='store_true'				,					help=(
			        'recalibrate weight amaxes by taking the max of the weights.'
			        ' amaxes will be computed with the current quantization granularity (axis).'
			    )				,					)





def     UpperCAmelCase					(      A__:     Union[str, Any]  )	->  List[Any]:

			if args.calibrator == "max":
						__lowerCamelCase       :						str													=					'max'
			elif args.calibrator == "percentile":
						if args.percentile is None:
									raise ValueError('Specify --percentile when using percentile calibrator'  )
						__lowerCamelCase       :						str													=					'histogram'
			elif args.calibrator == "mse":
						__lowerCamelCase       :						Union[str, Any]													=					'histogram'
			else:
						raise ValueError(f'''Invalid calibrator {args.calibrator}'''  )

			__lowerCamelCase       :						Any													=					QuantDescriptor(num_bits=args.aprec				,					calib_method=_UpperCAmelCase  )
			__lowerCamelCase       :						List[str]													=					QuantDescriptor(num_bits=args.wprec				,					axis=(None if args.quant_per_tensor else (0,))  )
			quant_nn.QuantLinear.set_default_quant_desc_input(_UpperCAmelCase  )
			quant_nn.QuantLinear.set_default_quant_desc_weight(_UpperCAmelCase  )





def     UpperCAmelCase					(      A__:     List[Any]				,					A__:     Union[str, Any]				,					A__:     Union[str, Any]=False				,					A__:     Optional[Any]=False  )	->  List[str]:
			logger.info('Configuring Model for Quantization'  )
			logger.info(f'''using quantization package {pytorch_quantization.__file__}'''  )

			if not calib:
						if args.quant_disable_embeddings:
									set_quantizer_by_name(_UpperCAmelCase				,					['embeddings']				,					which='weight'				,					_disabled=_UpperCAmelCase  )

						if args.quant_disable:
									set_quantizer_by_name(_UpperCAmelCase				,					['']				,					_disabled=_UpperCAmelCase  )

						if args.quant_disable_keyword:
									set_quantizer_by_name(_UpperCAmelCase				,					args.quant_disable_keyword				,					_disabled=_UpperCAmelCase  )

						if args.quant_disable_layer_module:
									set_quantizer_by_name(_UpperCAmelCase				,					[r'layer.\d+.' + args.quant_disable_layer_module]				,					_disabled=_UpperCAmelCase  )

						if args.quant_enable_layer_module:
									set_quantizer_by_name(_UpperCAmelCase				,					[r'layer.\d+.' + args.quant_enable_layer_module]				,					_disabled=_UpperCAmelCase  )

						if args.recalibrate_weights:
									recalibrate_weights(_UpperCAmelCase  )

						if args.fuse_qkv:
									fuse_qkv(_UpperCAmelCase				,					_UpperCAmelCase  )

			if args.clip_gelu:
						clip_gelu(_UpperCAmelCase				,					args.clip_gelu  )

			# if args.local_rank in [-1, 0] and not calib:
			print_quant_summary(_UpperCAmelCase  )





def     UpperCAmelCase					(      A__:     Optional[Any]  )	->  Union[str, Any]:
			logger.info('Enabling Calibration'  )
			for name, module in model.named_modules():
						if name.endswith('_quantizer'  ):
									if module._calibrator is not None:
												module.disable_quant()
												module.enable_calib()
									else:
												module.disable()
									logger.info(f'''{name:80}: {module}'''  )





def     UpperCAmelCase					(      A__:     List[str]				,					A__:     Any  )	->  List[Any]:
			logger.info('Loading calibrated amax'  )
			for name, module in model.named_modules():
						if name.endswith('_quantizer'  ):
									if module._calibrator is not None:
												if isinstance(module._calibrator				,					calib.MaxCalibrator  ):
															module.load_calib_amax()
												else:
															module.load_calib_amax('percentile'				,					percentile=args.percentile  )
												module.enable_quant()
												module.disable_calib()
									else:
												module.enable()
			model.cuda()
			print_quant_summary(_UpperCAmelCase  )





def     UpperCAmelCase					(      A__:     List[Any]				,					A__:     List[str]  )	->  List[str]:

			def fusea(A__:     Optional[int]				,					A__:     List[Any]				,					A__:     List[str]  ):
						for mod in [qq, qk, qv]:
									if not hasattr(_UpperCAmelCase				,					'_amax'  ):
												print('          WARNING: NO AMAX BUFFER'  )
												return
						__lowerCamelCase       :						Union[str, Any]													=					qq._amax.detach().item()
						__lowerCamelCase       :						Any													=					qk._amax.detach().item()
						__lowerCamelCase       :						Optional[int]													=					qv._amax.detach().item()

						__lowerCamelCase       :						Dict													=					max(_UpperCAmelCase				,					_UpperCAmelCase				,					_UpperCAmelCase  )
						qq._amax.fill_(_UpperCAmelCase  )
						qk._amax.fill_(_UpperCAmelCase  )
						qv._amax.fill_(_UpperCAmelCase  )
						logger.info(f'''          q={q:5.2f} k={k:5.2f} v={v:5.2f} -> {amax:5.2f}'''  )

			for name, mod in model.named_modules():
						if name.endswith('.attention.self'  ):
									logger.info(f'''FUSE_QKV: {name:{name_width}}'''  )
									fusea(mod.matmul_q_input_quantizer				,					mod.matmul_k_input_quantizer				,					mod.matmul_v_input_quantizer  )
									if args.quant_per_tensor:
												fusea(mod.query._weight_quantizer				,					mod.key._weight_quantizer				,					mod.value._weight_quantizer  )





def     UpperCAmelCase					(      A__:     Union[str, Any]				,					A__:     Dict  )	->  Optional[int]:

			for name, mod in model.named_modules():
						if name.endswith('.output.dense'  ) and not name.endswith('attention.output.dense'  ):
									__lowerCamelCase       :						Union[str, Any]													=					mod._input_quantizer._amax.data.detach().item()
									mod._input_quantizer._amax.data.detach().clamp_(max=_UpperCAmelCase  )
									__lowerCamelCase       :						int													=					mod._input_quantizer._amax.data.detach().item()
									logger.info(f'''CLIP_GELU: {name:{name_width}} amax: {amax_init:5.2f} -> {amax:5.2f}'''  )





def     UpperCAmelCase					(      A__:     str  )	->  Union[str, Any]:

			for name, mod in model.named_modules():
						if hasattr(_UpperCAmelCase				,					'_weight_quantizer'  ) and mod._weight_quantizer.axis is not None:
									__lowerCamelCase       :						Union[str, Any]													=					mod.weight.shape[0]
									__lowerCamelCase       :						int													=					mod._weight_quantizer._amax.detach()
									__lowerCamelCase       :						Dict													=					torch.ones(_UpperCAmelCase				,					dtype=amax.dtype				,					device=amax.device  ) * amax
									print(f'''expanding {name} {amax} -> {mod._weight_quantizer._amax}'''  )





def     UpperCAmelCase					(      A__:     Any  )	->  str:

			for name, mod in model.named_modules():
						if hasattr(_UpperCAmelCase				,					'_weight_quantizer'  ):
									if not hasattr(mod.weight_quantizer				,					'_amax'  ):
												print('RECALIB: {name:{name_width}} WARNING: NO AMAX BUFFER'  )
												continue

									# determine which axes to reduce across
									# e.g. a 4D tensor quantized per axis 0 should reduce over (1,2,3)
									__lowerCamelCase       :						Optional[Any]													=					set() if mod._weight_quantizer.axis is None else set(mod._weight_quantizer.axis  )
									__lowerCamelCase       :						Tuple													=					set(range(len(mod.weight.size()  )  )  ) - axis_set
									__lowerCamelCase       :						Optional[Any]													=					pytorch_quantization.utils.reduce_amax(mod.weight				,					axis=_UpperCAmelCase				,					keepdims=_UpperCAmelCase  ).detach()
									logger.info(f'''RECALIB: {name:{name_width}} {mod._weight_quantizer._amax.flatten()} -> {amax.flatten()}'''  )
									__lowerCamelCase       :						str													=					amax





def     UpperCAmelCase					(      A__:     List[Any]				,					A__:     Any=25				,					A__:     List[str]=180				,					A__:     Dict=None  )	->  List[Any]:

			if ignore is None:
						__lowerCamelCase       :						Union[str, Any]													=					[]
			elif not isinstance(_UpperCAmelCase				,					_UpperCAmelCase  ):
						__lowerCamelCase       :						Optional[Any]													=					[ignore]

			__lowerCamelCase       :						Any													=					0
			for name, mod in model.named_modules():
						if not hasattr(_UpperCAmelCase				,					'weight'  ):
									continue
						__lowerCamelCase       :						int													=					max(_UpperCAmelCase				,					len(_UpperCAmelCase  )  )

			for name, mod in model.named_modules():
						__lowerCamelCase       :						Optional[Any]													=					getattr(_UpperCAmelCase				,					'_input_quantizer'				,					_UpperCAmelCase  )
						__lowerCamelCase       :						Optional[Any]													=					getattr(_UpperCAmelCase				,					'_weight_quantizer'				,					_UpperCAmelCase  )
						if not hasattr(_UpperCAmelCase				,					'weight'  ):
									continue
						if type(_UpperCAmelCase  ) in ignore:
									continue
						if [True for s in ignore if type(_UpperCAmelCase  ) is str and s in name]:
									continue
						__lowerCamelCase       :						Optional[Any]													=					f'''Act:{input_q.extra_repr()}'''
						__lowerCamelCase       :						int													=					f'''Wgt:{weight_q.extra_repr()}'''
						__lowerCamelCase       :						Optional[Any]													=					f'''{name:{name_width}} {act_str} {wgt_str}'''
						if len(_UpperCAmelCase  ) <= line_width:
									logger.info(_UpperCAmelCase  )
						else:
									logger.info(f'''{name:{name_width}} {act_str}'''  )
									logger.info(f'''{"  ":{name_width}} {wgt_str}'''  )





def     UpperCAmelCase					(      A__:     int  )	->  str:
			__lowerCamelCase       :						List[Any]													=					0
			for name, mod in model.named_modules():
						if isinstance(_UpperCAmelCase				,					pytorch_quantization.nn.TensorQuantizer  ):
									print(f'''{name:80} {mod}'''  )
									count += 1
			print(f'''{count} TensorQuantizers found in model'''  )





def     UpperCAmelCase					(      A__:     List[str]				,					A__:     str				,					A__:     Optional[Any]				,					A__:     Optional[Any]				,					A__:     Tuple  )	->  Tuple:
			__lowerCamelCase       :						int													=					getattr(_UpperCAmelCase				,					_UpperCAmelCase				,					_UpperCAmelCase  )
			if quantizer_mod is not None:
						assert hasattr(_UpperCAmelCase				,					_UpperCAmelCase  )
						setattr(_UpperCAmelCase				,					_UpperCAmelCase				,					_UpperCAmelCase  )
			else:
						logger.warning(f'''{name} has no {quantizer}'''  )





def     UpperCAmelCase					(      A__:     Optional[Any]				,					A__:     Optional[Any]				,					A__:     Tuple="both"				,					**A__:     Optional[int]  )	->  str:
			__lowerCamelCase       :						str													=					f'''Warning: changing {which} quantizers of {name:{qname_width}}'''
			for k, v in kwargs.items():
						s += f''' {k}={v}'''
						if which in ["input", "both"]:
									set_quantizer(_UpperCAmelCase				,					_UpperCAmelCase				,					'_input_quantizer'				,					_UpperCAmelCase				,					_UpperCAmelCase  )
						if which in ["weight", "both"]:
									set_quantizer(_UpperCAmelCase				,					_UpperCAmelCase				,					'_weight_quantizer'				,					_UpperCAmelCase				,					_UpperCAmelCase  )
			logger.info(_UpperCAmelCase  )






def     UpperCAmelCase					(      A__:     List[str]				,					A__:     Tuple				,					**A__:     Optional[int]  )	->  Optional[int]:

			for name, mod in model.named_modules():
						if hasattr(_UpperCAmelCase				,					'_input_quantizer'  ) or hasattr(_UpperCAmelCase				,					'_weight_quantizer'  ):
									for n in names:
												if re.search(_UpperCAmelCase				,					_UpperCAmelCase  ):
															set_quantizers(_UpperCAmelCase				,					_UpperCAmelCase				,					**_UpperCAmelCase  )
						elif name.endswith('_quantizer'  ):
									for n in names:
												if re.search(_UpperCAmelCase				,					_UpperCAmelCase  ):
															__lowerCamelCase       :						Optional[int]													=					f'''Warning: changing {name:{name_width}}'''
															for k, v in kwargs.items():
																		s += f''' {k}={v}'''
																		setattr(_UpperCAmelCase				,					_UpperCAmelCase				,					_UpperCAmelCase  )
															logger.info(_UpperCAmelCase  )








'''simple docstring'''





import copy

from ...configuration_utils import PretrainedConfig
from ...utils import logging
from ..auto.configuration_auto import CONFIG_MAPPING


A__    :   Union[str, Any]           =					logging.get_logger(__name__)



class  snake_case__						(    SCREAMING_SNAKE_CASE_				):
 A__				= '''upernet'''
 def __init__(   self						:							Optional[int]      ,     __a						:							Dict=None      ,     __a						:							List[str]=512      ,     __a						:							int=0.0_2      ,     __a						:							Optional[Any]=[1, 2, 3, 6]      ,     __a						:							Union[str, Any]=True      ,     __a						:							Any=0.4      ,     __a						:							int=384      ,     __a						:							int=256      ,     __a						:							str=1      ,     __a						:							List[Any]=False      ,     __a						:							Dict=255      ,     **__a						:							Dict      ,     )      ->   Optional[int]:







       '''simple docstring'''
       super().__init__(**__a  )

       if backbone_config is None:
             logger.info('`backbone_config` is `None`. Initializing the config with the default `ResNet` backbone.'  )
             __snake_case :   Optional[int]													=    CONFIG_MAPPING['resnet'](out_features=['stage1', 'stage2', 'stage3', 'stage4']  )
       elif isinstance(__a      ,     __a  ):
             __snake_case :   List[Any]													=    backbone_config.get('model_type'  )
             __snake_case :   List[str]													=    CONFIG_MAPPING[backbone_model_type]
             __snake_case :   int													=    config_class.from_dict(__a  )

       __snake_case :   Any													=    backbone_config
       __snake_case :   Tuple													=    hidden_size
       __snake_case :   str													=    initializer_range
       __snake_case :   Dict													=    pool_scales
       __snake_case :   Optional[Any]													=    use_auxiliary_head
       __snake_case :   Optional[Any]													=    auxiliary_loss_weight
       __snake_case :   Optional[int]													=    auxiliary_in_channels
       __snake_case :   Dict													=    auxiliary_channels
       __snake_case :   Any													=    auxiliary_num_convs
       __snake_case :   Optional[Any]													=    auxiliary_concat_input
       __snake_case :   List[str]													=    loss_ignore_index





 def A_   (   self						:							List[Any]  )      ->   Union[str, Any]:







       '''simple docstring'''
       __snake_case :   Union[str, Any]													=    copy.deepcopy(self.__dict__  )
       __snake_case :   str													=    self.backbone_config.to_dict()
       __snake_case :   Optional[int]													=    self.__class__.model_type
       return output



