


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

_snake_case          =							logging.get_logger(__name__)



def   snake_case						(				_a:     Optional[Any]		,   _a:     Optional[Any]		,   _a:     int		,   _a:     Tuple=None		,   _a:     Dict=None							)->		Optional[int]:
      '''simple docstring'''


      if "." in tensor_name:
            lowerCamelCase__           =		tensor_name.split('.'							)
            for split in splits[:-1]:
                  lowerCamelCase__           =		getattr(_a		,   _a							)
                  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(_a		,   _a							)

      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(_a							)
                  elif isinstance(_a		,   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(_a		,   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		,   _a							) and fpaa_statistics is None:
                        lowerCamelCase__           =		new_value.T

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

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

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

            if is_buffer:
                  lowerCamelCase__           =		new_value
            else:
                  lowerCamelCase__           =		nn.Parameter(_a		,   requires_grad=old_value.requires_grad							)
                  lowerCamelCase__           =		new_value



def   snake_case						(				_a:     Union[str, Any]		,   _a:     Dict=None		,   _a:     List[Any]=None		,   _a:     Dict=None		,   _a:     Any=False							)->		Dict:
      '''simple docstring'''


      for name, module in model.named_children():
            if current_key_name is None:
                  lowerCamelCase__           =		[]
            current_key_name.append(_a							)

            if (isinstance(_a		,   nn.Linear							) or isinstance(_a		,   _a							)) 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(_a							) for key in modules_to_not_convert							):
                        with init_empty_weights():
                              if isinstance(_a		,   _a							):
                                    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(
                                        _a		,   _a		,   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(
                                              _a		,   _a		,   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(_a							)
                              # Force requires grad to False to avoid unexpected errors
                              model._modules[name].requires_grad_(_a							)
            if len(list(module.children()							)							) > 0:
                  lowerCamelCase__    ,  lowerCamelCase__           =		_replace_with_bnb_linear(
                      _a		,   _a		,   _a		,   _a		,   has_been_replaced=_a		,   )
            # Remove the last key for recursion
            current_key_name.pop(-1							)
      return model, has_been_replaced



def   snake_case						(				_a:     Optional[Any]		,   _a:     str=None		,   _a:     str=None		,   _a:     Optional[Any]=None							)->		str:
      '''simple docstring'''


      lowerCamelCase__           =		['lm_head'] if modules_to_not_convert is None else modules_to_not_convert
      lowerCamelCase__    ,  lowerCamelCase__           =		_replace_with_bnb_linear(
          _a		,   _a		,   _a		,   _a							)

      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   snake_case						(				*_a:     Tuple		,   **_a:     int							)->		List[Any]:
      '''simple docstring'''


      warnings.warn(
          '`replace_8bit_linear` will be deprecated in a future version, please use `replace_with_bnb_linear` instead'		,   _a		,   )
      return replace_with_bnb_linear(*_a		,   **_a							)



def   snake_case						(				*_a:     Tuple		,   **_a:     int							)->		int:
      '''simple docstring'''


      warnings.warn(
          '`set_module_8bit_tensor_to_device` will be deprecated in a future version, please use `set_module_quantized_tensor_to_device` instead'		,   _a		,   )
      return set_module_quantized_tensor_to_device(*_a		,   **_a							)






def   snake_case						(				_a:     Optional[int]							)->		Optional[int]:
      '''simple docstring'''


      lowerCamelCase__           =		deepcopy(_a							)  # this has 0 cost since it is done inside `init_empty_weights` context manager`
      tied_model.tie_weights()

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

      # Check if it is a base model
      lowerCamelCase__           =		not hasattr(_a		,   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(_a							) - set(_a							)
      lowerCamelCase__           =		list(set(_a							)							) + list(_a							)

      # 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(_a		,   ''							)
            filtered_module_names.append(_a							)

      return filtered_module_names







"""simple docstring"""


from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tokenizers_available, is_torch_available


_snake_case          =							{
    "configuration_m2m_100": ["M2M_100_PRETRAINED_CONFIG_ARCHIVE_MAP", "M2M100Config", "M2M100OnnxConfig"],
    "tokenization_m2m_100": ["M2M100Tokenizer"],
}


try:
   if not is_torch_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   _snake_case          =							[
       "M2M_100_PRETRAINED_MODEL_ARCHIVE_LIST",
       "M2M100ForConditionalGeneration",
       "M2M100Model",
       "M2M100PreTrainedModel",
   ]


if TYPE_CHECKING:
   from .configuration_mam_aaa import M2M_100_PRETRAINED_CONFIG_ARCHIVE_MAP, MaMaaaConfig, MaMaaaOnnxConfig
   from .tokenization_mam_aaa import MaMaaaTokenizer

   try:
      if not is_torch_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .modeling_mam_aaa import (
          M2M_100_PRETRAINED_MODEL_ARCHIVE_LIST,
          MaMaaaForConditionalGeneration,
          MaMaaaModel,
          MaMaaaPreTrainedModel,
      )


else:
   import sys

   _snake_case          =							_LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)



