





'''simple docstring'''

import argparse
import gc
import json
import os
import shutil
import warnings

import torch

from transformers import LlamaConfig, LlamaForCausalLM, LlamaTokenizer


try:
   from transformers import LlamaTokenizerFast
except ImportError as e:
   warnings.warn(e)
   warnings.warn(
       'The converted tokenizer will be the `slow` tokenizer. To use the fast, update your `tokenizers` library and re-run the tokenizer conversion'
   )
   UpperCAmelCase					:		Any		=							None
UpperCAmelCase					:		List[str]		=							{
    '7B': 1_1_0_0_8,
    '13B': 1_3_8_2_4,
    '30B': 1_7_9_2_0,
    '65B': 2_2_0_1_6,
    '70B': 2_8_6_7_2,
}
UpperCAmelCase					:		Tuple		=							{
    '7B': 1,
    '7Bf': 1,
    '13B': 2,
    '13Bf': 2,
    '30B': 4,
    '65B': 8,
    '70B': 8,
    '70Bf': 8,
}




def    _a    (							lowerCAmelCase_			,      lowerCAmelCase_=1			,      lowerCAmelCase_=256	):





      """simple docstring"""



      return multiple_of * ((int(ffn_dim_multiplier * int(8 * n / 3	)	) + multiple_of - 1) // multiple_of)




def    _a    (							lowerCAmelCase_	):





      """simple docstring"""



      with open(lowerCAmelCase_			,      '''r'''	) as f:
            return json.load(lowerCAmelCase_	)




def    _a    (							lowerCAmelCase_			,      lowerCAmelCase_	):





      """simple docstring"""



      with open(lowerCAmelCase_			,      '''w'''	) as f:
            json.dump(lowerCAmelCase_			,      lowerCAmelCase_	)




def    _a    (							lowerCAmelCase_			,      lowerCAmelCase_			,      lowerCAmelCase_			,      lowerCAmelCase_=True	):





      """simple docstring"""



      os.makedirs(lowerCAmelCase_			,      exist_ok=lowerCAmelCase_	)
      _snake_case		:	Tuple					     =     os.path.join(lowerCAmelCase_			,      '''tmp'''	)
      os.makedirs(lowerCAmelCase_			,      exist_ok=lowerCAmelCase_	)

      _snake_case		:	Optional[Any]					     =     read_json(os.path.join(lowerCAmelCase_			,      '''params.json'''	)	)
      _snake_case		:	Optional[int]					     =     NUM_SHARDS[model_size]
      _snake_case		:	Tuple					     =     params['''n_layers''']
      _snake_case		:	str					     =     params['''n_heads''']
      _snake_case		:	Optional[Any]					     =     n_heads // num_shards
      _snake_case		:	Any					     =     params['''dim''']
      _snake_case		:	Any					     =     dim // n_heads
      _snake_case		:	Union[str, Any]					     =     10_000.0
      _snake_case		:	int					     =     1.0 / (base ** (torch.arange(0			,      lowerCAmelCase_			,      2	).float() / dims_per_head))

      if "n_kv_heads" in params:
            _snake_case		:	str					     =     params['''n_kv_heads''']  # for GQA / MQA
            _snake_case		:	Optional[int]					     =     n_heads_per_shard // num_key_value_heads
            _snake_case		:	Optional[Any]					     =     dim // num_key_value_heads
      else:  # compatibility with other checkpoints
            _snake_case		:	Any					     =     n_heads
            _snake_case		:	List[Any]					     =     n_heads_per_shard
            _snake_case		:	List[Any]					     =     dim

      # permute for sliced rotary
      def permute(lowerCAmelCase_			,      lowerCAmelCase_=n_heads			,      lowerCAmelCase_=dim			,      lowerCAmelCase_=dim	):
            return w.view(lowerCAmelCase_			,      dima // n_heads // 2			,      2			,      lowerCAmelCase_	).transpose(1			,      2	).reshape(lowerCAmelCase_			,      lowerCAmelCase_	)

      print(f'''Fetching all parameters from the checkpoint at {input_base_path}.'''	)
      # Load weights
      if model_size == "7B":
            # Not sharded
            # (The sharded implementation would also work, but this is simpler.)
            _snake_case		:	List[str]					     =     torch.load(os.path.join(lowerCAmelCase_			,      '''consolidated.00.pth'''	)			,      map_location='''cpu'''	)
      else:
            # Sharded
            _snake_case		:	Any					     =     [
                torch.load(os.path.join(lowerCAmelCase_			,      f'''consolidated.{i:02d}.pth'''	)			,      map_location='''cpu'''	)
                for i in range(lowerCAmelCase_	)
            ]
      _snake_case		:	Dict					     =     0
      _snake_case		:	Optional[Any]					     =     {'''weight_map''': {}}
      for layer_i in range(lowerCAmelCase_	):
            _snake_case		:	int					     =     f'''pytorch_model-{layer_i + 1}-of-{n_layers + 1}.bin'''
            if model_size == "7B":
                  # Unsharded
                  _snake_case		:	List[str]					     =     {
                      f'''model.layers.{layer_i}.self_attn.q_proj.weight''': permute(
                          loaded[f'''layers.{layer_i}.attention.wq.weight''']	),
                      f'''model.layers.{layer_i}.self_attn.k_proj.weight''': permute(
                          loaded[f'''layers.{layer_i}.attention.wk.weight''']	),
                      f'''model.layers.{layer_i}.self_attn.v_proj.weight''': loaded[f'''layers.{layer_i}.attention.wv.weight'''],
                      f'''model.layers.{layer_i}.self_attn.o_proj.weight''': loaded[f'''layers.{layer_i}.attention.wo.weight'''],
                      f'''model.layers.{layer_i}.mlp.gate_proj.weight''': loaded[f'''layers.{layer_i}.feed_forward.w1.weight'''],
                      f'''model.layers.{layer_i}.mlp.down_proj.weight''': loaded[f'''layers.{layer_i}.feed_forward.w2.weight'''],
                      f'''model.layers.{layer_i}.mlp.up_proj.weight''': loaded[f'''layers.{layer_i}.feed_forward.w3.weight'''],
                      f'''model.layers.{layer_i}.input_layernorm.weight''': loaded[f'''layers.{layer_i}.attention_norm.weight'''],
                      f'''model.layers.{layer_i}.post_attention_layernorm.weight''': loaded[f'''layers.{layer_i}.ffn_norm.weight'''],
                  }
            else:
                  # Sharded
                  # Note that attention.w{q,k,v,o}, feed_fordward.w[1,2,3], attention_norm.weight and ffn_norm.weight share
                  # the same storage object, saving attention_norm and ffn_norm will save other weights too, which is
                  # redundant as other weights will be stitched from multiple shards. To avoid that, they are cloned.

                  _snake_case		:	str					     =     {
                      f'''model.layers.{layer_i}.input_layernorm.weight''': loaded[0][
                          f'''layers.{layer_i}.attention_norm.weight'''
                      ].clone(),
                      f'''model.layers.{layer_i}.post_attention_layernorm.weight''': loaded[0][
                          f'''layers.{layer_i}.ffn_norm.weight'''
                      ].clone(),
                  }
                  _snake_case		:	int					     =     permute(
                      torch.cat(
                          [
                              loaded[i][f'''layers.{layer_i}.attention.wq.weight'''].view(lowerCAmelCase_			,      lowerCAmelCase_			,      lowerCAmelCase_	)
                              for i in range(lowerCAmelCase_	)
                          ]			,      dim=0			,      ).reshape(lowerCAmelCase_			,      lowerCAmelCase_	)	)
                  _snake_case		:	Any					     =     permute(
                      torch.cat(
                          [
                              loaded[i][f'''layers.{layer_i}.attention.wk.weight'''].view(
                                  lowerCAmelCase_			,      lowerCAmelCase_			,      lowerCAmelCase_	)
                              for i in range(lowerCAmelCase_	)
                          ]			,      dim=0			,      ).reshape(lowerCAmelCase_			,      lowerCAmelCase_	)			,      lowerCAmelCase_			,      lowerCAmelCase_			,      lowerCAmelCase_			,      )
                  _snake_case		:	str					     =     torch.cat(
                      [
                          loaded[i][f'''layers.{layer_i}.attention.wv.weight'''].view(
                              lowerCAmelCase_			,      lowerCAmelCase_			,      lowerCAmelCase_	)
                          for i in range(lowerCAmelCase_	)
                      ]			,      dim=0			,      ).reshape(lowerCAmelCase_			,      lowerCAmelCase_	)

                  _snake_case		:	Union[str, Any]					     =     torch.cat(
                      [loaded[i][f'''layers.{layer_i}.attention.wo.weight'''] for i in range(lowerCAmelCase_	)]			,      dim=1	)
                  _snake_case		:	Optional[Any]					     =     torch.cat(
                      [loaded[i][f'''layers.{layer_i}.feed_forward.w1.weight'''] for i in range(lowerCAmelCase_	)]			,      dim=0	)
                  _snake_case		:	List[str]					     =     torch.cat(
                      [loaded[i][f'''layers.{layer_i}.feed_forward.w2.weight'''] for i in range(lowerCAmelCase_	)]			,      dim=1	)
                  _snake_case		:	int					     =     torch.cat(
                      [loaded[i][f'''layers.{layer_i}.feed_forward.w3.weight'''] for i in range(lowerCAmelCase_	)]			,      dim=0	)

            _snake_case		:	Dict					     =     inv_freq
            for k, v in state_dict.items():
                  _snake_case		:	List[str]					     =     filename
                  param_count += v.numel()
            torch.save(lowerCAmelCase_			,      os.path.join(lowerCAmelCase_			,      lowerCAmelCase_	)	)

      _snake_case		:	Tuple					     =     f'''pytorch_model-{n_layers + 1}-of-{n_layers + 1}.bin'''
      if model_size == "7B":
            # Unsharded
            _snake_case		:	Optional[int]					     =     {
                '''model.embed_tokens.weight''': loaded['''tok_embeddings.weight'''],
                '''model.norm.weight''': loaded['''norm.weight'''],
                '''lm_head.weight''': loaded['''output.weight'''],
            }
      else:
            _snake_case		:	Any					     =     {
                '''model.norm.weight''': loaded[0]['''norm.weight'''],
                '''model.embed_tokens.weight''': torch.cat(
                    [loaded[i]['''tok_embeddings.weight'''] for i in range(lowerCAmelCase_	)]			,      dim=1	),
                '''lm_head.weight''': torch.cat([loaded[i]['''output.weight'''] for i in range(lowerCAmelCase_	)]			,      dim=0	),
            }

      for k, v in state_dict.items():
            _snake_case		:	List[Any]					     =     filename
            param_count += v.numel()
      torch.save(lowerCAmelCase_			,      os.path.join(lowerCAmelCase_			,      lowerCAmelCase_	)	)

      # Write configs
      _snake_case		:	Optional[Any]					     =     {'''total_size''': param_count * 2}
      write_json(lowerCAmelCase_			,      os.path.join(lowerCAmelCase_			,      '''pytorch_model.bin.index.json'''	)	)
      _snake_case		:	Optional[int]					     =     params['''ffn_dim_multiplier'''] if '''ffn_dim_multiplier''' in params else 1
      _snake_case		:	str					     =     params['''multiple_of'''] if '''multiple_of''' in params else 256
      _snake_case		:	Optional[int]					     =     LlamaConfig(
          hidden_size=lowerCAmelCase_			,      intermediate_size=compute_intermediate_size(lowerCAmelCase_			,      lowerCAmelCase_			,      lowerCAmelCase_	)			,      num_attention_heads=params['''n_heads''']			,      num_hidden_layers=params['''n_layers''']			,      rms_norm_eps=params['''norm_eps''']			,      num_key_value_heads=lowerCAmelCase_			,      )
      config.save_pretrained(lowerCAmelCase_	)

      # Make space so we can load the model properly now.
      del state_dict
      del loaded
      gc.collect()

      print('''Loading the checkpoint in a Llama model.'''	)
      _snake_case		:	Optional[int]					     =     LlamaForCausalLM.from_pretrained(lowerCAmelCase_			,      torch_dtype=torch.floataa			,      low_cpu_mem_usage=lowerCAmelCase_	)
      # Avoid saving this as part of the config.
      del model.config._name_or_path

      print('''Saving in the Transformers format.'''	)
      model.save_pretrained(lowerCAmelCase_			,      safe_serialization=lowerCAmelCase_	)
      shutil.rmtree(lowerCAmelCase_	)




def    _a    (							lowerCAmelCase_			,      lowerCAmelCase_	):





      """simple docstring"""



      _snake_case		:	Optional[int]					     =     LlamaTokenizer if LlamaTokenizerFast is None else LlamaTokenizerFast
      print(f'''Saving a {tokenizer_class.__name__} to {tokenizer_path}.'''	)
      _snake_case		:	Optional[int]					     =     tokenizer_class(lowerCAmelCase_	)
      tokenizer.save_pretrained(lowerCAmelCase_	)




def    _a    (							):





      """simple docstring"""



      _snake_case		:	List[Any]					     =     argparse.ArgumentParser()
      parser.add_argument(
          '''--input_dir'''			,      help='''Location of LLaMA weights, which contains tokenizer.model and model folders'''			,      )
      parser.add_argument(
          '''--model_size'''			,      choices=['''7B''', '''7Bf''', '''13B''', '''13Bf''', '''30B''', '''65B''', '''70B''', '''70Bf''', '''tokenizer_only''']			,      )
      parser.add_argument(
          '''--output_dir'''			,      help='''Location to write HF model and tokenizer'''			,      )
      parser.add_argument('''--safe_serialization'''			,      type=lowerCAmelCase_			,      help='''Whether or not to save using `safetensors`.'''	)
      _snake_case		:	int					     =     parser.parse_args()
      if args.model_size != "tokenizer_only":
            write_model(
                model_path=args.output_dir			,      input_base_path=os.path.join(args.input_dir			,      args.model_size	)			,      model_size=args.model_size			,      safe_serialization=args.safe_serialization			,      )
      _snake_case		:	List[str]					     =     os.path.join(args.input_dir			,      '''tokenizer.model'''	)
      write_tokenizer(args.output_dir			,      lowerCAmelCase_	)


if __name__ == "__main__":
   main()









'''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


UpperCAmelCase					:		str		=							logging.getLogger(__name__)

UpperCAmelCase					:		Dict		=							5_0  # max width of layer names
UpperCAmelCase					:		Union[str, Any]		=							7_0  # max width of quantizer names




def    _a    (							lowerCAmelCase_	):





      """simple docstring"""



      _snake_case		:	Dict					     =     parser.add_argument_group('''quant_trainer arguments'''	)
      group.add_argument('''--wprec'''			,      type=lowerCAmelCase_			,      default=8			,      help='''weight precision'''	)
      group.add_argument('''--aprec'''			,      type=lowerCAmelCase_			,      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=lowerCAmelCase_			,      nargs='''+'''			,      help='''disable quantizers by keyword'''	)
      group.add_argument('''--quant-disable-layer-module'''			,      type=lowerCAmelCase_			,      help='''disable quantizers by keyword under layer.'''	)
      group.add_argument('''--quant-enable-layer-module'''			,      type=lowerCAmelCase_			,      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=lowerCAmelCase_			,      type=lowerCAmelCase_			,      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=lowerCAmelCase_			,      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    (							lowerCAmelCase_	):





      """simple docstring"""



      if args.calibrator == "max":
            _snake_case		:	Optional[int]					     =     '''max'''
      elif args.calibrator == "percentile":
            if args.percentile is None:
                  raise ValueError('''Specify --percentile when using percentile calibrator'''	)
            _snake_case		:	Tuple					     =     '''histogram'''
      elif args.calibrator == "mse":
            _snake_case		:	int					     =     '''histogram'''
      else:
            raise ValueError(f'''Invalid calibrator {args.calibrator}'''	)

      _snake_case		:	Tuple					     =     QuantDescriptor(num_bits=args.aprec			,      calib_method=lowerCAmelCase_	)
      _snake_case		:	str					     =     QuantDescriptor(num_bits=args.wprec			,      axis=(None if args.quant_per_tensor else (0,))	)
      quant_nn.QuantLinear.set_default_quant_desc_input(lowerCAmelCase_	)
      quant_nn.QuantLinear.set_default_quant_desc_weight(lowerCAmelCase_	)




def    _a    (							lowerCAmelCase_			,      lowerCAmelCase_			,      lowerCAmelCase_=False			,      lowerCAmelCase_=False	):





      """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(lowerCAmelCase_			,      ['''embeddings''']			,      which='''weight'''			,      _disabled=lowerCAmelCase_	)

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

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

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

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

            if args.recalibrate_weights:
                  recalibrate_weights(lowerCAmelCase_	)

            if args.fuse_qkv:
                  fuse_qkv(lowerCAmelCase_			,      lowerCAmelCase_	)

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

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




def    _a    (							lowerCAmelCase_	):





      """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    (							lowerCAmelCase_			,      lowerCAmelCase_	):





      """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(lowerCAmelCase_	)




def    _a    (							lowerCAmelCase_			,      lowerCAmelCase_	):





      """simple docstring"""



      def fusea(lowerCAmelCase_			,      lowerCAmelCase_			,      lowerCAmelCase_	):
            for mod in [qq, qk, qv]:
                  if not hasattr(lowerCAmelCase_			,      '''_amax'''	):
                        print('''          WARNING: NO AMAX BUFFER'''	)
                        return
            _snake_case		:	Tuple					     =     qq._amax.detach().item()
            _snake_case		:	Tuple					     =     qk._amax.detach().item()
            _snake_case		:	List[Any]					     =     qv._amax.detach().item()

            _snake_case		:	List[str]					     =     max(lowerCAmelCase_			,      lowerCAmelCase_			,      lowerCAmelCase_	)
            qq._amax.fill_(lowerCAmelCase_	)
            qk._amax.fill_(lowerCAmelCase_	)
            qv._amax.fill_(lowerCAmelCase_	)
            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    (							lowerCAmelCase_			,      lowerCAmelCase_	):





      """simple docstring"""



      for name, mod in model.named_modules():
            if name.endswith('''.output.dense'''	) and not name.endswith('''attention.output.dense'''	):
                  _snake_case		:	List[Any]					     =     mod._input_quantizer._amax.data.detach().item()
                  mod._input_quantizer._amax.data.detach().clamp_(max=lowerCAmelCase_	)
                  _snake_case		:	List[str]					     =     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    (							lowerCAmelCase_	):





      """simple docstring"""



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




def    _a    (							lowerCAmelCase_	):





      """simple docstring"""



      for name, mod in model.named_modules():
            if hasattr(lowerCAmelCase_			,      '''_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)
                  _snake_case		:	int					     =     set() if mod._weight_quantizer.axis is None else set(mod._weight_quantizer.axis	)
                  _snake_case		:	Dict					     =     set(range(len(mod.weight.size()	)	)	) - axis_set
                  _snake_case		:	Optional[int]					     =     pytorch_quantization.utils.reduce_amax(mod.weight			,      axis=lowerCAmelCase_			,      keepdims=lowerCAmelCase_	).detach()
                  logger.info(f'''RECALIB: {name:{name_width}} {mod._weight_quantizer._amax.flatten()} -> {amax.flatten()}'''	)
                  _snake_case		:	Tuple					     =     amax




def    _a    (							lowerCAmelCase_			,      lowerCAmelCase_=25			,      lowerCAmelCase_=180			,      lowerCAmelCase_=None	):





      """simple docstring"""



      if ignore is None:
            _snake_case		:	Dict					     =     []
      elif not isinstance(lowerCAmelCase_			,      lowerCAmelCase_	):
            _snake_case		:	Optional[int]					     =     [ignore]

      _snake_case		:	str					     =     0
      for name, mod in model.named_modules():
            if not hasattr(lowerCAmelCase_			,      '''weight'''	):
                  continue
            _snake_case		:	Optional[int]					     =     max(lowerCAmelCase_			,      len(lowerCAmelCase_	)	)

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




def    _a    (							lowerCAmelCase_	):





      """simple docstring"""



      _snake_case		:	str					     =     0
      for name, mod in model.named_modules():
            if isinstance(lowerCAmelCase_			,      pytorch_quantization.nn.TensorQuantizer	):
                  print(f'''{name:80} {mod}'''	)
                  count += 1
      print(f'''{count} TensorQuantizers found in model'''	)




def    _a    (							lowerCAmelCase_			,      lowerCAmelCase_			,      lowerCAmelCase_			,      lowerCAmelCase_			,      lowerCAmelCase_	):





      """simple docstring"""



      _snake_case		:	Optional[Any]					     =     getattr(lowerCAmelCase_			,      lowerCAmelCase_			,      lowerCAmelCase_	)
      if quantizer_mod is not None:
            assert hasattr(lowerCAmelCase_			,      lowerCAmelCase_	)
            setattr(lowerCAmelCase_			,      lowerCAmelCase_			,      lowerCAmelCase_	)
      else:
            logger.warning(f'''{name} has no {quantizer}'''	)




def    _a    (							lowerCAmelCase_			,      lowerCAmelCase_			,      lowerCAmelCase_="both"			,      **lowerCAmelCase_	):





      """simple docstring"""



      _snake_case		:	Optional[Any]					     =     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(lowerCAmelCase_			,      lowerCAmelCase_			,      '''_input_quantizer'''			,      lowerCAmelCase_			,      lowerCAmelCase_	)
            if which in ["weight", "both"]:
                  set_quantizer(lowerCAmelCase_			,      lowerCAmelCase_			,      '''_weight_quantizer'''			,      lowerCAmelCase_			,      lowerCAmelCase_	)
      logger.info(lowerCAmelCase_	)




def    _a    (							lowerCAmelCase_			,      lowerCAmelCase_			,      **lowerCAmelCase_	):





      """simple docstring"""



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


