






import os
from shutil import copyfile
from typing import Any, Dict, List, Optional, Tuple

import sentencepiece as spm

from ...tokenization_utils import AddedToken, BatchEncoding, PreTrainedTokenizer
from ...utils import logging


a_							=    logging.get_logger(__name__)

a_							=    '''▁'''

a_							=    {'''vocab_file''': '''sentencepiece.bpe.model'''}

a_							=    {
    '''vocab_file''': {
        '''facebook/nllb-200-distilled-600M''': (
            '''https://huggingface.co/facebook/nllb-200-distilled-600M/blob/main/sentencepiece.bpe.model'''
        ),
    }
}

a_							=    {
    '''facebook/nllb-200-distilled-600M''': 1024,
}

# fmt: off
a_							=    ['''ace_Arab''', '''ace_Latn''', '''acm_Arab''', '''acq_Arab''', '''aeb_Arab''', '''afr_Latn''', '''ajp_Arab''', '''aka_Latn''', '''amh_Ethi''', '''apc_Arab''', '''arb_Arab''', '''ars_Arab''', '''ary_Arab''', '''arz_Arab''', '''asm_Beng''', '''ast_Latn''', '''awa_Deva''', '''ayr_Latn''', '''azb_Arab''', '''azj_Latn''', '''bak_Cyrl''', '''bam_Latn''', '''ban_Latn''', '''bel_Cyrl''', '''bem_Latn''', '''ben_Beng''', '''bho_Deva''', '''bjn_Arab''', '''bjn_Latn''', '''bod_Tibt''', '''bos_Latn''', '''bug_Latn''', '''bul_Cyrl''', '''cat_Latn''', '''ceb_Latn''', '''ces_Latn''', '''cjk_Latn''', '''ckb_Arab''', '''crh_Latn''', '''cym_Latn''', '''dan_Latn''', '''deu_Latn''', '''dik_Latn''', '''dyu_Latn''', '''dzo_Tibt''', '''ell_Grek''', '''eng_Latn''', '''epo_Latn''', '''est_Latn''', '''eus_Latn''', '''ewe_Latn''', '''fao_Latn''', '''pes_Arab''', '''fij_Latn''', '''fin_Latn''', '''fon_Latn''', '''fra_Latn''', '''fur_Latn''', '''fuv_Latn''', '''gla_Latn''', '''gle_Latn''', '''glg_Latn''', '''grn_Latn''', '''guj_Gujr''', '''hat_Latn''', '''hau_Latn''', '''heb_Hebr''', '''hin_Deva''', '''hne_Deva''', '''hrv_Latn''', '''hun_Latn''', '''hye_Armn''', '''ibo_Latn''', '''ilo_Latn''', '''ind_Latn''', '''isl_Latn''', '''ita_Latn''', '''jav_Latn''', '''jpn_Jpan''', '''kab_Latn''', '''kac_Latn''', '''kam_Latn''', '''kan_Knda''', '''kas_Arab''', '''kas_Deva''', '''kat_Geor''', '''knc_Arab''', '''knc_Latn''', '''kaz_Cyrl''', '''kbp_Latn''', '''kea_Latn''', '''khm_Khmr''', '''kik_Latn''', '''kin_Latn''', '''kir_Cyrl''', '''kmb_Latn''', '''kon_Latn''', '''kor_Hang''', '''kmr_Latn''', '''lao_Laoo''', '''lvs_Latn''', '''lij_Latn''', '''lim_Latn''', '''lin_Latn''', '''lit_Latn''', '''lmo_Latn''', '''ltg_Latn''', '''ltz_Latn''', '''lua_Latn''', '''lug_Latn''', '''luo_Latn''', '''lus_Latn''', '''mag_Deva''', '''mai_Deva''', '''mal_Mlym''', '''mar_Deva''', '''min_Latn''', '''mkd_Cyrl''', '''plt_Latn''', '''mlt_Latn''', '''mni_Beng''', '''khk_Cyrl''', '''mos_Latn''', '''mri_Latn''', '''zsm_Latn''', '''mya_Mymr''', '''nld_Latn''', '''nno_Latn''', '''nob_Latn''', '''npi_Deva''', '''nso_Latn''', '''nus_Latn''', '''nya_Latn''', '''oci_Latn''', '''gaz_Latn''', '''ory_Orya''', '''pag_Latn''', '''pan_Guru''', '''pap_Latn''', '''pol_Latn''', '''por_Latn''', '''prs_Arab''', '''pbt_Arab''', '''quy_Latn''', '''ron_Latn''', '''run_Latn''', '''rus_Cyrl''', '''sag_Latn''', '''san_Deva''', '''sat_Beng''', '''scn_Latn''', '''shn_Mymr''', '''sin_Sinh''', '''slk_Latn''', '''slv_Latn''', '''smo_Latn''', '''sna_Latn''', '''snd_Arab''', '''som_Latn''', '''sot_Latn''', '''spa_Latn''', '''als_Latn''', '''srd_Latn''', '''srp_Cyrl''', '''ssw_Latn''', '''sun_Latn''', '''swe_Latn''', '''swh_Latn''', '''szl_Latn''', '''tam_Taml''', '''tat_Cyrl''', '''tel_Telu''', '''tgk_Cyrl''', '''tgl_Latn''', '''tha_Thai''', '''tir_Ethi''', '''taq_Latn''', '''taq_Tfng''', '''tpi_Latn''', '''tsn_Latn''', '''tso_Latn''', '''tuk_Latn''', '''tum_Latn''', '''tur_Latn''', '''twi_Latn''', '''tzm_Tfng''', '''uig_Arab''', '''ukr_Cyrl''', '''umb_Latn''', '''urd_Arab''', '''uzn_Latn''', '''vec_Latn''', '''vie_Latn''', '''war_Latn''', '''wol_Latn''', '''xho_Latn''', '''ydd_Hebr''', '''yor_Latn''', '''yue_Hant''', '''zho_Hans''', '''zho_Hant''', '''zul_Latn''']


class      lowercase__     (			_UpperCAmelCase	):
	a_         =VOCAB_FILES_NAMES
	a_         =PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
	a_         =PRETRAINED_VOCAB_FILES_MAP
	a_         =["""input_ids""", """attention_mask"""]

	a_         =[]
	a_         =[]

	def __init__(							self		,    __UpperCAmelCase		,    __UpperCAmelCase="<s>"		,    __UpperCAmelCase="</s>"		,    __UpperCAmelCase="</s>"		,    __UpperCAmelCase="<s>"		,    __UpperCAmelCase="<unk>"		,    __UpperCAmelCase="<pad>"		,    __UpperCAmelCase="<mask>"		,    __UpperCAmelCase=None		,    __UpperCAmelCase=None		,    __UpperCAmelCase=None		,    __UpperCAmelCase = None		,    __UpperCAmelCase=None		,    __UpperCAmelCase=False		,    **__UpperCAmelCase		,    )->					Optional[int]:







							'''simple docstring'''





							lowerCAmelCase__       =						AddedToken(__UpperCAmelCase		,    lstrip=__UpperCAmelCase		,    rstrip=__UpperCAmelCase       ) if isinstance(__UpperCAmelCase		,    __UpperCAmelCase       ) else mask_token

							lowerCAmelCase__       =						{} if sp_model_kwargs is None else sp_model_kwargs
							lowerCAmelCase__       =						legacy_behaviour

							super().__init__(
							    bos_token=__UpperCAmelCase		,    eos_token=__UpperCAmelCase		,    unk_token=__UpperCAmelCase		,    sep_token=__UpperCAmelCase		,    cls_token=__UpperCAmelCase		,    pad_token=__UpperCAmelCase		,    mask_token=__UpperCAmelCase		,    tokenizer_file=__UpperCAmelCase		,    src_lang=__UpperCAmelCase		,    tgt_lang=__UpperCAmelCase		,    additional_special_tokens=__UpperCAmelCase		,    sp_model_kwargs=self.sp_model_kwargs		,    legacy_behaviour=__UpperCAmelCase		,    **__UpperCAmelCase		,    )

							lowerCAmelCase__       =						spm.SentencePieceProcessor(**self.sp_model_kwargs       )
							self.sp_model.Load(str(__UpperCAmelCase       )       )
							lowerCAmelCase__       =						vocab_file
							# Original fairseq vocab and spm vocab must be "aligned":
							# Vocab    |    0    |    1    |   2    |    3    |  4   |  5   |  6   |   7  |   8  |  9
							# -------- | ------- | ------- | ------ | ------- | ---- | ---- | ---- | ---- | ---- | ----
							# fairseq  | '<s>'   | '<pad>' | '</s>' | '<unk>' | 'an' | '▁n' | '▁m' | '▁t' | '▁k' | '▁a'
							# spm      | '<unk>' | '<s>'   | '</s>' | 'an'    | '▁n' | '▁m' | '▁t' | '▁k' | '▁a' | '▁s'

							# Mimic fairseq token-to-id alignment for the first 4 token
							lowerCAmelCase__       =						{"<s>": 0, "<pad>": 1, "</s>": 2, "<unk>": 3}

							# The first "real" token "," has position 4 in the original fairseq vocab and position 3 in the spm vocab
							lowerCAmelCase__       =						1

							lowerCAmelCase__       =						len(self.sp_model       )
							lowerCAmelCase__       =						{
							    code: self.sp_model_size + i + self.fairseq_offset for i, code in enumerate(__UpperCAmelCase       )
							}
							lowerCAmelCase__       =						{v: k for k, v in self.lang_code_to_id.items()}
							lowerCAmelCase__       =						len(self.sp_model       ) + len(self.lang_code_to_id       ) + self.fairseq_offset

							self.fairseq_tokens_to_ids.update(self.lang_code_to_id       )
							lowerCAmelCase__       =						{v: k for k, v in self.fairseq_tokens_to_ids.items()}
							lowerCAmelCase__       =						list(self.lang_code_to_id.keys()       )

							if additional_special_tokens is not None:
													# Only add those special tokens if they are not already there.
													self._additional_special_tokens.extend(
													    [t for t in additional_special_tokens if t not in self._additional_special_tokens]       )

							lowerCAmelCase__       =						src_lang if src_lang is not None else "eng_Latn"
							lowerCAmelCase__       =						self.lang_code_to_id[self._src_lang]
							lowerCAmelCase__       =						tgt_lang
							self.set_src_lang_special_tokens(self._src_lang       )

	def __getstate__(							self       )->					List[str]:







							'''simple docstring'''





							lowerCAmelCase__       =						self.__dict__.copy()
							lowerCAmelCase__       =						None
							lowerCAmelCase__       =						self.sp_model.serialized_model_proto()
							return state

	def __setstate__(							self		,    __UpperCAmelCase       )->					Optional[int]:







							'''simple docstring'''





							lowerCAmelCase__       =						d

							# for backward compatibility
							if not hasattr(self		,    "sp_model_kwargs"       ):
													lowerCAmelCase__       =						{}

							lowerCAmelCase__       =						spm.SentencePieceProcessor(**self.sp_model_kwargs       )
							self.sp_model.LoadFromSerializedProto(self.sp_model_proto       )

	@property
	def 		UpperCAmelCase  (							self       )->					List[str]:







							'''simple docstring'''





							return len(self.sp_model       ) + len(self.lang_code_to_id       ) + self.fairseq_offset + 1  # Plus 1 for the mask token

	@property
	def 		UpperCAmelCase  (							self       )->					str:







							'''simple docstring'''





							return self._src_lang

	@src_lang.setter
	def 		UpperCAmelCase  (							self		,    __UpperCAmelCase       )->					None:







							'''simple docstring'''





							lowerCAmelCase__       =						new_src_lang
							self.set_src_lang_special_tokens(self._src_lang       )

	def 		UpperCAmelCase  (							self		,    __UpperCAmelCase		,    __UpperCAmelCase = None		,    __UpperCAmelCase = False       )->					List[int]:







							'''simple docstring'''





							if already_has_special_tokens:
													return super().get_special_tokens_mask(
													    token_ids_a=__UpperCAmelCase		,    token_ids_a=__UpperCAmelCase		,    already_has_special_tokens=__UpperCAmelCase       )

							lowerCAmelCase__       =						[1] * len(self.prefix_tokens       )
							lowerCAmelCase__       =						[1] * len(self.suffix_tokens       )
							if token_ids_a is None:
													return prefix_ones + ([0] * len(__UpperCAmelCase       )) + suffix_ones
							return prefix_ones + ([0] * len(__UpperCAmelCase       )) + ([0] * len(__UpperCAmelCase       )) + suffix_ones

	def 		UpperCAmelCase  (							self		,    __UpperCAmelCase		,    __UpperCAmelCase = None       )->					List[int]:







							'''simple docstring'''





							if token_ids_a is None:
													return self.prefix_tokens + token_ids_a + self.suffix_tokens
							# We don't expect to process pairs, but leave the pair logic for API consistency
							return self.prefix_tokens + token_ids_a + token_ids_a + self.suffix_tokens

	def 		UpperCAmelCase  (							self		,    __UpperCAmelCase		,    __UpperCAmelCase = None       )->					List[int]:







							'''simple docstring'''





							lowerCAmelCase__       =						[self.sep_token_id]
							lowerCAmelCase__       =						[self.cls_token_id]

							if token_ids_a is None:
													return len(cls + token_ids_a + sep       ) * [0]
							return len(cls + token_ids_a + sep + sep + token_ids_a + sep       ) * [0]

	def 		UpperCAmelCase  (							self		,    __UpperCAmelCase		,    __UpperCAmelCase		,    __UpperCAmelCase		,    __UpperCAmelCase		,    **__UpperCAmelCase       )->					Optional[Any]:







							'''simple docstring'''





							if src_lang is None or tgt_lang is None:
													raise ValueError("Translation requires a `src_lang` and a `tgt_lang` for this model"       )
							lowerCAmelCase__       =						src_lang
							lowerCAmelCase__       =						self(__UpperCAmelCase		,    add_special_tokens=__UpperCAmelCase		,    return_tensors=__UpperCAmelCase		,    **__UpperCAmelCase       )
							lowerCAmelCase__       =						self.convert_tokens_to_ids(__UpperCAmelCase       )
							lowerCAmelCase__       =						tgt_lang_id
							return inputs

	def 		UpperCAmelCase  (							self       )->					Any:







							'''simple docstring'''





							lowerCAmelCase__       =						{self.convert_ids_to_tokens(__UpperCAmelCase       ): i for i in range(self.vocab_size       )}
							vocab.update(self.added_tokens_encoder       )
							return vocab

	def 		UpperCAmelCase  (							self		,    __UpperCAmelCase       )->					List[str]:







							'''simple docstring'''





							return self.sp_model.encode(__UpperCAmelCase		,    out_type=__UpperCAmelCase       )

	def 		UpperCAmelCase  (							self		,    __UpperCAmelCase       )->					Optional[Any]:







							'''simple docstring'''





							if token in self.fairseq_tokens_to_ids:
													return self.fairseq_tokens_to_ids[token]
							lowerCAmelCase__       =						self.sp_model.PieceToId(__UpperCAmelCase       )

							# Need to return unknown token if the SP model returned 0
							return spm_id + self.fairseq_offset if spm_id else self.unk_token_id

	def 		UpperCAmelCase  (							self		,    __UpperCAmelCase       )->					Dict:







							'''simple docstring'''





							if index in self.fairseq_ids_to_tokens:
													return self.fairseq_ids_to_tokens[index]
							return self.sp_model.IdToPiece(index - self.fairseq_offset       )

	def 		UpperCAmelCase  (							self		,    __UpperCAmelCase       )->					Optional[int]:







							'''simple docstring'''





							lowerCAmelCase__       =						"".join(__UpperCAmelCase       ).replace(__UpperCAmelCase		,    " "       ).strip()
							return out_string

	def 		UpperCAmelCase  (							self		,    __UpperCAmelCase		,    __UpperCAmelCase = None       )->					Tuple[str]:







							'''simple docstring'''





							if not os.path.isdir(__UpperCAmelCase       ):
													logger.error(F"Vocabulary path ({save_directory}) should be a directory"       )
													return
							lowerCAmelCase__       =						os.path.join(
							    __UpperCAmelCase		,    (filename_prefix + "-" if filename_prefix else "") + VOCAB_FILES_NAMES["vocab_file"]       )

							if os.path.abspath(self.vocab_file       ) != os.path.abspath(__UpperCAmelCase       ) and os.path.isfile(self.vocab_file       ):
													copyfile(self.vocab_file		,    __UpperCAmelCase       )
							elif not os.path.isfile(self.vocab_file       ):
													with open(__UpperCAmelCase		,    "wb"       ) as fi:
																			lowerCAmelCase__       =						self.sp_model.serialized_model_proto()
																			fi.write(__UpperCAmelCase       )

							return (out_vocab_file,)

	def 		UpperCAmelCase  (							self		,    __UpperCAmelCase		,    __UpperCAmelCase = "eng_Latn"		,    __UpperCAmelCase = None		,    __UpperCAmelCase = "fra_Latn"		,    **__UpperCAmelCase		,    )->					BatchEncoding:







							'''simple docstring'''





							lowerCAmelCase__       =						src_lang
							lowerCAmelCase__       =						tgt_lang
							return super().prepare_seqaseq_batch(__UpperCAmelCase		,    __UpperCAmelCase		,    **__UpperCAmelCase       )

	def 		UpperCAmelCase  (							self       )->					Any:







							'''simple docstring'''





							return self.set_src_lang_special_tokens(self.src_lang       )

	def 		UpperCAmelCase  (							self       )->					str:







							'''simple docstring'''





							return self.set_tgt_lang_special_tokens(self.tgt_lang       )

	def 		UpperCAmelCase  (							self		,    __UpperCAmelCase       )->					None:







							'''simple docstring'''





							lowerCAmelCase__       =						self.lang_code_to_id[src_lang]
							if self.legacy_behaviour:
													lowerCAmelCase__       =						[]
													lowerCAmelCase__       =						[self.eos_token_id, self.cur_lang_code]
							else:
													lowerCAmelCase__       =						[self.cur_lang_code]
													lowerCAmelCase__       =						[self.eos_token_id]


	def 		UpperCAmelCase  (							self		,    __UpperCAmelCase       )->					None:







							'''simple docstring'''





							lowerCAmelCase__       =						self.lang_code_to_id[lang]
							if self.legacy_behaviour:
													lowerCAmelCase__       =						[]
													lowerCAmelCase__       =						[self.eos_token_id, self.cur_lang_code]
							else:
													lowerCAmelCase__       =						[self.cur_lang_code]
													lowerCAmelCase__       =						[self.eos_token_id]














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_							=    logging.getLogger(__name__)

a_							=    50  # max width of layer names
a_							=    70  # max width of quantizer names


def        _a  (     UpperCamelCase_					:				str   ) ->   List[str]:
						"""simple docstring"""







						lowerCAmelCase__       =						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        _a  (     UpperCamelCase_					:				int   ) ->   List[Any]:
						"""simple docstring"""







						if args.calibrator == "max":
												lowerCAmelCase__       =						"max"
						elif args.calibrator == "percentile":
												if args.percentile is None:
																		raise ValueError("Specify --percentile when using percentile calibrator"   )
												lowerCAmelCase__       =						"histogram"
						elif args.calibrator == "mse":
												lowerCAmelCase__       =						"histogram"
						else:
												raise ValueError(F"Invalid calibrator {args.calibrator}"   )

						lowerCAmelCase__       =						QuantDescriptor(num_bits=args.aprec    ,   calib_method=UpperCamelCase_   )
						lowerCAmelCase__       =						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        _a  (     UpperCamelCase_					:				Union[str, Any]    ,   UpperCamelCase_					:				List[Any]    ,   UpperCamelCase_					:				Any=False    ,   UpperCamelCase_					:				List[Any]=False   ) ->   Any:
						"""simple docstring"""







						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        _a  (     UpperCamelCase_					:				Union[str, Any]   ) ->   Tuple:
						"""simple docstring"""







						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        _a  (     UpperCamelCase_					:				Dict    ,   UpperCamelCase_					:				Tuple   ) ->   str:
						"""simple docstring"""







						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        _a  (     UpperCamelCase_					:				Optional[Any]    ,   UpperCamelCase_					:				int   ) ->   int:
						"""simple docstring"""







						def fusea(UpperCamelCase_					:				List[Any]    ,   UpperCamelCase_					:				Tuple    ,   UpperCamelCase_					:				Optional[int]   ):
												for mod in [qq, qk, qv]:
																		if not hasattr(UpperCamelCase_    ,   "_amax"   ):
																								print("          WARNING: NO AMAX BUFFER"   )
																								return
												lowerCAmelCase__       =						qq._amax.detach().item()
												lowerCAmelCase__       =						qk._amax.detach().item()
												lowerCAmelCase__       =						qv._amax.detach().item()

												lowerCAmelCase__       =						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        _a  (     UpperCamelCase_					:				Any    ,   UpperCamelCase_					:				List[Any]   ) ->   Optional[int]:
						"""simple docstring"""







						for name, mod in model.named_modules():
												if name.endswith(".output.dense"   ) and not name.endswith("attention.output.dense"   ):
																		lowerCAmelCase__       =						mod._input_quantizer._amax.data.detach().item()
																		mod._input_quantizer._amax.data.detach().clamp_(max=UpperCamelCase_   )
																		lowerCAmelCase__       =						mod._input_quantizer._amax.data.detach().item()
																		logger.info(F"CLIP_GELU: {name:{name_width}} amax: {amax_init:5.2f} -> {amax:5.2f}"   )


def        _a  (     UpperCamelCase_					:				str   ) ->   int:
						"""simple docstring"""







						for name, mod in model.named_modules():
												if hasattr(UpperCamelCase_    ,   "_weight_quantizer"   ) and mod._weight_quantizer.axis is not None:
																		lowerCAmelCase__       =						mod.weight.shape[0]
																		lowerCAmelCase__       =						mod._weight_quantizer._amax.detach()
																		lowerCAmelCase__       =						torch.ones(UpperCamelCase_    ,   dtype=amax.dtype    ,   device=amax.device   ) * amax
																		print(F"expanding {name} {amax} -> {mod._weight_quantizer._amax}"   )


def        _a  (     UpperCamelCase_					:				Any   ) ->   Optional[int]:
						"""simple docstring"""







						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__       =						set() if mod._weight_quantizer.axis is None else set(mod._weight_quantizer.axis   )
																		lowerCAmelCase__       =						set(range(len(mod.weight.size()   )   )   ) - axis_set
																		lowerCAmelCase__       =						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__       =						amax


def        _a  (     UpperCamelCase_					:				str    ,   UpperCamelCase_					:				Optional[Any]=25    ,   UpperCamelCase_					:				str=180    ,   UpperCamelCase_					:				Optional[int]=None   ) ->   Tuple:
						"""simple docstring"""







						if ignore is None:
												lowerCAmelCase__       =						[]
						elif not isinstance(UpperCamelCase_    ,   UpperCamelCase_   ):
												lowerCAmelCase__       =						[ignore]

						lowerCAmelCase__       =						0
						for name, mod in model.named_modules():
												if not hasattr(UpperCamelCase_    ,   "weight"   ):
																		continue
												lowerCAmelCase__       =						max(UpperCamelCase_    ,   len(UpperCamelCase_   )   )

						for name, mod in model.named_modules():
												lowerCAmelCase__       =						getattr(UpperCamelCase_    ,   "_input_quantizer"    ,   UpperCamelCase_   )
												lowerCAmelCase__       =						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__       =						F"Act:{input_q.extra_repr()}"
												lowerCAmelCase__       =						F"Wgt:{weight_q.extra_repr()}"
												lowerCAmelCase__       =						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        _a  (     UpperCamelCase_					:				str   ) ->   Dict:
						"""simple docstring"""







						lowerCAmelCase__       =						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        _a  (     UpperCamelCase_					:				List[str]    ,   UpperCamelCase_					:				Union[str, Any]    ,   UpperCamelCase_					:				Union[str, Any]    ,   UpperCamelCase_					:				Optional[Any]    ,   UpperCamelCase_					:				int   ) ->   Tuple:
						"""simple docstring"""







						lowerCAmelCase__       =						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        _a  (     UpperCamelCase_					:				List[Any]    ,   UpperCamelCase_					:				int    ,   UpperCamelCase_					:				Union[str, Any]="both"    ,   **UpperCamelCase_					:				Dict   ) ->   Optional[int]:
						"""simple docstring"""







						lowerCAmelCase__       =						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        _a  (     UpperCamelCase_					:				str    ,   UpperCamelCase_					:				List[Any]    ,   **UpperCamelCase_					:				Any   ) ->   Any:
						"""simple docstring"""







						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__       =						F"Warning: changing {name:{name_width}}"
																														for k, v in kwargs.items():
																																				s += F" {k}={v}"
																																				setattr(UpperCamelCase_    ,   UpperCamelCase_    ,   UpperCamelCase_   )
																														logger.info(UpperCamelCase_   )






