





"""simple docstring"""
import importlib.metadata
import warnings
from copy import deepcopy

from packaging import version

from ..utils import logging
from .import_utils import is_accelerate_available, is_bitsandbytes_available


if is_bitsandbytes_available():
       import bitsandbytes as bnb
       import torch
       import torch.nn as nn

       from ..pytorch_utils import ConvaD

if is_accelerate_available():
       from accelerate import init_empty_weights
       from accelerate.utils import find_tied_parameters

__UpperCamelCase     :						Dict						       =  logging.get_logger(__name__)

def 		_SCREAMING_SNAKE_CASE			(_UpperCAmelCase					:    Union[str, Any]  ,     _UpperCAmelCase					:    Optional[int]  ,     _UpperCAmelCase					:    str  ,     _UpperCAmelCase					:    Optional[Any]=None  ,     _UpperCAmelCase					:    Optional[Any]=None			):
 # Recurse if needed
 if "." in tensor_name:
  lowerCAmelCase    				= tensor_name.split('.'			)
  for split in splits[:-1]:
   lowerCAmelCase    				= getattr(_UpperCAmelCase  ,     _UpperCAmelCase			)
   if new_module is None:
    raise ValueError(F'{module} has no attribute {split}.'			)
   lowerCAmelCase    				= new_module
  lowerCAmelCase    				= splits[-1]

 if tensor_name not in module._parameters and tensor_name not in module._buffers:
  raise ValueError(F'{module} does not have a parameter or a buffer named {tensor_name}.'			)
 lowerCAmelCase    				= tensor_name in module._buffers
 lowerCAmelCase    				= getattr(_UpperCAmelCase  ,     _UpperCAmelCase			)

 if old_value.device == torch.device('meta'			) and device not in ["meta", torch.device('meta'			)] and value is None:
  raise ValueError(F'{tensor_name} is on the meta device, we need a `value` to put in on {device}.'			)

 lowerCAmelCase    				= False
 lowerCAmelCase    				= False
 if is_buffer or not is_bitsandbytes_available():
  lowerCAmelCase    				= False
  lowerCAmelCase    				= False
 else:
  lowerCAmelCase    				= hasattr(bnb.nn  ,     'Params4bit'			) and isinstance(module._parameters[tensor_name]  ,     bnb.nn.Paramsabit			)
  lowerCAmelCase    				= isinstance(module._parameters[tensor_name]  ,     bnb.nn.IntaParams			)

 if is_abit or is_abit:
  lowerCAmelCase    				= module._parameters[tensor_name]
  if param.device.type != "cuda":
   if value is None:
    lowerCAmelCase    				= old_value.to(_UpperCAmelCase			)
   elif isinstance(_UpperCAmelCase  ,     torch.Tensor			):
    lowerCAmelCase    				= value.to('cpu'			)
    if value.dtype == torch.inta:
     lowerCAmelCase    				= version.parse(importlib.metadata.version('bitsandbytes'			)			) > version.parse(
         '0.37.2'			)
     if not is_abit_serializable:
      raise ValueError(
          'Detected int8 weights but the version of bitsandbytes is not compatible with int8 serialization. '
          'Make sure to download the latest `bitsandbytes` version. `pip install --upgrade bitsandbytes`.'			)
   else:
    lowerCAmelCase    				= torch.tensor(_UpperCAmelCase  ,     device='cpu'			)

   # Support models using `Conv1D` in place of `nn.Linear` (e.g. gpt2) by transposing the weight matrix prior to quantization.
   # Since weights are saved in the correct "orientation", we skip transposing when loading.
   if issubclass(module.source_cls  ,     _UpperCAmelCase			) and fpaa_statistics is None:
    lowerCAmelCase    				= new_value.T

   lowerCAmelCase    				= old_value.__dict__
   if is_abit:
    lowerCAmelCase    				= bnb.nn.IntaParams(_UpperCAmelCase  ,     requires_grad=_UpperCAmelCase  ,     **_UpperCAmelCase			).to(_UpperCAmelCase			)
   elif is_abit:
    lowerCAmelCase    				= bnb.nn.Paramsabit(_UpperCAmelCase  ,     requires_grad=_UpperCAmelCase  ,     **_UpperCAmelCase			).to(_UpperCAmelCase			)

   lowerCAmelCase    				= new_value
   if fpaa_statistics is not None:
    setattr(module.weight  ,     'SCB'  ,     fpaa_statistics.to(_UpperCAmelCase			)			)

 else:
  if value is None:
   lowerCAmelCase    				= old_value.to(_UpperCAmelCase			)
  elif isinstance(_UpperCAmelCase  ,     torch.Tensor			):
   lowerCAmelCase    				= value.to(_UpperCAmelCase			)
  else:
   lowerCAmelCase    				= torch.tensor(_UpperCAmelCase  ,     device=_UpperCAmelCase			)

  if is_buffer:
   lowerCAmelCase    				= new_value
  else:
   lowerCAmelCase    				= nn.Parameter(_UpperCAmelCase  ,     requires_grad=old_value.requires_grad			)
   lowerCAmelCase    				= new_value

def 		_SCREAMING_SNAKE_CASE			(_UpperCAmelCase					:    int  ,     _UpperCAmelCase					:    Union[str, Any]=None  ,     _UpperCAmelCase					:    str=None  ,     _UpperCAmelCase					:    Optional[Any]=None  ,     _UpperCAmelCase					:    Union[str, Any]=False			):
 for name, module in model.named_children():
  if current_key_name is None:
   lowerCAmelCase    				= []
  current_key_name.append(_UpperCAmelCase			)

  if (isinstance(_UpperCAmelCase  ,     nn.Linear			) or isinstance(_UpperCAmelCase  ,     _UpperCAmelCase			)) and name not in modules_to_not_convert:
   # Check if the current key is not in the `modules_to_not_convert`
   if not any(key in '.'.join(_UpperCAmelCase			) for key in modules_to_not_convert			):
    with init_empty_weights():
     if isinstance(_UpperCAmelCase  ,     _UpperCAmelCase			):
      lowerCAmelCase				,lowerCAmelCase    				= module.weight.shape
     else:
      lowerCAmelCase    				= module.in_features
      lowerCAmelCase    				= module.out_features

     if quantization_config.quantization_method() == "llm_int8":
      lowerCAmelCase    				= bnb.nn.LinearabitLt(
          _UpperCAmelCase  ,     _UpperCAmelCase  ,     module.bias is not None  ,     has_fpaa_weights=quantization_config.llm_inta_has_fpaa_weight  ,     threshold=quantization_config.llm_inta_threshold  ,     )
      lowerCAmelCase    				= True
     else:
      if (
          quantization_config.llm_inta_skip_modules is not None
          and name in quantization_config.llm_inta_skip_modules
      ):
       pass
      else:
       lowerCAmelCase    				= bnb.nn.Linearabit(
           _UpperCAmelCase  ,     _UpperCAmelCase  ,     module.bias is not None  ,     quantization_config.bnb_abit_compute_dtype  ,     compress_statistics=quantization_config.bnb_abit_use_double_quant  ,     quant_type=quantization_config.bnb_abit_quant_type  ,     )
       lowerCAmelCase    				= True
                    # Store the module class in case we need to transpose the weight later
     lowerCAmelCase    				= type(_UpperCAmelCase			)
     # Force requires grad to False to avoid unexpected errors
     model._modules[name].requires_grad_(_UpperCAmelCase			)
  if len(list(module.children()			)			) > 0:
   lowerCAmelCase				,lowerCAmelCase    				= _replace_with_bnb_linear(
       _UpperCAmelCase  ,     _UpperCAmelCase  ,     _UpperCAmelCase  ,     _UpperCAmelCase  ,     has_been_replaced=_UpperCAmelCase  ,     )
  # Remove the last key for recursion
  current_key_name.pop(-1			)
 return model, has_been_replaced

def 		_SCREAMING_SNAKE_CASE			(_UpperCAmelCase					:    Optional[int]  ,     _UpperCAmelCase					:    Tuple=None  ,     _UpperCAmelCase					:    str=None  ,     _UpperCAmelCase					:    List[Any]=None			):
 lowerCAmelCase    				= ['lm_head'] if modules_to_not_convert is None else modules_to_not_convert
 lowerCAmelCase				,lowerCAmelCase    				= _replace_with_bnb_linear(
     _UpperCAmelCase  ,     _UpperCAmelCase  ,     _UpperCAmelCase  ,     _UpperCAmelCase			)

 if not has_been_replaced:
  logger.warning(
      'You are loading your model in 8bit or 4bit but no linear modules were found in your model.'
      ' Please double check your model architecture, or submit an issue on github if you think this is'
      ' a bug.'			)

 return model

def 		_SCREAMING_SNAKE_CASE			(*_UpperCAmelCase					:    List[Any]  ,     **_UpperCAmelCase					:    str			):
 warnings.warn(
     '`replace_8bit_linear` will be deprecated in a future version, please use `replace_with_bnb_linear` instead'  ,     _UpperCAmelCase  ,     )
 return replace_with_bnb_linear(*_UpperCAmelCase  ,     **_UpperCAmelCase			)

def 		_SCREAMING_SNAKE_CASE			(*_UpperCAmelCase					:    List[Any]  ,     **_UpperCAmelCase					:    Optional[int]			):
 warnings.warn(
     '`set_module_8bit_tensor_to_device` will be deprecated in a future version, please use `set_module_quantized_tensor_to_device` instead'  ,     _UpperCAmelCase  ,     )
 return set_module_quantized_tensor_to_device(*_UpperCAmelCase  ,     **_UpperCAmelCase			)




def 		_SCREAMING_SNAKE_CASE			(_UpperCAmelCase					:    int			):
 lowerCAmelCase    				= deepcopy(_UpperCAmelCase			)  # this has 0 cost since it is done inside `init_empty_weights` context manager`
 tied_model.tie_weights()

 lowerCAmelCase    				= find_tied_parameters(_UpperCAmelCase			)
 # For compatibility with Accelerate < 0.18
 if isinstance(_UpperCAmelCase  ,     _UpperCAmelCase			):
  lowerCAmelCase    				= sum(list(tied_params.values()			)  ,     []			) + list(tied_params.keys()			)
 else:
  lowerCAmelCase    				= sum(_UpperCAmelCase  ,     []			)
 lowerCAmelCase    				= len(_UpperCAmelCase			) > 0

 # Check if it is a base model
 lowerCAmelCase    				= not hasattr(_UpperCAmelCase  ,     model.base_model_prefix			)

 # Ignore this for base models (BertModel, GPT2Model, etc.)
 if (not has_tied_params) and is_base_model:
  return []

 # otherwise they have an attached head
 lowerCAmelCase    				= list(model.named_children()			)
 lowerCAmelCase    				= [list_modules[-1][0]]

 # add last module together with tied weights
 lowerCAmelCase    				= set(_UpperCAmelCase			) - set(_UpperCAmelCase			)
 lowerCAmelCase    				= list(set(_UpperCAmelCase			)			) + list(_UpperCAmelCase			)

 # remove ".weight" from the keys
 lowerCAmelCase    				= ['.weight', '.bias']
 lowerCAmelCase    				= []
 for name in list_untouched:
  for name_to_remove in names_to_remove:
   if name_to_remove in name:
    lowerCAmelCase    				= name.replace(_UpperCAmelCase  ,     ''			)
  filtered_module_names.append(_UpperCAmelCase			)

 return filtered_module_names











from google.protobuf import descriptor as _descriptor
from google.protobuf import descriptor_pool as _descriptor_pool
from google.protobuf import symbol_database as _symbol_database
from google.protobuf.internal import builder as _builder


# @@protoc_insertion_point(imports)

SCREAMING_SNAKE_CASE:     str									= _symbol_database.Default()


SCREAMING_SNAKE_CASE:     Dict									= _descriptor_pool.Default().AddSerializedFile(
    b'''\n\x19sentencepiece_model.proto\x12\rsentencepiece"\x80\x0c\n\x0bTrainerSpec\x12\r\n\x05input\x18\x01 \x03(\t\x12\x14\n\x0cinput_format\x18\x07 \x01(\t\x12\x14\n\x0cmodel_prefix\x18\x02 \x01(\t\x12\x41\n\nmodel_type\x18\x03 \x01(\x0e\x32$.sentencepiece.TrainerSpec.ModelType:\x07UNIGRAM\x12\x18\n\nvocab_size\x18\x04 \x01(\x05:\x04\x38\x30\x30\x30\x12\x17\n\x0f\x61\x63\x63\x65pt_language\x18\x05 \x03(\t\x12 \n\x15self_test_sample_size\x18\x06 \x01(\x05:\x01\x30\x12*\n\x1b\x65nable_differential_privacy\x18\x32 \x01(\x08:\x05\x66\x61lse\x12+\n differential_privacy_noise_level\x18\x33 \x01(\x02:\x01\x30\x12\x32\n\'differential_privacy_clipping_threshold\x18\x34 \x01(\x04:\x01\x30\x12"\n\x12\x63haracter_coverage\x18\n \x01(\x02:\x06\x30.9995\x12\x1e\n\x13input_sentence_size\x18\x0b \x01(\x04:\x01\x30\x12$\n\x16shuffle_input_sentence\x18\x13 \x01(\x08:\x04true\x12 \n\x14mining_sentence_size\x18\x0c \x01(\x05\x42\x02\x18\x01\x12"\n\x16training_sentence_size\x18\r \x01(\x05\x42\x02\x18\x01\x12(\n\x17seed_sentencepiece_size\x18\x0e \x01(\x05:\x07\x31\x30\x30\x30\x30\x30\x30\x12\x1e\n\x10shrinking_factor\x18\x0f \x01(\x02:\x04\x30.75\x12!\n\x13max_sentence_length\x18\x12 \x01(\x05:\x04\x34\x31\x39\x32\x12\x17\n\x0bnum_threads\x18\x10 \x01(\x05:\x02\x31\x36\x12\x1d\n\x12num_sub_iterations\x18\x11 \x01(\x05:\x01\x32\x12$\n\x18max_sentencepiece_length\x18\x14 \x01(\x05:\x02\x31\x36\x12%\n\x17split_by_unicode_script\x18\x15 \x01(\x08:\x04true\x12\x1d\n\x0fsplit_by_number\x18\x17 \x01(\x08:\x04true\x12!\n\x13split_by_whitespace\x18\x16 \x01(\x08:\x04true\x12)\n\x1atreat_whitespace_as_suffix\x18\x18 \x01(\x08:\x05\x66\x61lse\x12+\n\x1c\x61llow_whitespace_only_pieces\x18\x1a \x01(\x08:\x05\x66\x61lse\x12\x1b\n\x0csplit_digits\x18\x19 \x01(\x08:\x05\x66\x61lse\x12#\n\x19pretokenization_delimiter\x18\x35 \x01(\t:\x00\x12\x17\n\x0f\x63ontrol_symbols\x18\x1e \x03(\t\x12\x1c\n\x14user_defined_symbols\x18\x1f \x03(\t\x12\x16\n\x0erequired_chars\x18$ \x01(\t\x12\x1c\n\rbyte_fallback\x18# \x01(\x08:\x05\x66\x61lse\x12+\n\x1dvocabulary_output_piece_score\x18  \x01(\x08:\x04true\x12\x1e\n\x10hard_vocab_limit\x18! \x01(\x08:\x04true\x12\x1c\n\ruse_all_vocab\x18" \x01(\x08:\x05\x66\x61lse\x12\x11\n\x06unk_id\x18( \x01(\x05:\x01\x30\x12\x11\n\x06\x62os_id\x18) \x01(\x05:\x01\x31\x12\x11\n\x06\x65os_id\x18* \x01(\x05:\x01\x32\x12\x12\n\x06pad_id\x18+ \x01(\x05:\x02-1\x12\x18\n\tunk_piece\x18- \x01(\t:\x05<unk>\x12\x16\n\tbos_piece\x18. \x01(\t:\x03<s>\x12\x17\n\teos_piece\x18/ \x01(\t:\x04</s>\x12\x18\n\tpad_piece\x18\x30 \x01(\t:\x05<pad>\x12\x1a\n\x0bunk_surface\x18, \x01(\t:\x05 \xe2\x81\x87 \x12+\n\x1ctrain_extremely_large_corpus\x18\x31 \x01(\x08:\x05\x66\x61lse"5\n\tModelType\x12\x0b\n\x07UNIGRAM\x10\x01\x12\x07\n\x03\x42PE\x10\x02\x12\x08\n\x04WORD\x10\x03\x12\x08\n\x04\x43HAR\x10\x04*\t\x08\xc8\x01\x10\x80\x80\x80\x80\x02"\xd1\x01\n\x0eNormalizerSpec\x12\x0c\n\x04name\x18\x01 \x01(\t\x12\x1c\n\x14precompiled_charsmap\x18\x02 \x01(\x0c\x12\x1e\n\x10\x61\x64\x64_dummy_prefix\x18\x03 \x01(\x08:\x04true\x12&\n\x18remove_extra_whitespaces\x18\x04 \x01(\x08:\x04true\x12 \n\x12\x65scape_whitespaces\x18\x05 \x01(\x08:\x04true\x12\x1e\n\x16normalization_rule_tsv\x18\x06 \x01(\t*\t\x08\xc8\x01\x10\x80\x80\x80\x80\x02"y\n\x0cSelfTestData\x12\x33\n\x07samples\x18\x01 \x03(\x0b\x32".sentencepiece.SelfTestData.Sample\x1a)\n\x06Sample\x12\r\n\x05input\x18\x01 \x01(\t\x12\x10\n\x08\x65xpected\x18\x02 \x01(\t*\t\x08\xc8\x01\x10\x80\x80\x80\x80\x02"\xfe\x03\n\nModelProto\x12\x37\n\x06pieces\x18\x01 \x03(\x0b\x32\'.sentencepiece.ModelProto.SentencePiece\x12\x30\n\x0ctrainer_spec\x18\x02 \x01(\x0b\x32\x1a.sentencepiece.TrainerSpec\x12\x36\n\x0fnormalizer_spec\x18\x03 \x01(\x0b\x32\x1d.sentencepiece.NormalizerSpec\x12\x33\n\x0eself_test_data\x18\x04 \x01(\x0b\x32\x1b.sentencepiece.SelfTestData\x12\x38\n\x11\x64\x65normalizer_spec\x18\x05 \x01(\x0b\x32\x1d.sentencepiece.NormalizerSpec\x1a\xd2\x01\n\rSentencePiece\x12\r\n\x05piece\x18\x01 \x01(\t\x12\r\n\x05score\x18\x02 \x01(\x02\x12\x42\n\x04type\x18\x03 \x01(\x0e\x32,.sentencepiece.ModelProto.SentencePiece.Type:\x06NORMAL"T\n\x04Type\x12\n\n\x06NORMAL\x10\x01\x12\x0b\n\x07UNKNOWN\x10\x02\x12\x0b\n\x07\x43ONTROL\x10\x03\x12\x10\n\x0cUSER_DEFINED\x10\x04\x12\x08\n\x04\x42YTE\x10\x06\x12\n\n\x06UNUSED\x10\x05*\t\x08\xc8\x01\x10\x80\x80\x80\x80\x02*\t\x08\xc8\x01\x10\x80\x80\x80\x80\x02\x42\x02H\x03'''
)

SCREAMING_SNAKE_CASE:     Optional[Any]									= globals()
_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, '''sentencepiece_model_pb2''', _globals)
if _descriptor._USE_C_DESCRIPTORS is False:
						SCREAMING_SNAKE_CASE:     List[Any]									= None
						SCREAMING_SNAKE_CASE:     str									= b'''H\003'''
						# (generated by protobuf compiler, but `_TRAINERSPEC` is not defined)
						# _TRAINERSPEC.fields_by_name["mining_sentence_size"]._options = None
						# _TRAINERSPEC.fields_by_name["mining_sentence_size"]._serialized_options = b"\030\001"
						# _TRAINERSPEC.fields_by_name["training_sentence_size"]._options = None
						# _TRAINERSPEC.fields_by_name["training_sentence_size"]._serialized_options = b"\030\001"
						SCREAMING_SNAKE_CASE:     List[Any]									= 4_5
						SCREAMING_SNAKE_CASE:     List[Any]									= 1_5_8_1
						SCREAMING_SNAKE_CASE:     Union[str, Any]									= 1_5_1_7
						SCREAMING_SNAKE_CASE:     Any									= 1_5_7_0
						SCREAMING_SNAKE_CASE:     Union[str, Any]									= 1_5_8_4
						SCREAMING_SNAKE_CASE:     str									= 1_7_9_3
						SCREAMING_SNAKE_CASE:     List[Any]									= 1_7_9_5
						SCREAMING_SNAKE_CASE:     Any									= 1_9_1_6
						SCREAMING_SNAKE_CASE:     Optional[Any]									= 1_8_6_4
						SCREAMING_SNAKE_CASE:     Union[str, Any]									= 1_9_0_5
						SCREAMING_SNAKE_CASE:     str									= 1_9_1_9
						SCREAMING_SNAKE_CASE:     Any									= 2_4_2_9
						SCREAMING_SNAKE_CASE:     Dict									= 2_2_0_8
						SCREAMING_SNAKE_CASE:     Optional[Any]									= 2_4_1_8
						SCREAMING_SNAKE_CASE:     Optional[Any]									= 2_3_2_3
						SCREAMING_SNAKE_CASE:     Tuple									= 2_4_0_7
# @@protoc_insertion_point(module_scope)